Add files using upload-large-folder tool

external/Grounded-Segment-Anything/playground/ImageBind_SAM/models/helpers.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+# Portions Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import math
+
+import einops
+import numpy as np
+import torch
+
+import torch.nn as nn
+
+
+class Normalize(nn.Module):
+    def __init__(self, dim: int) -> None:
+        super().__init__()
+        self.dim = dim
+
+    def forward(self, x):
+        return torch.nn.functional.normalize(x, dim=self.dim, p=2)
+
+
+class LearnableLogitScaling(nn.Module):
+    def __init__(
+        self,
+        logit_scale_init: float = 1 / 0.07,
+        learnable: bool = True,
+        max_logit_scale: float = 100,
+    ) -> None:
+        super().__init__()
+        self.max_logit_scale = max_logit_scale
+        self.logit_scale_init = logit_scale_init
+        self.learnable = learnable
+        log_logit_scale = torch.ones([]) * np.log(self.logit_scale_init)
+        if learnable:
+            self.log_logit_scale = nn.Parameter(log_logit_scale)
+        else:
+            self.register_buffer("log_logit_scale", log_logit_scale)
+
+    def forward(self, x):
+        return torch.clip(self.log_logit_scale.exp(), max=self.max_logit_scale) * x
+
+    def extra_repr(self):
+        st = f"logit_scale_init={self.logit_scale_init},learnable={self.learnable}, max_logit_scale={self.max_logit_scale}"
+        return st
+
+
+class EinOpsRearrange(nn.Module):
+    def __init__(self, rearrange_expr: str, **kwargs) -> None:
+        super().__init__()
+        self.rearrange_expr = rearrange_expr
+        self.kwargs = kwargs
+
+    def forward(self, x):
+        assert isinstance(x, torch.Tensor)
+        return einops.rearrange(x, self.rearrange_expr, **self.kwargs)
+
+
+class VerboseNNModule(nn.Module):
+    """
+    Wrapper around nn.Module that prints registered buffers and parameter names.
+    """
+
+    @staticmethod
+    def get_readable_tensor_repr(name: str, tensor: torch.Tensor) -> str:
+        st = (
+            "("
+            + name
+            + "): "
+            + "tensor("
+            + str(tuple(tensor[1].shape))
+            + ", requires_grad="
+            + str(tensor[1].requires_grad)
+            + ")\n"
+        )
+        return st
+
+    def extra_repr(self) -> str:
+        named_modules = set()
+        for p in self.named_modules():
+            named_modules.update([p[0]])
+        named_modules = list(named_modules)
+
+        string_repr = ""
+        for p in self.named_parameters():
+            name = p[0].split(".")[0]
+            if name not in named_modules:
+                string_repr += self.get_readable_tensor_repr(name, p)
+
+        for p in self.named_buffers():
+            name = p[0].split(".")[0]
+            string_repr += self.get_readable_tensor_repr(name, p)
+
+        return string_repr
+
+
+def cast_if_src_dtype(
+    tensor: torch.Tensor, src_dtype: torch.dtype, tgt_dtype: torch.dtype
+):
+    updated = False
+    if tensor.dtype == src_dtype:
+        tensor = tensor.to(dtype=tgt_dtype)
+        updated = True
+    return tensor, updated
+
+
+class QuickGELU(nn.Module):
+    # From https://github.com/openai/CLIP/blob/d50d76daa670286dd6cacf3bcd80b5e4823fc8e1/clip/model.py#L166
+    def forward(self, x: torch.Tensor):
+        return x * torch.sigmoid(1.702 * x)
+
+
+class SelectElement(nn.Module):
+    def __init__(self, index) -> None:
+        super().__init__()
+        self.index = index
+
+    def forward(self, x):
+        assert x.ndim >= 3
+        return x[:, self.index, ...]
+
+
+class SelectEOSAndProject(nn.Module):
+    """
+    Text Pooling used in OpenCLIP
+    """
+
+    def __init__(self, proj: nn.Module) -> None:
+        super().__init__()
+        self.proj = proj
+
+    def forward(self, x, seq_len):
+        assert x.ndim == 3
+        # x is of shape B x L x D
+        # take features from the eot embedding (eot_token is the highest number in each sequence)
+        x = x[torch.arange(x.shape[0]), seq_len]
+        x = self.proj(x)
+        return x

external/Grounded-Segment-Anything/playground/ImageBind_SAM/models/imagebind_model.py

@@ -0,0 +1,517 @@
+#!/usr/bin/env python3
+# Portions Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+import os
+import urllib
+from functools import partial
+from types import SimpleNamespace
+
+import torch
+import torch.nn as nn
+
+from models.helpers import (
+    EinOpsRearrange,
+    LearnableLogitScaling,
+    Normalize,
+    SelectElement,
+    SelectEOSAndProject,
+)
+from models.multimodal_preprocessors import (
+    AudioPreprocessor,
+    IMUPreprocessor,
+    PadIm2Video,
+    PatchEmbedGeneric,
+    RGBDTPreprocessor,
+    SpatioTemporalPosEmbeddingHelper,
+    TextPreprocessor,
+    ThermalPreprocessor,
+)
+
+from models.transformer import MultiheadAttention, SimpleTransformer
+
+
+ModalityType = SimpleNamespace(
+    VISION="vision",
+    TEXT="text",
+    AUDIO="audio",
+    THERMAL="thermal",
+    DEPTH="depth",
+    IMU="imu",
+)
+
+
+class ImageBindModel(nn.Module):
+    def __init__(
+        self,
+        video_frames=2,
+        kernel_size=(2, 14, 14),
+        audio_kernel_size=16,
+        audio_stride=10,
+        out_embed_dim=768,
+        vision_embed_dim=1024,
+        vision_num_blocks=24,
+        vision_num_heads=16,
+        audio_embed_dim=768,
+        audio_num_blocks=12,
+        audio_num_heads=12,
+        audio_num_mel_bins=128,
+        audio_target_len=204,
+        audio_drop_path=0.1,
+        text_embed_dim=768,
+        text_num_blocks=12,
+        text_num_heads=12,
+        depth_embed_dim=384,
+        depth_kernel_size=16,
+        depth_num_blocks=12,
+        depth_num_heads=8,
+        depth_drop_path=0.0,
+        thermal_embed_dim=768,
+        thermal_kernel_size=16,
+        thermal_num_blocks=12,
+        thermal_num_heads=12,
+        thermal_drop_path=0.0,
+        imu_embed_dim=512,
+        imu_kernel_size=8,
+        imu_num_blocks=6,
+        imu_num_heads=8,
+        imu_drop_path=0.7,
+    ):
+        super().__init__()
+
+        self.modality_preprocessors = self._create_modality_preprocessors(
+            video_frames,
+            vision_embed_dim,
+            kernel_size,
+            text_embed_dim,
+            audio_embed_dim,
+            audio_kernel_size,
+            audio_stride,
+            audio_num_mel_bins,
+            audio_target_len,
+            depth_embed_dim,
+            depth_kernel_size,
+            thermal_embed_dim,
+            thermal_kernel_size,
+            imu_embed_dim,
+        )
+
+        self.modality_trunks = self._create_modality_trunks(
+            vision_embed_dim,
+            vision_num_blocks,
+            vision_num_heads,
+            text_embed_dim,
+            text_num_blocks,
+            text_num_heads,
+            audio_embed_dim,
+            audio_num_blocks,
+            audio_num_heads,
+            audio_drop_path,
+            depth_embed_dim,
+            depth_num_blocks,
+            depth_num_heads,
+            depth_drop_path,
+            thermal_embed_dim,
+            thermal_num_blocks,
+            thermal_num_heads,
+            thermal_drop_path,
+            imu_embed_dim,
+            imu_num_blocks,
+            imu_num_heads,
+            imu_drop_path,
+        )
+
+        self.modality_heads = self._create_modality_heads(
+            out_embed_dim,
+            vision_embed_dim,
+            text_embed_dim,
+            audio_embed_dim,
+            depth_embed_dim,
+            thermal_embed_dim,
+            imu_embed_dim,
+        )
+
+        self.modality_postprocessors = self._create_modality_postprocessors(
+            out_embed_dim
+        )
+
+    def _create_modality_preprocessors(
+        self,
+        video_frames=2,
+        vision_embed_dim=1024,
+        kernel_size=(2, 14, 14),
+        text_embed_dim=768,
+        audio_embed_dim=768,
+        audio_kernel_size=16,
+        audio_stride=10,
+        audio_num_mel_bins=128,
+        audio_target_len=204,
+        depth_embed_dim=768,
+        depth_kernel_size=16,
+        thermal_embed_dim=768,
+        thermal_kernel_size=16,
+        imu_embed_dim=512,
+    ):
+        rgbt_stem = PatchEmbedGeneric(
+            proj_stem=[
+                PadIm2Video(pad_type="repeat", ntimes=2),
+                nn.Conv3d(
+                    in_channels=3,
+                    kernel_size=kernel_size,
+                    out_channels=vision_embed_dim,
+                    stride=kernel_size,
+                    bias=False,
+                ),
+            ]
+        )
+        rgbt_preprocessor = RGBDTPreprocessor(
+            img_size=[3, video_frames, 224, 224],
+            num_cls_tokens=1,
+            pos_embed_fn=partial(SpatioTemporalPosEmbeddingHelper, learnable=True),
+            rgbt_stem=rgbt_stem,
+            depth_stem=None,
+        )
+
+        text_preprocessor = TextPreprocessor(
+            context_length=77,
+            vocab_size=49408,
+            embed_dim=text_embed_dim,
+            causal_masking=True,
+        )
+
+        audio_stem = PatchEmbedGeneric(
+            proj_stem=[
+                nn.Conv2d(
+                    in_channels=1,
+                    kernel_size=audio_kernel_size,
+                    stride=audio_stride,
+                    out_channels=audio_embed_dim,
+                    bias=False,
+                ),
+            ],
+            norm_layer=nn.LayerNorm(normalized_shape=audio_embed_dim),
+        )
+        audio_preprocessor = AudioPreprocessor(
+            img_size=[1, audio_num_mel_bins, audio_target_len],
+            num_cls_tokens=1,
+            pos_embed_fn=partial(SpatioTemporalPosEmbeddingHelper, learnable=True),
+            audio_stem=audio_stem,
+        )
+
+        depth_stem = PatchEmbedGeneric(
+            [
+                nn.Conv2d(
+                    kernel_size=depth_kernel_size,
+                    in_channels=1,
+                    out_channels=depth_embed_dim,
+                    stride=depth_kernel_size,
+                    bias=False,
+                ),
+            ],
+            norm_layer=nn.LayerNorm(normalized_shape=depth_embed_dim),
+        )
+
+        depth_preprocessor = RGBDTPreprocessor(
+            img_size=[1, 224, 224],
+            num_cls_tokens=1,
+            pos_embed_fn=partial(SpatioTemporalPosEmbeddingHelper, learnable=True),
+            rgbt_stem=None,
+            depth_stem=depth_stem,
+        )
+
+        thermal_stem = PatchEmbedGeneric(
+            [
+                nn.Conv2d(
+                    kernel_size=thermal_kernel_size,
+                    in_channels=1,
+                    out_channels=thermal_embed_dim,
+                    stride=thermal_kernel_size,
+                    bias=False,
+                ),
+            ],
+            norm_layer=nn.LayerNorm(normalized_shape=thermal_embed_dim),
+        )
+        thermal_preprocessor = ThermalPreprocessor(
+            img_size=[1, 224, 224],
+            num_cls_tokens=1,
+            pos_embed_fn=partial(SpatioTemporalPosEmbeddingHelper, learnable=True),
+            thermal_stem=thermal_stem,
+        )
+
+        imu_stem = PatchEmbedGeneric(
+            [
+                nn.Linear(
+                    in_features=48,
+                    out_features=imu_embed_dim,
+                    bias=False,
+                ),
+            ],
+            norm_layer=nn.LayerNorm(normalized_shape=imu_embed_dim),
+        )
+
+        imu_preprocessor = IMUPreprocessor(
+            img_size=[6, 2000],
+            num_cls_tokens=1,
+            kernel_size=8,
+            embed_dim=imu_embed_dim,
+            pos_embed_fn=partial(SpatioTemporalPosEmbeddingHelper, learnable=True),
+            imu_stem=imu_stem,
+        )
+
+        modality_preprocessors = {
+            ModalityType.VISION: rgbt_preprocessor,
+            ModalityType.TEXT: text_preprocessor,
+            ModalityType.AUDIO: audio_preprocessor,
+            ModalityType.DEPTH: depth_preprocessor,
+            ModalityType.THERMAL: thermal_preprocessor,
+            ModalityType.IMU: imu_preprocessor,
+        }
+
+        return nn.ModuleDict(modality_preprocessors)
+
+    def _create_modality_trunks(
+        self,
+        vision_embed_dim=1024,
+        vision_num_blocks=24,
+        vision_num_heads=16,
+        text_embed_dim=768,
+        text_num_blocks=12,
+        text_num_heads=12,
+        audio_embed_dim=768,
+        audio_num_blocks=12,
+        audio_num_heads=12,
+        audio_drop_path=0.0,
+        depth_embed_dim=768,
+        depth_num_blocks=12,
+        depth_num_heads=12,
+        depth_drop_path=0.0,
+        thermal_embed_dim=768,
+        thermal_num_blocks=12,
+        thermal_num_heads=12,
+        thermal_drop_path=0.0,
+        imu_embed_dim=512,
+        imu_num_blocks=6,
+        imu_num_heads=8,
+        imu_drop_path=0.7,
+    ):
+        def instantiate_trunk(
+            embed_dim, num_blocks, num_heads, pre_transformer_ln, add_bias_kv, drop_path
+        ):
+            return SimpleTransformer(
+                embed_dim=embed_dim,
+                num_blocks=num_blocks,
+                ffn_dropout_rate=0.0,
+                drop_path_rate=drop_path,
+                attn_target=partial(
+                    MultiheadAttention,
+                    embed_dim=embed_dim,
+                    num_heads=num_heads,
+                    bias=True,
+                    add_bias_kv=add_bias_kv,
+                ),
+                pre_transformer_layer=nn.Sequential(
+                    nn.LayerNorm(embed_dim, eps=1e-6)
+                    if pre_transformer_ln
+                    else nn.Identity(),
+                    EinOpsRearrange("b l d -> l b d"),
+                ),
+                post_transformer_layer=EinOpsRearrange("l b d -> b l d"),
+            )
+
+        modality_trunks = {}
+        modality_trunks[ModalityType.VISION] = instantiate_trunk(
+            vision_embed_dim,
+            vision_num_blocks,
+            vision_num_heads,
+            pre_transformer_ln=True,
+            add_bias_kv=False,
+            drop_path=0.0,
+        )
+        modality_trunks[ModalityType.TEXT] = instantiate_trunk(
+            text_embed_dim,
+            text_num_blocks,
+            text_num_heads,
+            pre_transformer_ln=False,
+            add_bias_kv=False,
+            drop_path=0.0,
+        )
+        modality_trunks[ModalityType.AUDIO] = instantiate_trunk(
+            audio_embed_dim,
+            audio_num_blocks,
+            audio_num_heads,
+            pre_transformer_ln=False,
+            add_bias_kv=True,
+            drop_path=audio_drop_path,
+        )
+        modality_trunks[ModalityType.DEPTH] = instantiate_trunk(
+            depth_embed_dim,
+            depth_num_blocks,
+            depth_num_heads,
+            pre_transformer_ln=False,
+            add_bias_kv=True,
+            drop_path=depth_drop_path,
+        )
+        modality_trunks[ModalityType.THERMAL] = instantiate_trunk(
+            thermal_embed_dim,
+            thermal_num_blocks,
+            thermal_num_heads,
+            pre_transformer_ln=False,
+            add_bias_kv=True,
+            drop_path=thermal_drop_path,
+        )
+        modality_trunks[ModalityType.IMU] = instantiate_trunk(
+            imu_embed_dim,
+            imu_num_blocks,
+            imu_num_heads,
+            pre_transformer_ln=False,
+            add_bias_kv=True,
+            drop_path=imu_drop_path,
+        )
+
+        return nn.ModuleDict(modality_trunks)
+
+    def _create_modality_heads(
+        self,
+        out_embed_dim,
+        vision_embed_dim,
+        text_embed_dim,
+        audio_embed_dim,
+        depth_embed_dim,
+        thermal_embed_dim,
+        imu_embed_dim,
+    ):
+        modality_heads = {}
+
+        modality_heads[ModalityType.VISION] = nn.Sequential(
+            nn.LayerNorm(normalized_shape=vision_embed_dim, eps=1e-6),
+            SelectElement(index=0),
+            nn.Linear(vision_embed_dim, out_embed_dim, bias=False),
+        )
+
+        modality_heads[ModalityType.TEXT] = SelectEOSAndProject(
+            proj=nn.Sequential(
+                nn.LayerNorm(normalized_shape=text_embed_dim, eps=1e-6),
+                nn.Linear(text_embed_dim, out_embed_dim, bias=False),
+            )
+        )
+
+        modality_heads[ModalityType.AUDIO] = nn.Sequential(
+            nn.LayerNorm(normalized_shape=audio_embed_dim, eps=1e-6),
+            SelectElement(index=0),
+            nn.Linear(audio_embed_dim, out_embed_dim, bias=False),
+        )
+
+        modality_heads[ModalityType.DEPTH] = nn.Sequential(
+            nn.LayerNorm(normalized_shape=depth_embed_dim, eps=1e-6),
+            SelectElement(index=0),
+            nn.Linear(depth_embed_dim, out_embed_dim, bias=False),
+        )
+
+        modality_heads[ModalityType.THERMAL] = nn.Sequential(
+            nn.LayerNorm(normalized_shape=thermal_embed_dim, eps=1e-6),
+            SelectElement(index=0),
+            nn.Linear(thermal_embed_dim, out_embed_dim, bias=False),
+        )
+
+        modality_heads[ModalityType.IMU] = nn.Sequential(
+            nn.LayerNorm(normalized_shape=imu_embed_dim, eps=1e-6),
+            SelectElement(index=0),
+            nn.Dropout(p=0.5),
+            nn.Linear(imu_embed_dim, out_embed_dim, bias=False),
+        )
+
+        return nn.ModuleDict(modality_heads)
+
+    def _create_modality_postprocessors(self, out_embed_dim):
+        modality_postprocessors = {}
+
+        modality_postprocessors[ModalityType.VISION] = Normalize(dim=-1)
+        modality_postprocessors[ModalityType.TEXT] = nn.Sequential(
+            Normalize(dim=-1), LearnableLogitScaling(learnable=True)
+        )
+        modality_postprocessors[ModalityType.AUDIO] = nn.Sequential(
+            Normalize(dim=-1),
+            LearnableLogitScaling(logit_scale_init=20.0, learnable=False),
+        )
+        modality_postprocessors[ModalityType.DEPTH] = nn.Sequential(
+            Normalize(dim=-1),
+            LearnableLogitScaling(logit_scale_init=5.0, learnable=False),
+        )
+        modality_postprocessors[ModalityType.THERMAL] = nn.Sequential(
+            Normalize(dim=-1),
+            LearnableLogitScaling(logit_scale_init=10.0, learnable=False),
+        )
+        modality_postprocessors[ModalityType.IMU] = nn.Sequential(
+            Normalize(dim=-1),
+            LearnableLogitScaling(logit_scale_init=5.0, learnable=False),
+        )
+
+        return nn.ModuleDict(modality_postprocessors)
+
+    def forward(self, inputs):
+        outputs = {}
+        for modality_key, modality_value in inputs.items():
+            reduce_list = (
+                modality_value.ndim >= 5
+            )  # Audio and Video inputs consist of multiple clips
+            if reduce_list:
+                B, S = modality_value.shape[:2]
+                modality_value = modality_value.reshape(
+                    B * S, *modality_value.shape[2:]
+                )
+
+            if modality_value is not None:
+                modality_value = self.modality_preprocessors[modality_key](
+                    **{modality_key: modality_value}
+                )
+                trunk_inputs = modality_value["trunk"]
+                head_inputs = modality_value["head"]
+                modality_value = self.modality_trunks[modality_key](**trunk_inputs)
+                modality_value = self.modality_heads[modality_key](
+                    modality_value, **head_inputs
+                )
+                modality_value = self.modality_postprocessors[modality_key](
+                    modality_value
+                )
+
+                if reduce_list:
+                    modality_value = modality_value.reshape(B, S, -1)
+                    modality_value = modality_value.mean(dim=1)
+
+                outputs[modality_key] = modality_value
+
+        return outputs
+
+
+def imagebind_huge(pretrained=False):
+    model = ImageBindModel(
+        vision_embed_dim=1280,
+        vision_num_blocks=32,
+        vision_num_heads=16,
+        text_embed_dim=1024,
+        text_num_blocks=24,
+        text_num_heads=16,
+        out_embed_dim=1024,
+        audio_drop_path=0.1,
+        imu_drop_path=0.7,
+    )
+
+    if pretrained:
+        if not os.path.exists(".checkpoints/imagebind_huge.pth"):
+            print(
+                "Downloading imagebind weights to .checkpoints/imagebind_huge.pth ..."
+            )
+            os.makedirs(".checkpoints", exist_ok=True)
+            torch.hub.download_url_to_file(
+                "https://dl.fbaipublicfiles.com/imagebind/imagebind_huge.pth",
+                ".checkpoints/imagebind_huge.pth",
+                progress=True,
+            )
+
+        model.load_state_dict(torch.load(".checkpoints/imagebind_huge.pth"))
+
+    return model

external/Grounded-Segment-Anything/playground/ImageBind_SAM/models/multimodal_preprocessors.py

@@ -0,0 +1,687 @@
+#!/usr/bin/env python3
+# Portions Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import gzip
+import html
+import io
+import math
+from functools import lru_cache
+from typing import Callable, List, Optional
+
+import ftfy
+
+import numpy as np
+import regex as re
+import torch
+import torch.nn as nn
+from iopath.common.file_io import g_pathmgr
+from timm.models.layers import trunc_normal_
+
+from models.helpers import cast_if_src_dtype, VerboseNNModule
+
+
+def get_sinusoid_encoding_table(n_position, d_hid):
+    """Sinusoid position encoding table"""
+
+    # TODO: make it with torch instead of numpy
+    def get_position_angle_vec(position):
+        return [
+            position / np.power(10000, 2 * (hid_j // 2) / d_hid)
+            for hid_j in range(d_hid)
+        ]
+
+    sinusoid_table = np.array(
+        [get_position_angle_vec(pos_i) for pos_i in range(n_position)]
+    )
+    sinusoid_table[:, 0::2] = np.sin(sinusoid_table[:, 0::2])  # dim 2i
+    sinusoid_table[:, 1::2] = np.cos(sinusoid_table[:, 1::2])  # dim 2i+1
+
+    return torch.FloatTensor(sinusoid_table).unsqueeze(0)
+
+
+def interpolate_pos_encoding_2d(target_spatial_size, pos_embed):
+    N = pos_embed.shape[1]
+    if N == target_spatial_size:
+        return pos_embed
+    dim = pos_embed.shape[-1]
+    # nn.functional.interpolate doesn't work with bfloat16 so we cast to float32
+    pos_embed, updated = cast_if_src_dtype(pos_embed, torch.bfloat16, torch.float32)
+    pos_embed = nn.functional.interpolate(
+        pos_embed.reshape(1, int(math.sqrt(N)), int(math.sqrt(N)), dim).permute(
+            0, 3, 1, 2
+        ),
+        scale_factor=math.sqrt(target_spatial_size / N),
+        mode="bicubic",
+    )
+    if updated:
+        pos_embed, _ = cast_if_src_dtype(pos_embed, torch.float32, torch.bfloat16)
+    pos_embed = pos_embed.permute(0, 2, 3, 1).view(1, -1, dim)
+    return pos_embed
+
+
+def interpolate_pos_encoding(
+    npatch_per_img,
+    pos_embed,
+    patches_layout,
+    input_shape=None,
+    first_patch_idx=1,
+):
+    assert first_patch_idx == 0 or first_patch_idx == 1, "there is 1 CLS token or none"
+    N = pos_embed.shape[1] - first_patch_idx  # since it's 1 if cls_token exists
+    if npatch_per_img == N:
+        return pos_embed
+
+    assert (
+        patches_layout[-1] == patches_layout[-2]
+    ), "Interpolation of pos embed not supported for non-square layouts"
+
+    class_emb = pos_embed[:, :first_patch_idx]
+    pos_embed = pos_embed[:, first_patch_idx:]
+
+    if input_shape is None or patches_layout[0] == 1:
+        # simple 2D pos embedding, no temporal component
+        pos_embed = interpolate_pos_encoding_2d(npatch_per_img, pos_embed)
+    elif patches_layout[0] > 1:
+        # pos embed has a temporal component
+        assert len(input_shape) == 4, "temporal interpolation not supported"
+        # we only support 2D interpolation in this case
+        num_frames = patches_layout[0]
+        num_spatial_tokens = patches_layout[1] * patches_layout[2]
+        pos_embed = pos_embed.view(1, num_frames, num_spatial_tokens, -1)
+        # interpolate embedding for zeroth frame
+        pos_embed = interpolate_pos_encoding_2d(
+            npatch_per_img, pos_embed[0, 0, ...].unsqueeze(0)
+        )
+    else:
+        raise ValueError("This type of interpolation isn't implemented")
+
+    return torch.cat((class_emb, pos_embed), dim=1)
+
+
+def _get_pos_embedding(
+    npatch_per_img,
+    pos_embed,
+    patches_layout,
+    input_shape,
+    first_patch_idx=1,
+):
+    pos_embed = interpolate_pos_encoding(
+        npatch_per_img,
+        pos_embed,
+        patches_layout,
+        input_shape=input_shape,
+        first_patch_idx=first_patch_idx,
+    )
+    return pos_embed
+
+
+class PatchEmbedGeneric(nn.Module):
+    """
+    PatchEmbed from Hydra
+    """
+
+    def __init__(self, proj_stem, norm_layer: Optional[nn.Module] = None):
+        super().__init__()
+
+        if len(proj_stem) > 1:
+            self.proj = nn.Sequential(*proj_stem)
+        else:
+            # Special case to be able to load pre-trained models that were
+            # trained with a standard stem
+            self.proj = proj_stem[0]
+        self.norm_layer = norm_layer
+
+    def get_patch_layout(self, img_size):
+        with torch.no_grad():
+            dummy_img = torch.zeros(
+                [
+                    1,
+                ]
+                + img_size
+            )
+            dummy_out = self.proj(dummy_img)
+        embed_dim = dummy_out.shape[1]
+        patches_layout = tuple(dummy_out.shape[2:])
+        num_patches = np.prod(patches_layout)
+        return patches_layout, num_patches, embed_dim
+
+    def forward(self, x):
+        x = self.proj(x)
+        # B C (T) H W -> B (T)HW C
+        x = x.flatten(2).transpose(1, 2)
+        if self.norm_layer is not None:
+            x = self.norm_layer(x)
+        return x
+
+
+class SpatioTemporalPosEmbeddingHelper(VerboseNNModule):
+    def __init__(
+        self,
+        patches_layout: List,
+        num_patches: int,
+        num_cls_tokens: int,
+        embed_dim: int,
+        learnable: bool,
+    ) -> None:
+        super().__init__()
+        self.num_cls_tokens = num_cls_tokens
+        self.patches_layout = patches_layout
+        self.num_patches = num_patches
+        self.num_tokens = num_cls_tokens + num_patches
+        self.learnable = learnable
+        if self.learnable:
+            self.pos_embed = nn.Parameter(torch.zeros(1, self.num_tokens, embed_dim))
+            trunc_normal_(self.pos_embed, std=0.02)
+        else:
+            self.register_buffer(
+                "pos_embed", get_sinusoid_encoding_table(self.num_tokens, embed_dim)
+            )
+
+    def get_pos_embedding(self, vision_input, all_vision_tokens):
+        input_shape = vision_input.shape
+        pos_embed = _get_pos_embedding(
+            all_vision_tokens.size(1) - self.num_cls_tokens,
+            pos_embed=self.pos_embed,
+            patches_layout=self.patches_layout,
+            input_shape=input_shape,
+            first_patch_idx=self.num_cls_tokens,
+        )
+        return pos_embed
+
+
+class RGBDTPreprocessor(VerboseNNModule):
+    def __init__(
+        self,
+        rgbt_stem: PatchEmbedGeneric,
+        depth_stem: PatchEmbedGeneric,
+        img_size: List = (3, 224, 224),
+        num_cls_tokens: int = 1,
+        pos_embed_fn: Callable = None,
+        use_type_embed: bool = False,
+        init_param_style: str = "openclip",
+    ) -> None:
+        super().__init__()
+        stem = rgbt_stem if rgbt_stem is not None else depth_stem
+        (
+            self.patches_layout,
+            self.num_patches,
+            self.embed_dim,
+        ) = stem.get_patch_layout(img_size)
+        self.rgbt_stem = rgbt_stem
+        self.depth_stem = depth_stem
+        self.use_pos_embed = pos_embed_fn is not None
+        self.use_type_embed = use_type_embed
+        self.num_cls_tokens = num_cls_tokens
+
+        if self.use_pos_embed:
+            self.pos_embedding_helper = pos_embed_fn(
+                patches_layout=self.patches_layout,
+                num_cls_tokens=num_cls_tokens,
+                num_patches=self.num_patches,
+                embed_dim=self.embed_dim,
+            )
+        if self.num_cls_tokens > 0:
+            self.cls_token = nn.Parameter(
+                torch.zeros(1, self.num_cls_tokens, self.embed_dim)
+            )
+        if self.use_type_embed:
+            self.type_embed = nn.Parameter(torch.zeros(1, 1, self.embed_dim))
+
+        self.init_parameters(init_param_style)
+
+    @torch.no_grad()
+    def init_parameters(self, init_param_style):
+        if init_param_style == "openclip":
+            # OpenCLIP style initialization
+            scale = self.embed_dim**-0.5
+            if self.use_pos_embed:
+                nn.init.normal_(self.pos_embedding_helper.pos_embed)
+                self.pos_embedding_helper.pos_embed *= scale
+
+            if self.num_cls_tokens > 0:
+                nn.init.normal_(self.cls_token)
+                self.cls_token *= scale
+        elif init_param_style == "vit":
+            self.cls_token.data.fill_(0)
+        else:
+            raise ValueError(f"Unknown init {init_param_style}")
+
+        if self.use_type_embed:
+            nn.init.normal_(self.type_embed)
+
+    def tokenize_input_and_cls_pos(self, input, stem, mask):
+        # tokens is of shape B x L x D
+        tokens = stem(input)
+        assert tokens.ndim == 3
+        assert tokens.shape[2] == self.embed_dim
+        B = tokens.shape[0]
+        if self.num_cls_tokens > 0:
+            class_tokens = self.cls_token.expand(
+                B, -1, -1
+            )  # stole class_tokens impl from Phil Wang, thanks
+            tokens = torch.cat((class_tokens, tokens), dim=1)
+        if self.use_pos_embed:
+            pos_embed = self.pos_embedding_helper.get_pos_embedding(input, tokens)
+            tokens = tokens + pos_embed
+        if self.use_type_embed:
+            tokens = tokens + self.type_embed.expand(B, -1, -1)
+        return tokens
+
+    def forward(self, vision=None, depth=None, patch_mask=None):
+        if patch_mask is not None:
+            raise NotImplementedError()
+
+        if vision is not None:
+            vision_tokens = self.tokenize_input_and_cls_pos(
+                vision, self.rgbt_stem, patch_mask
+            )
+
+        if depth is not None:
+            depth_tokens = self.tokenize_input_and_cls_pos(
+                depth, self.depth_stem, patch_mask
+            )
+
+        # aggregate tokens
+        if vision is not None and depth is not None:
+            final_tokens = vision_tokens + depth_tokens
+        else:
+            final_tokens = vision_tokens if vision is not None else depth_tokens
+        return_dict = {
+            "trunk": {
+                "tokens": final_tokens,
+            },
+            "head": {},
+        }
+        return return_dict
+
+
+class AudioPreprocessor(RGBDTPreprocessor):
+    def __init__(self, audio_stem: PatchEmbedGeneric, **kwargs) -> None:
+        super().__init__(rgbt_stem=audio_stem, depth_stem=None, **kwargs)
+
+    def forward(self, audio=None):
+        return super().forward(vision=audio)
+
+
+class ThermalPreprocessor(RGBDTPreprocessor):
+    def __init__(self, thermal_stem: PatchEmbedGeneric, **kwargs) -> None:
+        super().__init__(rgbt_stem=thermal_stem, depth_stem=None, **kwargs)
+
+    def forward(self, thermal=None):
+        return super().forward(vision=thermal)
+
+
+def build_causal_attention_mask(context_length):
+    # lazily create causal attention mask, with full attention between the vision tokens
+    # pytorch uses additive attention mask; fill with -inf
+    mask = torch.empty(context_length, context_length, requires_grad=False)
+    mask.fill_(float("-inf"))
+    mask.triu_(1)  # zero out the lower diagonal
+    return mask
+
+
+class TextPreprocessor(VerboseNNModule):
+    def __init__(
+        self,
+        vocab_size: int,
+        context_length: int,
+        embed_dim: int,
+        causal_masking: bool,
+        supply_seq_len_to_head: bool = True,
+        num_cls_tokens: int = 0,
+        init_param_style: str = "openclip",
+    ) -> None:
+        super().__init__()
+        self.vocab_size = vocab_size
+        self.context_length = context_length
+        self.token_embedding = nn.Embedding(vocab_size, embed_dim)
+        self.pos_embed = nn.Parameter(
+            torch.empty(1, self.context_length + num_cls_tokens, embed_dim)
+        )
+        self.causal_masking = causal_masking
+        if self.causal_masking:
+            mask = build_causal_attention_mask(self.context_length)
+            # register the mask as a buffer so it can be moved to the right device
+            self.register_buffer("mask", mask)
+
+        self.supply_seq_len_to_head = supply_seq_len_to_head
+        self.num_cls_tokens = num_cls_tokens
+        self.embed_dim = embed_dim
+        if num_cls_tokens > 0:
+            assert self.causal_masking is False, "Masking + CLS token isn't implemented"
+            self.cls_token = nn.Parameter(
+                torch.zeros(1, self.num_cls_tokens, embed_dim)
+            )
+
+        self.init_parameters(init_param_style)
+
+    @torch.no_grad()
+    def init_parameters(self, init_param_style="openclip"):
+        # OpenCLIP style initialization
+        nn.init.normal_(self.token_embedding.weight, std=0.02)
+        nn.init.normal_(self.pos_embed, std=0.01)
+
+        if init_param_style == "openclip":
+            # OpenCLIP style initialization
+            scale = self.embed_dim**-0.5
+            if self.num_cls_tokens > 0:
+                nn.init.normal_(self.cls_token)
+                self.cls_token *= scale
+        elif init_param_style == "vit":
+            self.cls_token.data.fill_(0)
+        else:
+            raise ValueError(f"Unknown init {init_param_style}")
+
+    def forward(self, text):
+        # text tokens are of shape B x L x D
+        text_tokens = self.token_embedding(text)
+        # concat CLS tokens if any
+        if self.num_cls_tokens > 0:
+            B = text_tokens.shape[0]
+            class_tokens = self.cls_token.expand(
+                B, -1, -1
+            )  # stole class_tokens impl from Phil Wang, thanks
+            text_tokens = torch.cat((class_tokens, text_tokens), dim=1)
+        text_tokens = text_tokens + self.pos_embed
+        return_dict = {
+            "trunk": {
+                "tokens": text_tokens,
+            },
+            "head": {},
+        }
+        # Compute sequence length after adding CLS tokens
+        if self.supply_seq_len_to_head:
+            text_lengths = text.argmax(dim=-1)
+            return_dict["head"] = {
+                "seq_len": text_lengths,
+            }
+        if self.causal_masking:
+            return_dict["trunk"].update({"attn_mask": self.mask})
+        return return_dict
+
+
+class Im2Video(nn.Module):
+    """Convert an image into a trivial video."""
+
+    def __init__(self, time_dim=2):
+        super().__init__()
+        self.time_dim = time_dim
+
+    def forward(self, x):
+        if x.ndim == 4:
+            # B, C, H, W -> B, C, T, H, W
+            return x.unsqueeze(self.time_dim)
+        elif x.ndim == 5:
+            return x
+        else:
+            raise ValueError(f"Dimension incorrect {x.shape}")
+
+
+class PadIm2Video(Im2Video):
+    def __init__(self, ntimes, pad_type, time_dim=2):
+        super().__init__(time_dim=time_dim)
+        assert ntimes > 0
+        assert pad_type in ["zero", "repeat"]
+        self.ntimes = ntimes
+        self.pad_type = pad_type
+
+    def forward(self, x):
+        x = super().forward(x)
+        if x.shape[self.time_dim] == 1:
+            if self.pad_type == "repeat":
+                new_shape = [1] * len(x.shape)
+                new_shape[self.time_dim] = self.ntimes
+                x = x.repeat(new_shape)
+            elif self.pad_type == "zero":
+                padarg = [0, 0] * len(x.shape)
+                padarg[2 * self.time_dim + 1] = self.ntimes - x.shape[self.time_dim]
+                x = nn.functional.pad(x, padarg)
+        return x
+
+
+# Modified from github.com/openai/CLIP
+@lru_cache()
+def bytes_to_unicode():
+    """
+    Returns list of utf-8 byte and a corresponding list of unicode strings.
+    The reversible bpe codes work on unicode strings.
+    This means you need a large # of unicode characters in your vocab if you want to avoid UNKs.
+    When you're at something like a 10B token dataset you end up needing around 5K for decent coverage.
+    This is a signficant percentage of your normal, say, 32K bpe vocab.
+    To avoid that, we want lookup tables between utf-8 bytes and unicode strings.
+    And avoids mapping to whitespace/control characters the bpe code barfs on.
+    """
+    bs = (
+        list(range(ord("!"), ord("~") + 1))
+        + list(range(ord("¡"), ord("¬") + 1))
+        + list(range(ord("®"), ord("ÿ") + 1))
+    )
+    cs = bs[:]
+    n = 0
+    for b in range(2**8):
+        if b not in bs:
+            bs.append(b)
+            cs.append(2**8 + n)
+            n += 1
+    cs = [chr(n) for n in cs]
+    return dict(zip(bs, cs))
+
+
+def get_pairs(word):
+    """Return set of symbol pairs in a word.
+    Word is represented as tuple of symbols (symbols being variable-length strings).
+    """
+    pairs = set()
+    prev_char = word[0]
+    for char in word[1:]:
+        pairs.add((prev_char, char))
+        prev_char = char
+    return pairs
+
+
+def basic_clean(text):
+    text = ftfy.fix_text(text)
+    text = html.unescape(html.unescape(text))
+    return text.strip()
+
+
+def whitespace_clean(text):
+    text = re.sub(r"\s+", " ", text)
+    text = text.strip()
+    return text
+
+
+class SimpleTokenizer(object):
+    def __init__(self, bpe_path: str, context_length=77):
+        self.byte_encoder = bytes_to_unicode()
+        self.byte_decoder = {v: k for k, v in self.byte_encoder.items()}
+
+        with g_pathmgr.open(bpe_path, "rb") as fh:
+            bpe_bytes = io.BytesIO(fh.read())
+            merges = gzip.open(bpe_bytes).read().decode("utf-8").split("\n")
+        merges = merges[1 : 49152 - 256 - 2 + 1]
+        merges = [tuple(merge.split()) for merge in merges]
+        vocab = list(bytes_to_unicode().values())
+        vocab = vocab + [v + "</w>" for v in vocab]
+        for merge in merges:
+            vocab.append("".join(merge))
+        vocab.extend(["<|startoftext|>", "<|endoftext|>"])
+        self.encoder = dict(zip(vocab, range(len(vocab))))
+        self.decoder = {v: k for k, v in self.encoder.items()}
+        self.bpe_ranks = dict(zip(merges, range(len(merges))))
+        self.cache = {
+            "<|startoftext|>": "<|startoftext|>",
+            "<|endoftext|>": "<|endoftext|>",
+        }
+        self.pat = re.compile(
+            r"""<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""",
+            re.IGNORECASE,
+        )
+        self.context_length = context_length
+
+    def bpe(self, token):
+        if token in self.cache:
+            return self.cache[token]
+        word = tuple(token[:-1]) + (token[-1] + "</w>",)
+        pairs = get_pairs(word)
+
+        if not pairs:
+            return token + "</w>"
+
+        while True:
+            bigram = min(pairs, key=lambda pair: self.bpe_ranks.get(pair, float("inf")))
+            if bigram not in self.bpe_ranks:
+                break
+            first, second = bigram
+            new_word = []
+            i = 0
+            while i < len(word):
+                try:
+                    j = word.index(first, i)
+                    new_word.extend(word[i:j])
+                    i = j
+                except:
+                    new_word.extend(word[i:])
+                    break
+
+                if word[i] == first and i < len(word) - 1 and word[i + 1] == second:
+                    new_word.append(first + second)
+                    i += 2
+                else:
+                    new_word.append(word[i])
+                    i += 1
+            new_word = tuple(new_word)
+            word = new_word
+            if len(word) == 1:
+                break
+            else:
+                pairs = get_pairs(word)
+        word = " ".join(word)
+        self.cache[token] = word
+        return word
+
+    def encode(self, text):
+        bpe_tokens = []
+        text = whitespace_clean(basic_clean(text)).lower()
+        for token in re.findall(self.pat, text):
+            token = "".join(self.byte_encoder[b] for b in token.encode("utf-8"))
+            bpe_tokens.extend(
+                self.encoder[bpe_token] for bpe_token in self.bpe(token).split(" ")
+            )
+        return bpe_tokens
+
+    def decode(self, tokens):
+        text = "".join([self.decoder[token] for token in tokens])
+        text = (
+            bytearray([self.byte_decoder[c] for c in text])
+            .decode("utf-8", errors="replace")
+            .replace("</w>", " ")
+        )
+        return text
+
+    def __call__(self, texts, context_length=None):
+        if not context_length:
+            context_length = self.context_length
+
+        if isinstance(texts, str):
+            texts = [texts]
+
+        sot_token = self.encoder["<|startoftext|>"]
+        eot_token = self.encoder["<|endoftext|>"]
+        all_tokens = [[sot_token] + self.encode(text) + [eot_token] for text in texts]
+        result = torch.zeros(len(all_tokens), context_length, dtype=torch.long)
+
+        for i, tokens in enumerate(all_tokens):
+            tokens = tokens[:context_length]
+            result[i, : len(tokens)] = torch.tensor(tokens)
+
+        if len(result) == 1:
+            return result[0]
+        return result
+
+
+class IMUPreprocessor(VerboseNNModule):
+    def __init__(
+        self,
+        kernel_size: int,
+        imu_stem: PatchEmbedGeneric,
+        embed_dim: int,
+        img_size: List = (6, 2000),
+        num_cls_tokens: int = 1,
+        pos_embed_fn: Callable = None,
+        init_param_style: str = "openclip",
+    ) -> None:
+        super().__init__()
+        stem = imu_stem
+        self.imu_stem = imu_stem
+        self.embed_dim = embed_dim
+        self.use_pos_embed = pos_embed_fn is not None
+        self.num_cls_tokens = num_cls_tokens
+        self.kernel_size = kernel_size
+        self.pos_embed = nn.Parameter(
+            torch.empty(1, (img_size[1] // kernel_size) + num_cls_tokens, embed_dim)
+        )
+
+        if self.num_cls_tokens > 0:
+            self.cls_token = nn.Parameter(
+                torch.zeros(1, self.num_cls_tokens, self.embed_dim)
+            )
+
+        self.init_parameters(init_param_style)
+
+    @torch.no_grad()
+    def init_parameters(self, init_param_style):
+        nn.init.normal_(self.pos_embed, std=0.01)
+
+        if init_param_style == "openclip":
+            # OpenCLIP style initialization
+            scale = self.embed_dim**-0.5
+
+            if self.num_cls_tokens > 0:
+                nn.init.normal_(self.cls_token)
+                self.cls_token *= scale
+        elif init_param_style == "vit":
+            self.cls_token.data.fill_(0)
+        else:
+            raise ValueError(f"Unknown init {init_param_style}")
+
+    def tokenize_input_and_cls_pos(self, input, stem):
+        # tokens is of shape B x L x D
+        tokens = stem.norm_layer(stem.proj(input))
+        assert tokens.ndim == 3
+        assert tokens.shape[2] == self.embed_dim
+        B = tokens.shape[0]
+        if self.num_cls_tokens > 0:
+            class_tokens = self.cls_token.expand(
+                B, -1, -1
+            )  # stole class_tokens impl from Phil Wang, thanks
+            tokens = torch.cat((class_tokens, tokens), dim=1)
+        if self.use_pos_embed:
+            tokens = tokens + self.pos_embed
+        return tokens
+
+    def forward(self, imu):
+        # Patchify
+        imu = imu.unfold(
+            -1,
+            self.kernel_size,
+            self.kernel_size,
+        ).permute(0, 2, 1, 3)
+        imu = imu.reshape(imu.size(0), imu.size(1), -1)
+
+        imu_tokens = self.tokenize_input_and_cls_pos(
+            imu,
+            self.imu_stem,
+        )
+
+        return_dict = {
+            "trunk": {
+                "tokens": imu_tokens,
+            },
+            "head": {},
+        }
+        return return_dict

external/Grounded-Segment-Anything/playground/ImageBind_SAM/models/transformer.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python3
+# Portions Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Code modified from
+# https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/vision_transformer.py ;
+# https://github.com/facebookresearch/deit/blob/main/models.py
+# and https://github.com/facebookresearch/vissl/blob/main/vissl/models/trunks/vision_transformer.py
+
+
+import copy
+import fnmatch
+import logging
+from functools import partial
+from typing import Callable, List
+
+import torch
+import torch.nn as nn
+import torch.utils.checkpoint as checkpoint
+
+from timm.models.layers import DropPath, trunc_normal_
+
+
+class Attention(nn.Module):
+    def __init__(
+        self,
+        dim,
+        num_heads=8,
+        qkv_bias=False,
+        qk_scale=None,
+        attn_drop=0.0,
+        proj_drop=0.0,
+    ):
+        super().__init__()
+        self.num_heads = num_heads
+        head_dim = dim // num_heads
+        # NOTE scale factor was wrong in my original version,
+        # can set manually to be compat with prev weights
+        self.scale = qk_scale or head_dim**-0.5
+
+        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(dim, dim)
+        self.proj_drop = nn.Dropout(proj_drop)
+
+    def forward(self, x):
+        B, N, C = x.shape
+        qkv = (
+            self.qkv(x)
+            .reshape(B, N, 3, self.num_heads, C // self.num_heads)
+            .permute(2, 0, 3, 1, 4)
+        )
+        q, k, v = (
+            qkv[0],
+            qkv[1],
+            qkv[2],
+        )  # make torchscript happy (cannot use tensor as tuple)
+
+        attn = (q @ k.transpose(-2, -1)) * self.scale
+        attn = attn.softmax(dim=-1)
+        attn = self.attn_drop(attn)
+
+        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+
+class Mlp(nn.Module):
+    def __init__(
+        self,
+        in_features,
+        hidden_features=None,
+        out_features=None,
+        act_layer=nn.GELU,
+        drop=0.0,
+    ):
+        super().__init__()
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        self.fc1 = nn.Linear(in_features, hidden_features)
+        self.act = act_layer()
+        self.fc2 = nn.Linear(hidden_features, out_features)
+        self.drop = nn.Dropout(drop)
+
+    def forward(self, x):
+        x = self.fc1(x)
+        x = self.act(x)
+        x = self.drop(x)
+        x = self.fc2(x)
+        x = self.drop(x)
+        return x
+
+
+class MultiheadAttention(nn.MultiheadAttention):
+    def forward(self, x: torch.Tensor, attn_mask: torch.Tensor):
+        return super().forward(x, x, x, need_weights=False, attn_mask=attn_mask)[0]
+
+
+class ViTAttention(Attention):
+    def forward(self, x: torch.Tensor, attn_mask: torch.Tensor):
+        assert attn_mask is None
+        return super().forward(x)
+
+
+class BlockWithMasking(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        attn_target: Callable,
+        mlp_ratio: int = 4,
+        act_layer: Callable = nn.GELU,
+        norm_layer: Callable = nn.LayerNorm,
+        ffn_dropout_rate: float = 0.0,
+        drop_path: float = 0.0,
+        layer_scale_type: str = None,
+        layer_scale_init_value: float = 1e-4,
+    ):
+        super().__init__()
+
+        assert not isinstance(
+            attn_target, nn.Module
+        ), "attn_target should be a Callable. Otherwise attn_target is shared across blocks!"
+        self.attn = attn_target()
+        if drop_path > 0.0:
+            self.drop_path = DropPath(drop_path)
+        else:
+            self.drop_path = nn.Identity()
+        self.norm_1 = norm_layer(dim)
+        mlp_hidden_dim = int(mlp_ratio * dim)
+        self.mlp = Mlp(
+            in_features=dim,
+            hidden_features=mlp_hidden_dim,
+            act_layer=act_layer,
+            drop=ffn_dropout_rate,
+        )
+        self.norm_2 = norm_layer(dim)
+        self.layer_scale_type = layer_scale_type
+        if self.layer_scale_type is not None:
+            assert self.layer_scale_type in [
+                "per_channel",
+                "scalar",
+            ], f"Found Layer scale type {self.layer_scale_type}"
+            if self.layer_scale_type == "per_channel":
+                # one gamma value per channel
+                gamma_shape = [1, 1, dim]
+            elif self.layer_scale_type == "scalar":
+                # single gamma value for all channels
+                gamma_shape = [1, 1, 1]
+            # two gammas: for each part of the fwd in the encoder
+            self.layer_scale_gamma1 = nn.Parameter(
+                torch.ones(size=gamma_shape) * layer_scale_init_value,
+                requires_grad=True,
+            )
+            self.layer_scale_gamma2 = nn.Parameter(
+                torch.ones(size=gamma_shape) * layer_scale_init_value,
+                requires_grad=True,
+            )
+
+    def forward(self, x: torch.Tensor, attn_mask: torch.Tensor):
+        if self.layer_scale_type is None:
+            x = x + self.drop_path(self.attn(self.norm_1(x), attn_mask))
+            x = x + self.drop_path(self.mlp(self.norm_2(x)))
+        else:
+            x = (
+                x
+                + self.drop_path(self.attn(self.norm_1(x), attn_mask))
+                * self.layer_scale_gamma1
+            )
+            x = x + self.drop_path(self.mlp(self.norm_2(x))) * self.layer_scale_gamma2
+        return x
+
+
+_LAYER_NORM = partial(nn.LayerNorm, eps=1e-6)
+
+
+class SimpleTransformer(nn.Module):
+    def __init__(
+        self,
+        attn_target: Callable,
+        embed_dim: int,
+        num_blocks: int,
+        block: Callable = BlockWithMasking,
+        pre_transformer_layer: Callable = None,
+        post_transformer_layer: Callable = None,
+        drop_path_rate: float = 0.0,
+        drop_path_type: str = "progressive",
+        norm_layer: Callable = _LAYER_NORM,
+        mlp_ratio: int = 4,
+        ffn_dropout_rate: float = 0.0,
+        layer_scale_type: str = None,  # from cait; possible values are None, "per_channel", "scalar"
+        layer_scale_init_value: float = 1e-4,  # from cait; float
+        weight_init_style: str = "jax",  # possible values jax or pytorch
+    ):
+        """
+        Simple Transformer with the following features
+        1. Supports masked attention
+        2. Supports DropPath
+        3. Supports LayerScale
+        4. Supports Dropout in Attention and FFN
+        5. Makes few assumptions about the input except that it is a Tensor
+        """
+        super().__init__()
+        self.pre_transformer_layer = pre_transformer_layer
+        if drop_path_type == "progressive":
+            dpr = [x.item() for x in torch.linspace(0, drop_path_rate, num_blocks)]
+        elif drop_path_type == "uniform":
+            dpr = [drop_path_rate for i in range(num_blocks)]
+        else:
+            raise ValueError(f"Unknown drop_path_type: {drop_path_type}")
+
+        self.blocks = nn.Sequential(
+            *[
+                block(
+                    dim=embed_dim,
+                    attn_target=attn_target,
+                    mlp_ratio=mlp_ratio,
+                    ffn_dropout_rate=ffn_dropout_rate,
+                    drop_path=dpr[i],
+                    norm_layer=norm_layer,
+                    layer_scale_type=layer_scale_type,
+                    layer_scale_init_value=layer_scale_init_value,
+                )
+                for i in range(num_blocks)
+            ]
+        )
+        self.post_transformer_layer = post_transformer_layer
+        self.weight_init_style = weight_init_style
+        self.apply(self._init_weights)
+
+    def _init_weights(self, m):
+        if isinstance(m, nn.Linear):
+            if self.weight_init_style == "jax":
+                # Based on MAE and official Jax ViT implementation
+                torch.nn.init.xavier_uniform_(m.weight)
+            elif self.weight_init_style == "pytorch":
+                # PyTorch ViT uses trunc_normal_
+                trunc_normal_(m.weight, std=0.02)
+
+            if m.bias is not None:
+                nn.init.constant_(m.bias, 0)
+        elif isinstance(m, (nn.LayerNorm)):
+            nn.init.constant_(m.bias, 0)
+            nn.init.constant_(m.weight, 1.0)
+
+    def forward(
+        self,
+        tokens: torch.Tensor,
+        attn_mask: torch.Tensor = None,
+        use_checkpoint: bool = False,
+        checkpoint_every_n: int = 1,
+        checkpoint_blk_ids: List[int] = None,
+    ):
+        """
+        Inputs
+        - tokens: data of shape N x L x D (or L x N x D depending on the attention implementation)
+        - attn: mask of shape L x L
+
+        Output
+        - x: data of shape N x L x D (or L x N x D depending on the attention implementation)
+        """
+        if self.pre_transformer_layer:
+            tokens = self.pre_transformer_layer(tokens)
+        if use_checkpoint and checkpoint_blk_ids is None:
+            checkpoint_blk_ids = [
+                blk_id
+                for blk_id in range(len(self.blocks))
+                if blk_id % checkpoint_every_n == 0
+            ]
+        if checkpoint_blk_ids:
+            checkpoint_blk_ids = set(checkpoint_blk_ids)
+        for blk_id, blk in enumerate(self.blocks):
+            if use_checkpoint and blk_id in checkpoint_blk_ids:
+                tokens = checkpoint.checkpoint(
+                    blk, tokens, attn_mask, use_reentrant=False
+                )
+            else:
+                tokens = blk(tokens, attn_mask=attn_mask)
+        if self.post_transformer_layer:
+            tokens = self.post_transformer_layer(tokens)
+        return tokens

external/Grounded-Segment-Anything/playground/PaintByExample/README.md

@@ -0,0 +1,70 @@
+## Paint by Example: Exemplar-based Image Editing with Diffusion Models
+
+:grapes: [[Official Project Page](https://github.com/Fantasy-Studio/Paint-by-Example)]   :apple:[[Official Online Demo](https://huggingface.co/spaces/Fantasy-Studio/Paint-by-Example)]
+
+<div align="center">
+
+![](https://github.com/Fantasy-Studio/Paint-by-Example/blob/main/figure/teaser.png?raw=True)
+
+</div>
+
+## Abstract
+
+> Language-guided image editing has achieved great success recently. In this paper, for the first time, we investigate exemplar-guided image editing for more precise control. We achieve this goal by leveraging self-supervised training to disentangle and re-organize the source image and the exemplar. However, the naive approach will cause obvious fusing artifacts. We carefully analyze it and propose an information bottleneck and strong augmentations to avoid the trivial solution of directly copying and pasting the exemplar image. Meanwhile, to ensure the controllability of the editing process, we design an arbitrary shape mask for the exemplar image and leverage the classifier-free guidance to increase the similarity to the exemplar image. The whole framework involves a single forward of the diffusion model without any iterative optimization. We demonstrate that our method achieves an impressive performance and enables controllable editing on in-the-wild images with high fidelity.
+
+## Table of Contents
+- [Installation](#installation)
+- [Paint-By-Example Demos](#paint-by-example-demos)
+  - [Diffuser Demo](#paintbyexample-diffuser-demos)
+  - [PaintByExample with SAM](#paintbyexample-with-sam)
+
+
+## TODO
+- [x] PaintByExample Diffuser Demo
+- [x] PaintByExample with SAM
+- [ ] PaintByExample with GroundingDINO
+- [ ] PaintByExample with Grounded-SAM
+
+## Installation
+We're using PaintByExample with diffusers, install diffusers as follows:
+```bash
+pip install diffusers==0.16.1
+```
+Then install Grounded-SAM follows [Grounded-SAM Installation](https://github.com/IDEA-Research/Grounded-Segment-Anything#installation) for some extension demos.
+
+## Paint-By-Example Demos
+Here we provide the demos for `PaintByExample`
+
+
+### PaintByExample Diffuser Demos
+```python
+cd playground/PaintByExample
+python paint_by_example.py
+```
+**Notes:** set `cache_dir` to save the pretrained weights to specific folder. The paint result will be save as `paint_by_example_demo.jpg`:
+
+<div align="center">
+
+| Input Image | Mask | Example Image | Inpaint Result |
+|:----:|:----:|:----:|:----:|
+| ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/input_image.png?raw=true) | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/mask.png?raw=true) | <div style="text-align: center"> <img src="https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/example_image.jpg?raw=true" width=55%></div> | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/paint_by_example_demo.jpg?raw=true) |
+| ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/input_image.png?raw=true) | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/mask.png?raw=true) | <div style="text-align: center"> <img src="https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/pomeranian_example.jpg?raw=true" width=55%></div> | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/paint_by_pomeranian_demo.jpg?raw=true) |
+
+</div>
+
+### PaintByExample with SAM
+
+In this demo, we did inpaint task by:
+1. Generate mask by SAM with prompt (box or point)
+2. Inpaint with mask and example image
+
+```python
+cd playground/PaintByExample
+python sam_paint_by_example.py
+```
+**Notes:** We set a more `num_inference_steps` (like 200 to 500) to get higher quality image. And we've found that the mask region can influence a lot on the final result (like a panda can not be well inpainted with a region like dog). It needed to have more test on it.
+
+| Input Image | SAM Output | Example Image | Inpaint Result |
+|:----:|:----:|:----:|:----:|
+| ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/input_image.png?raw=true) | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/demo_with_point_prompt.png?raw=true) | <div style="text-align: center"> <img src="https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/labrador_example.jpg?raw=true" width=55%></div> | ![](https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/sam_paint_by_example_demo.jpg?raw=true) |
+

external/Grounded-Segment-Anything/playground/PaintByExample/paint_by_example.py

@@ -0,0 +1,53 @@
+# !pip install diffusers transformers
+
+import PIL
+import requests
+import torch
+from io import BytesIO
+from diffusers import DiffusionPipeline
+
+
+"""
+Step 1: Download demo images
+"""
+def download_image(url):
+    response = requests.get(url)
+    return PIL.Image.open(BytesIO(response.content)).convert("RGB")
+
+
+img_url = "https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/input_image.png?raw=true"
+mask_url = "https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/mask.png?raw=true"
+example_url = "https://github.com/IDEA-Research/detrex-storage/blob/main/assets/grounded_sam/paint_by_example/pomeranian_example.jpg?raw=True"
+# example_url = "https://raw.githubusercontent.com/Fantasy-Studio/Paint-by-Example/main/examples/reference/example_1.jpg"
+
+init_image = download_image(img_url).resize((512, 512))
+mask_image = download_image(mask_url).resize((512, 512))
+example_image = download_image(example_url).resize((512, 512))
+
+
+"""
+Step 2: Download pretrained weights and initialize model
+"""
+# set cache dir to store the weights
+cache_dir = "/comp_robot/rentianhe/weights/diffusers/"
+
+pipe = DiffusionPipeline.from_pretrained(
+    "Fantasy-Studio/Paint-by-Example",
+    torch_dtype=torch.float16,
+    cache_dir=cache_dir,
+)
+# set to device
+pipe = pipe.to("cuda:1")
+
+
+"""
+Step 3: Run PaintByExample pipeline and save image
+"""
+image = pipe(
+    image=init_image, 
+    mask_image=mask_image, 
+    example_image=example_image,
+    num_inference_steps=200,
+).images[0]
+
+image.save("./paint_by_example_demo.jpg")

external/Grounded-Segment-Anything/voxelnext_3d_box/models/data_processor.py

@@ -0,0 +1,211 @@
+from functools import partial
+
+import numpy as np
+
+tv = None
+try:
+    import cumm.tensorview as tv
+except:
+    pass
+
+
+def mask_points_by_range(points, limit_range):
+    mask = (points[:, 0] >= limit_range[0]) & (points[:, 0] <= limit_range[3]) \
+           & (points[:, 1] >= limit_range[1]) & (points[:, 1] <= limit_range[4])
+    return mask
+
+
+class VoxelGeneratorWrapper():
+    def __init__(self, vsize_xyz, coors_range_xyz, num_point_features, max_num_points_per_voxel, max_num_voxels):
+        try:
+            from spconv.utils import VoxelGeneratorV2 as VoxelGenerator
+            self.spconv_ver = 1
+        except:
+            try:
+                from spconv.utils import VoxelGenerator
+                self.spconv_ver = 1
+            except:
+                from spconv.utils import Point2VoxelCPU3d as VoxelGenerator
+                self.spconv_ver = 2
+
+        if self.spconv_ver == 1:
+            self._voxel_generator = VoxelGenerator(
+                voxel_size=vsize_xyz,
+                point_cloud_range=coors_range_xyz,
+                max_num_points=max_num_points_per_voxel,
+                max_voxels=max_num_voxels
+            )
+        else:
+            self._voxel_generator = VoxelGenerator(
+                vsize_xyz=vsize_xyz,
+                coors_range_xyz=coors_range_xyz,
+                num_point_features=num_point_features,
+                max_num_points_per_voxel=max_num_points_per_voxel,
+                max_num_voxels=max_num_voxels
+            )
+
+    def generate(self, points):
+        if self.spconv_ver == 1:
+            voxel_output = self._voxel_generator.generate(points)
+            if isinstance(voxel_output, dict):
+                voxels, coordinates, num_points = \
+                    voxel_output['voxels'], voxel_output['coordinates'], voxel_output['num_points_per_voxel']
+            else:
+                voxels, coordinates, num_points = voxel_output
+        else:
+            assert tv is not None, f"Unexpected error, library: 'cumm' wasn't imported properly."
+            voxel_output = self._voxel_generator.point_to_voxel(tv.from_numpy(points))
+            tv_voxels, tv_coordinates, tv_num_points = voxel_output
+            # make copy with numpy(), since numpy_view() will disappear as soon as the generator is deleted
+            voxels = tv_voxels.numpy()
+            coordinates = tv_coordinates.numpy()
+            num_points = tv_num_points.numpy()
+        return voxels, coordinates, num_points
+
+
+class DataProcessor(object):
+    def __init__(self, processor_configs, point_cloud_range, training, num_point_features):
+        self.point_cloud_range = point_cloud_range
+        self.training = training
+        self.num_point_features = num_point_features
+        self.mode = 'train' if training else 'test'
+        self.grid_size = self.voxel_size = None
+        self.data_processor_queue = []
+
+        self.voxel_generator = None
+
+        for cur_cfg in processor_configs:
+            cur_processor = getattr(self, cur_cfg.NAME)(config=cur_cfg)
+            self.data_processor_queue.append(cur_processor)
+
+    def mask_points_and_boxes_outside_range(self, data_dict=None, config=None):
+        if data_dict is None:
+            return partial(self.mask_points_and_boxes_outside_range, config=config)
+
+        if data_dict.get('points', None) is not None:
+            mask = mask_points_by_range(data_dict['points'], self.point_cloud_range)
+            data_dict['points'] = data_dict['points'][mask]
+
+        return data_dict
+
+    def shuffle_points(self, data_dict=None, config=None):
+        if data_dict is None:
+            return partial(self.shuffle_points, config=config)
+
+        if config.SHUFFLE_ENABLED[self.mode]:
+            points = data_dict['points']
+            shuffle_idx = np.random.permutation(points.shape[0])
+            points = points[shuffle_idx]
+            data_dict['points'] = points
+
+        return data_dict
+
+    def transform_points_to_voxels_placeholder(self, data_dict=None, config=None):
+        # just calculate grid size
+        if data_dict is None:
+            grid_size = (self.point_cloud_range[3:6] - self.point_cloud_range[0:3]) / np.array(config.VOXEL_SIZE)
+            self.grid_size = np.round(grid_size).astype(np.int64)
+            self.voxel_size = config.VOXEL_SIZE
+            return partial(self.transform_points_to_voxels_placeholder, config=config)
+        
+        return data_dict
+
+    def double_flip(self, points):
+        # y flip
+        points_yflip = points.copy()
+        points_yflip[:, 1] = -points_yflip[:, 1]
+
+        # x flip
+        points_xflip = points.copy()
+        points_xflip[:, 0] = -points_xflip[:, 0]
+
+        # x y flip
+        points_xyflip = points.copy()
+        points_xyflip[:, 0] = -points_xyflip[:, 0]
+        points_xyflip[:, 1] = -points_xyflip[:, 1]
+
+        return points_yflip, points_xflip, points_xyflip
+
+    def transform_points_to_voxels(self, data_dict=None, config=None):
+        if data_dict is None:
+            grid_size = (self.point_cloud_range[3:6] - self.point_cloud_range[0:3]) / np.array(config.VOXEL_SIZE)
+            self.grid_size = np.round(grid_size).astype(np.int64)
+            self.voxel_size = config.VOXEL_SIZE
+            # just bind the config, we will create the VoxelGeneratorWrapper later,
+            # to avoid pickling issues in multiprocess spawn
+            return partial(self.transform_points_to_voxels, config=config)
+
+        if self.voxel_generator is None:
+            self.voxel_generator = VoxelGeneratorWrapper(
+                vsize_xyz=config.VOXEL_SIZE,
+                coors_range_xyz=self.point_cloud_range,
+                num_point_features=self.num_point_features,
+                max_num_points_per_voxel=config.MAX_POINTS_PER_VOXEL,
+                max_num_voxels=config.MAX_NUMBER_OF_VOXELS[self.mode],
+            )
+
+        points = data_dict['points']
+        voxel_output = self.voxel_generator.generate(points)
+        voxels, coordinates, num_points = voxel_output
+
+        data_dict['voxels'] = voxels
+        data_dict['voxel_coords'] = coordinates
+        data_dict['voxel_num_points'] = num_points
+        return data_dict
+
+    def sample_points(self, data_dict=None, config=None):
+        if data_dict is None:
+            return partial(self.sample_points, config=config)
+
+        num_points = config.NUM_POINTS[self.mode]
+        if num_points == -1:
+            return data_dict
+
+        points = data_dict['points']
+        if num_points < len(points):
+            pts_depth = np.linalg.norm(points[:, 0:3], axis=1)
+            pts_near_flag = pts_depth < 40.0
+            far_idxs_choice = np.where(pts_near_flag == 0)[0]
+            near_idxs = np.where(pts_near_flag == 1)[0]
+            choice = []
+            if num_points > len(far_idxs_choice):
+                near_idxs_choice = np.random.choice(near_idxs, num_points - len(far_idxs_choice), replace=False)
+                choice = np.concatenate((near_idxs_choice, far_idxs_choice), axis=0) \
+                    if len(far_idxs_choice) > 0 else near_idxs_choice
+            else: 
+                choice = np.arange(0, len(points), dtype=np.int32)
+                choice = np.random.choice(choice, num_points, replace=False)
+            np.random.shuffle(choice)
+        else:
+            choice = np.arange(0, len(points), dtype=np.int32)
+            if num_points > len(points):
+                extra_choice = np.random.choice(choice, num_points - len(points), replace=False)
+                choice = np.concatenate((choice, extra_choice), axis=0)
+            np.random.shuffle(choice)
+        data_dict['points'] = points[choice]
+        return data_dict
+
+    def calculate_grid_size(self, data_dict=None, config=None):
+        if data_dict is None:
+            grid_size = (self.point_cloud_range[3:6] - self.point_cloud_range[0:3]) / np.array(config.VOXEL_SIZE)
+            self.grid_size = np.round(grid_size).astype(np.int64)
+            self.voxel_size = config.VOXEL_SIZE
+            return partial(self.calculate_grid_size, config=config)
+        return data_dict
+
+    def forward(self, data_dict):
+        """
+        Args:
+            data_dict:
+                points: (N, 3 + C_in)
+                gt_boxes: optional, (N, 7 + C) [x, y, z, dx, dy, dz, heading, ...]
+                gt_names: optional, (N), string
+                ...
+
+        Returns:
+        """
+
+        for cur_processor in self.data_processor_queue:
+            data_dict = cur_processor(data_dict=data_dict)
+
+        return data_dict

external/Grounded-Segment-Anything/voxelnext_3d_box/models/mean_vfe.py

@@ -0,0 +1,25 @@
+import torch
+import torch.nn as nn
+
+class MeanVFE(nn.Module):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, batch_dict, **kwargs):
+        """
+        Args:
+            batch_dict:
+                voxels: (num_voxels, max_points_per_voxel, C)
+                voxel_num_points: optional (num_voxels)
+            **kwargs:
+
+        Returns:
+            vfe_features: (num_voxels, C)
+        """
+        voxel_features, voxel_num_points = batch_dict['voxels'], batch_dict['voxel_num_points']
+        points_mean = voxel_features[:, :, :].sum(dim=1, keepdim=False)
+        normalizer = torch.clamp_min(voxel_num_points.view(-1, 1), min=1.0).type_as(voxel_features)
+        points_mean = points_mean / normalizer
+        batch_dict['voxel_features'] = points_mean.contiguous()
+
+        return batch_dict

external/Grounded-Segment-Anything/voxelnext_3d_box/models/spconv_backbone_voxelnext.py

@@ -0,0 +1,292 @@
+from functools import partial
+import torch
+import torch.nn as nn
+
+import spconv.pytorch as spconv
+from spconv.core import ConvAlgo
+
+
+def replace_feature(out, new_features):
+    return out.replace_feature(new_features)
+
+
+def post_act_block(in_channels, out_channels, kernel_size, indice_key=None, stride=1, padding=0,
+                   conv_type='subm', norm_fn=None):
+
+    if conv_type == 'subm':
+        conv = spconv.SubMConv3d(in_channels, out_channels, kernel_size, bias=False, indice_key=indice_key, algo=ConvAlgo.Native)
+    elif conv_type == 'spconv':
+        conv = spconv.SparseConv3d(in_channels, out_channels, kernel_size, stride=stride, padding=padding,
+                                   bias=False, indice_key=indice_key, algo=ConvAlgo.Native)
+    elif conv_type == 'inverseconv':
+        conv = spconv.SparseInverseConv3d(in_channels, out_channels, kernel_size, indice_key=indice_key, bias=False, algo=ConvAlgo.Native)
+    else:
+        raise NotImplementedError
+
+    m = spconv.SparseSequential(
+        conv,
+        norm_fn(out_channels),
+        nn.ReLU(),
+    )
+
+    return m
+
+
+class SparseBasicBlock(spconv.SparseModule):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, norm_fn=None, downsample=None, indice_key=None):
+        super(SparseBasicBlock, self).__init__()
+
+        assert norm_fn is not None
+        bias = norm_fn is not None
+        self.conv1 = spconv.SubMConv3d(
+            inplanes, planes, kernel_size=3, stride=stride, padding=1, bias=bias, indice_key=indice_key, algo=ConvAlgo.Native
+        )
+        self.bn1 = norm_fn(planes)
+        self.relu = nn.ReLU()
+        self.conv2 = spconv.SubMConv3d(
+            planes, planes, kernel_size=3, stride=stride, padding=1, bias=bias, indice_key=indice_key, algo=ConvAlgo.Native
+        )
+        self.bn2 = norm_fn(planes)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        identity = x
+
+        out = self.conv1(x)
+        out = replace_feature(out, self.bn1(out.features))
+        out = replace_feature(out, self.relu(out.features))
+
+        out = self.conv2(out)
+        out = replace_feature(out, self.bn2(out.features))
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out = replace_feature(out, out.features + identity.features)
+        out = replace_feature(out, self.relu(out.features))
+
+        return out
+
+
+class VoxelResBackBone8xVoxelNeXt(nn.Module):
+    def __init__(self, input_channels, grid_size, **kwargs):
+        super().__init__()
+        norm_fn = partial(nn.BatchNorm1d, eps=1e-3, momentum=0.01)
+
+        spconv_kernel_sizes = [3, 3, 3, 3]
+        channels = [16, 32, 64, 128, 128]
+        out_channel = 128
+
+        self.sparse_shape = grid_size[::-1] + [1, 0, 0]
+
+        self.conv_input = spconv.SparseSequential(
+            spconv.SubMConv3d(input_channels, channels[0], 3, padding=1, bias=False, indice_key='subm1', algo=ConvAlgo.Native),
+            norm_fn(channels[0]),
+            nn.ReLU(),
+        )
+        block = post_act_block
+
+        self.conv1 = spconv.SparseSequential(
+            SparseBasicBlock(channels[0], channels[0], norm_fn=norm_fn, indice_key='res1'),
+            SparseBasicBlock(channels[0], channels[0], norm_fn=norm_fn, indice_key='res1'),
+        )
+
+        self.conv2 = spconv.SparseSequential(
+            # [1600, 1408, 41] <- [800, 704, 21]
+            block(channels[0], channels[1], spconv_kernel_sizes[0], norm_fn=norm_fn, stride=2, padding=int(spconv_kernel_sizes[0]//2), indice_key='spconv2', conv_type='spconv'),
+            SparseBasicBlock(channels[1], channels[1], norm_fn=norm_fn, indice_key='res2'),
+            SparseBasicBlock(channels[1], channels[1], norm_fn=norm_fn, indice_key='res2'),
+        )
+
+        self.conv3 = spconv.SparseSequential(
+            # [800, 704, 21] <- [400, 352, 11]
+            block(channels[1], channels[2], spconv_kernel_sizes[1], norm_fn=norm_fn, stride=2, padding=int(spconv_kernel_sizes[1]//2), indice_key='spconv3', conv_type='spconv'),
+            SparseBasicBlock(channels[2], channels[2], norm_fn=norm_fn, indice_key='res3'),
+            SparseBasicBlock(channels[2], channels[2], norm_fn=norm_fn, indice_key='res3'),
+        )
+
+        self.conv4 = spconv.SparseSequential(
+            # [400, 352, 11] <- [200, 176, 6]
+            block(channels[2], channels[3], spconv_kernel_sizes[2], norm_fn=norm_fn, stride=2, padding=int(spconv_kernel_sizes[2]//2), indice_key='spconv4', conv_type='spconv'),
+            SparseBasicBlock(channels[3], channels[3], norm_fn=norm_fn, indice_key='res4'),
+            SparseBasicBlock(channels[3], channels[3], norm_fn=norm_fn, indice_key='res4'),
+        )
+
+        self.conv5 = spconv.SparseSequential(
+            # [200, 176, 6] <- [100, 88, 3]
+            block(channels[3], channels[4], spconv_kernel_sizes[3], norm_fn=norm_fn, stride=2, padding=int(spconv_kernel_sizes[3]//2), indice_key='spconv5', conv_type='spconv'),
+            SparseBasicBlock(channels[4], channels[4], norm_fn=norm_fn, indice_key='res5'),
+            SparseBasicBlock(channels[4], channels[4], norm_fn=norm_fn, indice_key='res5'),
+        )
+        
+        self.conv6 = spconv.SparseSequential(
+            # [200, 176, 6] <- [100, 88, 3]
+            block(channels[4], channels[4], spconv_kernel_sizes[3], norm_fn=norm_fn, stride=2, padding=int(spconv_kernel_sizes[3]//2), indice_key='spconv6', conv_type='spconv'),
+            SparseBasicBlock(channels[4], channels[4], norm_fn=norm_fn, indice_key='res6'),
+            SparseBasicBlock(channels[4], channels[4], norm_fn=norm_fn, indice_key='res6'),
+        )
+        self.conv_out = spconv.SparseSequential(
+            # [200, 150, 5] -> [200, 150, 2]
+            spconv.SparseConv2d(channels[3], out_channel, 3, stride=1, padding=1, bias=False, indice_key='spconv_down2', algo=ConvAlgo.Native),
+            norm_fn(out_channel),
+            nn.ReLU(),
+        )
+
+        self.shared_conv = spconv.SparseSequential(
+            spconv.SubMConv2d(out_channel, out_channel, 3, stride=1, padding=1, bias=True, algo=ConvAlgo.Native),
+            nn.BatchNorm1d(out_channel),
+            nn.ReLU(True),
+        )
+
+        self.forward_ret_dict = {}
+        self.num_point_features = out_channel
+        self.backbone_channels = {
+            'x_conv1': channels[0],
+            'x_conv2': channels[1],
+            'x_conv3': channels[2],
+            'x_conv4': channels[3]
+        }
+
+    def bev_out(self, x_conv, index):
+        features_cat = x_conv.features
+        indices_cat = x_conv.indices[:, [0, 2, 3]]
+        spatial_shape = x_conv.spatial_shape[1:]
+
+        indices_unique, _inv = torch.unique(indices_cat, dim=0, return_inverse=True)
+        features_unique = features_cat.new_zeros((indices_unique.shape[0], features_cat.shape[1]))
+        features_unique.index_add_(0, _inv, features_cat)
+
+        perm = torch.arange(_inv.size(0), dtype=_inv.dtype, device=_inv.device)
+        perm = _inv.new_empty(indices_unique.size(0)).scatter_(0, _inv, perm)
+        index_out = index[perm]
+
+        x_out = spconv.SparseConvTensor(
+            features=features_unique,
+            indices=indices_unique,
+            spatial_shape=spatial_shape,
+            batch_size=x_conv.batch_size
+        )
+        return x_out, index_out
+
+    def track_voxels_2d(self, x, x_downsample, index, kernel_size=3):
+        _step = int(kernel_size//2)
+        kernel_offsets = [[i, j] for i in range(-_step, _step+1) for j in range(-_step, _step+1)]
+        #kernel_offsets.remove([0, 0])
+        kernel_offsets = torch.Tensor(kernel_offsets).to(x.indices.device)
+
+        batch_size = x.batch_size
+        index_batch = []
+        indices_batch = []
+
+        for b in range(batch_size):
+            batch_index = x.indices[:, 0]==b
+            indices_ori = x.indices[batch_index]
+            features_ori = index[batch_index]
+
+            features_fore = features_ori
+            coords_fore = indices_ori
+
+            voxel_kerels_imp = kernel_offsets.unsqueeze(0).repeat(features_fore.shape[0],1, 1)
+            indices_fore_kernels = coords_fore[:, 1:].unsqueeze(1).repeat(1, kernel_offsets.shape[0], 1)
+            indices_with_imp = indices_fore_kernels + voxel_kerels_imp
+            features_fore = features_fore.repeat(1, kernel_offsets.shape[0])
+
+            selected_indices = indices_with_imp
+            spatial_indices = (selected_indices[:, :, 0] >=0) * (selected_indices[:, :, 1] >=0) * \
+                                (selected_indices[:, :, 0] < x.spatial_shape[0]) * (selected_indices[:, :, 1] < x.spatial_shape[1])
+            selected_indices = selected_indices[spatial_indices]
+            features_fore = features_fore[spatial_indices].view(-1, 1)
+
+            selected_indices = torch.cat([torch.ones((selected_indices.shape[0], 1), device=features_fore.device)*b, selected_indices], dim=1)
+
+            features_fore, coords_fore = features_fore, selected_indices
+            index_batch.append(features_fore)
+            indices_batch.append(coords_fore)
+
+        index_batch = torch.cat(index_batch)
+        indices_batch = torch.cat(indices_batch)
+
+        return self.index_from_sparse(index_batch, indices_batch, x_downsample, True)
+
+    def index_from_sparse(self, feature, indices, x_target, _2d=False):
+        sparse_index = spconv.SparseConvTensor(
+            features=feature,
+            indices=indices.int(),
+            spatial_shape=x_target.spatial_shape,
+            batch_size=x_target.batch_size
+        )
+        dense_index = sparse_index.dense()
+        indices_downsample = x_target.indices.long()
+        if _2d:
+            index_downsample = dense_index[indices_downsample[:, 0], :, indices_downsample[:, 1], indices_downsample[:, 2]]
+        else:
+            index_downsample = dense_index[indices_downsample[:, 0], :, indices_downsample[:, 1], indices_downsample[:, 2], indices_downsample[:, 3]]
+        return index_downsample
+
+    def forward(self, batch_dict):
+        """
+        Args:
+            batch_dict:
+                batch_size: int
+                vfe_features: (num_voxels, C)
+                voxel_coords: (num_voxels, 4), [batch_idx, z_idx, y_idx, x_idx]
+        Returns:
+            batch_dict:
+                encoded_spconv_tensor: sparse tensor
+        """
+        voxel_features, voxel_coords = batch_dict['voxel_features'], batch_dict['voxel_coords']
+        batch_size = batch_dict['batch_size']
+        input_sp_tensor = spconv.SparseConvTensor(
+            features=voxel_features,
+            indices=voxel_coords.int(),
+            spatial_shape=self.sparse_shape,
+            batch_size=batch_size
+        )
+        x = self.conv_input(input_sp_tensor)
+
+        x_conv1 = self.conv1(x)
+        x_conv2 = self.conv2(x_conv1)
+        x_conv3 = self.conv3(x_conv2)
+        x_conv4 = self.conv4(x_conv3)
+        x_conv5 = self.conv5(x_conv4)
+        x_conv6 = self.conv6(x_conv5)
+
+        x_conv5.indices[:, 1:] *= 2
+        x_conv6.indices[:, 1:] *= 4
+        x_conv4 = x_conv4.replace_feature(torch.cat([x_conv4.features, x_conv5.features, x_conv6.features]))
+        x_conv4.indices = torch.cat([x_conv4.indices, x_conv5.indices, x_conv6.indices])
+
+        index6_out = torch.arange(x_conv4.indices.shape[0], device=x_conv4.indices.device).unsqueeze(-1)
+        out_bevout, index_bevout = self.bev_out(x_conv4, index6_out)
+
+        out = self.conv_out(out_bevout)
+        index_out = self.track_voxels_2d(out_bevout, out, index_bevout)
+
+        out = self.shared_conv(out)
+
+        batch_dict.update({
+            'encoded_spconv_tensor': out,
+            'encoded_spconv_tensor_stride': 8,
+            'out_voxels': x_conv4.indices[index_out.squeeze(-1)],
+        })
+        batch_dict.update({
+            'multi_scale_3d_features': {
+                'x_conv1': x_conv1,
+                'x_conv2': x_conv2,
+                'x_conv3': x_conv3,
+                'x_conv4': x_conv4,
+            }
+        })
+        batch_dict.update({
+            'multi_scale_3d_strides': {
+                'x_conv1': 1,
+                'x_conv2': 2,
+                'x_conv3': 4,
+                'x_conv4': 8,
+            }
+        })
+        
+        return batch_dict

external/Grounded-Segment-Anything/voxelnext_3d_box/models/voxelnext_head.py

@@ -0,0 +1,166 @@
+import numpy as np
+import torch
+import torch.nn as nn
+from voxelnext_3d_box.utils import centernet_utils
+import spconv.pytorch as spconv
+import copy
+from spconv.core import ConvAlgo
+
+
+class SeparateHead(nn.Module):
+    def __init__(self, input_channels, sep_head_dict, kernel_size, use_bias=False):
+        super().__init__()
+        self.sep_head_dict = sep_head_dict
+
+        for cur_name in self.sep_head_dict:
+            output_channels = self.sep_head_dict[cur_name]['out_channels']
+            num_conv = self.sep_head_dict[cur_name]['num_conv']
+
+            fc_list = []
+            for k in range(num_conv - 1):
+                fc_list.append(spconv.SparseSequential(
+                    spconv.SubMConv2d(input_channels, input_channels, kernel_size, padding=int(kernel_size//2), bias=use_bias, indice_key=cur_name, algo=ConvAlgo.Native),
+                    nn.BatchNorm1d(input_channels),
+                    nn.ReLU()
+                ))
+            fc_list.append(spconv.SubMConv2d(input_channels, output_channels, 1, bias=True, indice_key=cur_name+'out', algo=ConvAlgo.Native))
+            fc = nn.Sequential(*fc_list)
+            self.__setattr__(cur_name, fc)
+
+    def forward(self, x):
+        ret_dict = {}
+        for cur_name in self.sep_head_dict:
+            ret_dict[cur_name] = self.__getattr__(cur_name)(x).features
+
+        return ret_dict
+
+
+class VoxelNeXtHead(nn.Module):
+    def __init__(self, class_names, point_cloud_range, voxel_size, kernel_size_head,
+                 CLASS_NAMES_EACH_HEAD, SEPARATE_HEAD_CFG, POST_PROCESSING):
+        super().__init__()
+        self.point_cloud_range = torch.Tensor(point_cloud_range)
+        self.voxel_size = torch.Tensor(voxel_size)
+        self.feature_map_stride = 8
+
+        self.class_names = class_names
+        self.class_names_each_head = []
+        self.class_id_mapping_each_head = []
+        self.POST_PROCESSING = POST_PROCESSING
+
+        for cur_class_names in CLASS_NAMES_EACH_HEAD:
+            self.class_names_each_head.append([x for x in cur_class_names if x in class_names])
+            cur_class_id_mapping = torch.from_numpy(np.array(
+                [self.class_names.index(x) for x in cur_class_names if x in class_names]
+            ))
+            self.class_id_mapping_each_head.append(cur_class_id_mapping)
+
+        total_classes = sum([len(x) for x in self.class_names_each_head])
+        assert total_classes == len(self.class_names), f'class_names_each_head={self.class_names_each_head}'
+
+        self.heads_list = nn.ModuleList()
+        self.separate_head_cfg = SEPARATE_HEAD_CFG
+        for idx, cur_class_names in enumerate(self.class_names_each_head):
+            cur_head_dict = copy.deepcopy(self.separate_head_cfg.HEAD_DICT)
+            cur_head_dict['hm'] = dict(out_channels=len(cur_class_names), num_conv=2)
+            self.heads_list.append(
+                SeparateHead(
+                    input_channels=128,
+                    sep_head_dict=cur_head_dict,
+                    kernel_size=kernel_size_head,
+                    use_bias=True,
+                )
+            )
+        self.forward_ret_dict = {}
+
+    def generate_predicted_boxes(self, batch_size, pred_dicts, voxel_indices, spatial_shape):
+        device = pred_dicts[0]['hm'].device
+        post_process_cfg = self.POST_PROCESSING
+        post_center_limit_range = torch.tensor(post_process_cfg.POST_CENTER_LIMIT_RANGE).float().to(device)
+
+        ret_dict = [{
+            'pred_boxes': [],
+            'pred_scores': [],
+            'pred_labels': [],
+            'pred_ious': [],
+            'voxel_ids': []
+        } for k in range(batch_size)]
+        for idx, pred_dict in enumerate(pred_dicts):
+            batch_hm = pred_dict['hm'].sigmoid()
+            batch_center = pred_dict['center']
+            batch_center_z = pred_dict['center_z']
+            batch_dim = pred_dict['dim'].exp()
+            batch_rot_cos = pred_dict['rot'][:, 0].unsqueeze(dim=1)
+            batch_rot_sin = pred_dict['rot'][:, 1].unsqueeze(dim=1)
+            batch_iou = None
+            batch_vel = pred_dict['vel'] if 'vel' in self.separate_head_cfg.HEAD_ORDER else None
+            voxel_indices_ = voxel_indices
+
+            final_pred_dicts = centernet_utils.decode_bbox_from_voxels_nuscenes(
+                batch_size=batch_size, indices=voxel_indices_,
+                obj=batch_hm, 
+                rot_cos=batch_rot_cos,
+                rot_sin=batch_rot_sin,
+                center=batch_center, center_z=batch_center_z,
+                dim=batch_dim, vel=batch_vel, iou=batch_iou,
+                point_cloud_range=self.point_cloud_range.to(device), voxel_size=self.voxel_size.to(device),
+                feature_map_stride=self.feature_map_stride,
+                K=post_process_cfg.MAX_OBJ_PER_SAMPLE,
+                score_thresh=post_process_cfg.SCORE_THRESH,
+                post_center_limit_range=post_center_limit_range,
+                add_features=torch.arange(voxel_indices_.shape[0], device=voxel_indices_.device).unsqueeze(-1)
+            )
+
+            for k, final_dict in enumerate(final_pred_dicts):
+                class_id_mapping_each_head = self.class_id_mapping_each_head[idx].to(device)
+                final_dict['pred_labels'] = class_id_mapping_each_head[final_dict['pred_labels'].long()]
+
+                ret_dict[k]['pred_boxes'].append(final_dict['pred_boxes'])
+                ret_dict[k]['pred_scores'].append(final_dict['pred_scores'])
+                ret_dict[k]['pred_labels'].append(final_dict['pred_labels'])
+                ret_dict[k]['pred_ious'].append(final_dict['pred_ious'])
+                ret_dict[k]['voxel_ids'].append(final_dict['add_features'])
+
+        for k in range(batch_size):
+            pred_boxes = torch.cat(ret_dict[k]['pred_boxes'], dim=0)
+            pred_scores = torch.cat(ret_dict[k]['pred_scores'], dim=0)
+            pred_labels = torch.cat(ret_dict[k]['pred_labels'], dim=0)
+            voxel_ids = torch.cat(ret_dict[k]['voxel_ids'], dim=0)
+
+            ret_dict[k]['pred_boxes'] = pred_boxes
+            ret_dict[k]['pred_scores'] = pred_scores
+            ret_dict[k]['pred_labels'] = pred_labels + 1
+            ret_dict[k]['voxel_ids'] = voxel_ids
+
+        return ret_dict
+
+    def _get_voxel_infos(self, x):
+        spatial_shape = x.spatial_shape
+        voxel_indices = x.indices
+        spatial_indices = []
+        num_voxels = []
+        batch_size = x.batch_size
+        batch_index = voxel_indices[:, 0]
+
+        for bs_idx in range(batch_size):
+            batch_inds = batch_index==bs_idx
+            spatial_indices.append(voxel_indices[batch_inds][:, [2, 1]])
+            num_voxels.append(batch_inds.sum())
+
+        return spatial_shape, batch_index, voxel_indices, spatial_indices, num_voxels
+
+    def forward(self, data_dict):
+        x = data_dict['encoded_spconv_tensor']
+        spatial_shape, batch_index, voxel_indices, spatial_indices, num_voxels = self._get_voxel_infos(x)
+
+        pred_dicts = []
+        for idx, head in enumerate(self.heads_list):
+            pred_dict = head(x)
+            pred_dicts.append(pred_dict)
+
+        pred_dicts = self.generate_predicted_boxes(
+            data_dict['batch_size'],
+            pred_dicts, voxel_indices, spatial_shape
+        )
+
+        return pred_dicts

external/Grounded-Segment-Anything/voxelnext_3d_box/utils/centernet_utils.py

@@ -0,0 +1,116 @@
+# This file is modified from https://github.com/tianweiy/CenterPoint
+
+import torch
+
+
+def _topk_1d(scores, batch_size, batch_idx, obj, K=40, nuscenes=False):
+    # scores: (N, num_classes)
+    topk_score_list = []
+    topk_inds_list = []
+    topk_classes_list = []
+
+    for bs_idx in range(batch_size):
+        batch_inds = batch_idx==bs_idx
+        if obj.shape[-1] == 1 and not nuscenes:
+            score = scores[batch_inds].permute(1, 0)
+            topk_scores, topk_inds = torch.topk(score, K)
+            topk_score, topk_ind = torch.topk(obj[topk_inds.view(-1)].squeeze(-1), K) #torch.topk(topk_scores.view(-1), K)
+        else:
+            score = obj[batch_inds].permute(1, 0)
+            topk_scores, topk_inds = torch.topk(score, min(K, score.shape[-1]))
+            topk_score, topk_ind = torch.topk(topk_scores.view(-1), min(K, topk_scores.view(-1).shape[-1]))
+
+        topk_classes = (topk_ind // K).int()
+        topk_inds = topk_inds.view(-1).gather(0, topk_ind)
+        #print('topk_inds', topk_inds)
+
+        if not obj is None and obj.shape[-1] == 1:
+            topk_score_list.append(obj[batch_inds][topk_inds])
+        else:
+            topk_score_list.append(topk_score)
+        topk_inds_list.append(topk_inds)
+        topk_classes_list.append(topk_classes)
+
+    topk_score = torch.stack(topk_score_list)
+    topk_inds = torch.stack(topk_inds_list)
+    topk_classes = torch.stack(topk_classes_list)
+
+    return topk_score, topk_inds, topk_classes
+
+def gather_feat_idx(feats, inds, batch_size, batch_idx):
+    feats_list = []
+    dim = feats.size(-1)
+    _inds = inds.unsqueeze(-1).expand(inds.size(0), inds.size(1), dim)
+
+    for bs_idx in range(batch_size):
+        batch_inds = batch_idx==bs_idx
+        feat = feats[batch_inds]
+        feats_list.append(feat.gather(0, _inds[bs_idx]))
+    feats = torch.stack(feats_list)
+    return feats
+
+
+def decode_bbox_from_voxels_nuscenes(batch_size, indices, obj, rot_cos, rot_sin,
+                            center, center_z, dim, vel=None, iou=None, point_cloud_range=None, voxel_size=None, voxels_3d=None,
+                            feature_map_stride=None, K=100, score_thresh=None, post_center_limit_range=None, add_features=None):
+    batch_idx = indices[:, 0]
+    spatial_indices = indices[:, 1:]
+    scores, inds, class_ids = _topk_1d(None, batch_size, batch_idx, obj, K=K, nuscenes=True)
+
+    center = gather_feat_idx(center, inds, batch_size, batch_idx)
+    rot_sin = gather_feat_idx(rot_sin, inds, batch_size, batch_idx)
+    rot_cos = gather_feat_idx(rot_cos, inds, batch_size, batch_idx)
+    center_z = gather_feat_idx(center_z, inds, batch_size, batch_idx)
+    dim = gather_feat_idx(dim, inds, batch_size, batch_idx)
+    spatial_indices = gather_feat_idx(spatial_indices, inds, batch_size, batch_idx)
+
+    if not add_features is None:
+        add_features = gather_feat_idx(add_features, inds, batch_size, batch_idx) #for add_feature in add_features]
+
+    if not isinstance(feature_map_stride, int):
+        feature_map_stride = gather_feat_idx(feature_map_stride.unsqueeze(-1), inds, batch_size, batch_idx)
+
+    angle = torch.atan2(rot_sin, rot_cos)
+    xs = (spatial_indices[:, :, -1:] + center[:, :, 0:1]) * feature_map_stride * voxel_size[0] + point_cloud_range[0]
+    ys = (spatial_indices[:, :, -2:-1] + center[:, :, 1:2]) * feature_map_stride * voxel_size[1] + point_cloud_range[1]
+
+    box_part_list = [xs, ys, center_z, dim, angle]
+
+    if not vel is None:
+        vel = gather_feat_idx(vel, inds, batch_size, batch_idx)
+        box_part_list.append(vel)
+
+    if not iou is None:
+        iou = gather_feat_idx(iou, inds, batch_size, batch_idx)
+        iou = torch.clamp(iou, min=0, max=1.)
+
+    final_box_preds = torch.cat((box_part_list), dim=-1)
+    final_scores = scores.view(batch_size, K)
+    final_class_ids = class_ids.view(batch_size, K)
+    if not add_features is None:
+        add_features = add_features.view(batch_size, K, add_features.shape[-1]) #for add_feature in add_features]
+
+    assert post_center_limit_range is not None
+    mask = (final_box_preds[..., :3] >= post_center_limit_range[:3]).all(2)
+    mask &= (final_box_preds[..., :3] <= post_center_limit_range[3:]).all(2)
+
+    if score_thresh is not None:
+        mask &= (final_scores > score_thresh)
+
+    ret_pred_dicts = []
+    for k in range(batch_size):
+        cur_mask = mask[k]
+        cur_boxes = final_box_preds[k, cur_mask]
+        cur_scores = final_scores[k, cur_mask]
+        cur_labels = final_class_ids[k, cur_mask]
+        cur_add_features = add_features[k, cur_mask] if not add_features is None else None
+        cur_iou = iou[k, cur_mask] if not iou is None else None
+
+        ret_pred_dicts.append({
+            'pred_boxes': cur_boxes,
+            'pred_scores': cur_scores,
+            'pred_labels': cur_labels,
+            'pred_ious': cur_iou,
+            'add_features': cur_add_features,
+        })
+    return ret_pred_dicts

external/Grounded-Segment-Anything/voxelnext_3d_box/utils/config.py

@@ -0,0 +1,34 @@
+import yaml
+from easydict import EasyDict
+
+def merge_new_config(config, new_config):
+    if '_BASE_CONFIG_' in new_config:
+        with open(new_config['_BASE_CONFIG_'], 'r') as f:
+            try:
+                yaml_config = yaml.safe_load(f, Loader=yaml.FullLoader)
+            except:
+                yaml_config = yaml.safe_load(f)
+        config.update(EasyDict(yaml_config))
+
+    for key, val in new_config.items():
+        if not isinstance(val, dict):
+            config[key] = val
+            continue
+        if key not in config:
+            config[key] = EasyDict()
+        merge_new_config(config[key], val)
+
+    return config
+
+def cfg_from_yaml_file(cfg_file, config):
+    with open(cfg_file, 'r') as f:
+        try:
+            new_config = yaml.safe_load(f, Loader=yaml.FullLoader)
+        except:
+            new_config = yaml.safe_load(f)
+
+        merge_new_config(config=config, new_config=new_config)
+
+    return config
+
+cfg = EasyDict()

external/Grounded-Segment-Anything/voxelnext_3d_box/utils/image_projection.py

@@ -0,0 +1,103 @@
+import torch
+import numpy as np
+import cv2
+
+def get_data_info(info, cam_type):
+
+    cam_info = info[cam_type]
+
+    lidar2cam_r = np.linalg.inv(cam_info['sensor2lidar_rotation'])
+    lidar2cam_t = cam_info[
+                      'sensor2lidar_translation'] @ lidar2cam_r.T
+    lidar2cam_rt = np.eye(4)
+    lidar2cam_rt[:3, :3] = lidar2cam_r.T
+    lidar2cam_rt[3, :3] = -lidar2cam_t
+    intrinsic = cam_info['cam_intrinsic']
+    viewpad = np.eye(4)
+    viewpad[:intrinsic.shape[0], :intrinsic.shape[1]] = intrinsic
+    lidar2img_rt = (viewpad @ lidar2cam_rt.T)
+
+    return lidar2img_rt
+
+
+def _proj_voxel_image(voxel_coords, lidar2img_rt, voxel_size, point_cloud_range):
+    # voxel_coords [n ,4]
+    # lidar2img_rt [4, 4]
+    #x_input.indices [n, 4] [[0, Z, Y, Z]xn]
+
+    voxel_coords = voxel_coords[:, [3,2,1]]
+    device = voxel_coords.device
+    lidar2img_rt = torch.Tensor(lidar2img_rt).to(device)
+    # point_cloud_rangetensor([-51.2000, -51.2000,  -5.0000,  51.2000,  51.2000,   3.0000])
+    voxel_coords = voxel_coords * voxel_size.unsqueeze(0) + point_cloud_range[:3].unsqueeze(0)
+    # (n, 4)
+    voxel_coords = torch.cat([voxel_coords, torch.ones((voxel_coords.shape[0], 1), device=device)], dim=-1)
+    points_image = torch.matmul(lidar2img_rt, voxel_coords.permute(1, 0)) #(voxel_coords @ lidar2img_rt).T
+    # (4, n)
+    depth = points_image[2:3] # (1, n)
+    points_image = points_image[:2] / torch.maximum(depth, torch.ones_like(depth*1e-4))
+    return points_image, depth
+
+def _draw_image(points_image, image_path, depth):
+    image = cv2.imread(image_path)
+    points_image = points_image.int().cpu().numpy()
+    for i in range(points_image.shape[1]):
+        _point = points_image[:, i]
+        if _point[0] > 0 and _point[1] > 0 and depth[0][i] >0:
+            cv2.circle(image, tuple(_point), 1, (0,255,0), -1)
+    #cv2.imwrite("image.png", image)
+    return image
+
+def _draw_mask(image_path, mask, color=None):
+    image = cv2.imread(image_path)
+    h, w, _ = image.shape
+
+    if color is None:
+        color = np.random.random(3)
+
+    image[mask] = image[mask] * color
+    #cv2.imwrite("image_mask.png", image)
+    return image
+
+def _draw_3dbox(box, lidar2img_rt, image, mask=None, color=None, output_path="image_box.png"):
+    #image = cv2.imread(image_path)
+    h, w, _ = image.shape
+
+    if color is None:
+        color = np.random.random(3)
+    if not mask is None:
+        image[mask] = image[mask] * color
+
+    center_x, center_y, center_z, H, W, Z, angle = box[:7]
+    sin_angle, cos_angle = torch.sin(angle), torch.cos(angle)
+    top1 = [center_x - (H/2 * cos_angle + W/2 * sin_angle), center_y - (H/2 * sin_angle + W/2 * cos_angle), center_z + Z/2]
+    top2 = [center_x - (H/2 * cos_angle + W/2 * sin_angle), center_y + (H/2 * sin_angle + W/2 * cos_angle), center_z + Z/2]
+    top3 = [center_x + (H/2 * cos_angle + W/2 * sin_angle), center_y + (H/2 * sin_angle + W/2 * cos_angle), center_z + Z/2]
+    top4 = [center_x + (H/2 * cos_angle + W/2 * sin_angle), center_y - (H/2 * sin_angle + W/2 * cos_angle), center_z + Z/2]
+
+    down1 = [center_x - (H/2 * cos_angle + W/2 * sin_angle), center_y - (H/2 * sin_angle + W/2 * cos_angle), center_z - Z/2]
+    down2 = [center_x - (H/2 * cos_angle + W/2 * sin_angle), center_y + (H/2 * sin_angle + W/2 * cos_angle), center_z - Z/2]
+    down3 = [center_x + (H/2 * cos_angle + W/2 * sin_angle), center_y + (H/2 * sin_angle + W/2 * cos_angle), center_z - Z/2]
+    down4 = [center_x + (H/2 * cos_angle + W/2 * sin_angle), center_y - (H/2 * sin_angle + W/2 * cos_angle), center_z - Z/2]
+    points = torch.Tensor([top1, top2, top3, top4, down1, down2, down3, down4, [center_x, center_y, center_z]]) # (8, 3)
+    points = torch.cat([points, torch.ones((points.shape[0], 1), device=points.device)], dim=-1)
+    points_image = torch.matmul(torch.Tensor(lidar2img_rt).to(points.device), points.permute(1, 0))
+    depth = points_image[2:3] # (1, n)
+    points_image = points_image[:2] / torch.maximum(depth, torch.ones_like(depth*1e-4))
+    points_image = points_image.permute(1, 0).int().cpu().numpy() #(voxel_coords @ lidar2img_rt).T
+    lines = [[0, 1], [1, 2], [2, 3], [3, 0], [4, 5], [5, 6], [6, 7], [7, 4], [0, 4], [1, 5], [2, 6], [3, 7]]
+
+    cv2.circle(image, tuple(points_image[-1]), 3, (0, 255, 0), -1)
+
+    for line in lines:
+        cv2.line(image, tuple(points_image[line[0]]), tuple(points_image[line[1]]), tuple(color * 255), 2)
+    #cv2.imwrite(output_path, image)
+    return image
+
+
+
+
+
+
+
+

external/WildCamera/WildCamera/benchmark/benchmark_calibration.py

@@ -0,0 +1,98 @@
+from __future__ import print_function, division
+import os, sys, inspect
+project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))))
+sys.path.insert(0, project_root)
+
+import warnings
+warnings.filterwarnings('ignore')
+import torch
+import argparse
+from loguru import logger
+from pprint import pprint
+
+from WildCamera.newcrfs.newcrf_incidencefield import NEWCRFIF
+
+
+parser = argparse.ArgumentParser(description='NeWCRFs PyTorch implementation.', fromfile_prefix_chars='@')
+parser.add_argument('--load_ckpt',                 type=str,   help='path of ckpt')
+parser.add_argument('--data_path',                 type=str,   help='path to the data', default='data/MonoCalib')
+parser.add_argument('--experiment_name',           type=str,   help='name of the experiment', required=True, choices=['in_the_wild', 'gsv'])
+
+def main_worker(args, wtassumption=False):
+    args.gpu = 0
+    pprint(vars(args))
+
+    model = NEWCRFIF(version='large07', pretrained=None)
+    model.load_state_dict(torch.load(args.load_ckpt, map_location="cpu"), strict=True)
+    model.eval()
+    model.cuda()
+    logger.info("Load Model from %s" % args.load_ckpt)
+
+    if args.experiment_name == 'in_the_wild':
+        from WildCamera.evaluation.evaluate_intrinsic import EvaluateIntrinsic
+        evaluate_intrinsic = EvaluateIntrinsic()
+        evaluate_intrinsic.evaluate(model, args, steps=0, writer=None, group=None, wtassumption=wtassumption)
+    elif args.experiment_name == 'gsv':
+        from WildCamera.evaluation.evaluate_fov import EvaluateFov
+        evaluate_fov = EvaluateFov()
+        evaluate_fov.evaluate(model, args, steps=0, writer=None, group=None, wtassumption=wtassumption)
+
+
+if __name__ == '__main__':
+    args = parser.parse_args()
+
+    args.world_size = torch.cuda.device_count()
+    args.augscale = 2.0
+    args.input_height = 480
+    args.input_width = 640
+
+    args.eval_workers = 4
+    args.l1_th = 0.02
+
+    if args.experiment_name == 'in_the_wild':
+        args.load_ckpt = os.path.join(project_root, 'model_zoo/Release', 'wild_camera_all.pth')
+        args.datasets_train = [
+            'Nuscenes',
+            'KITTI',
+            'Cityscapes',
+            'NYUv2',
+            'ARKitScenes',
+            'MegaDepth',
+            'SUN3D',
+            'MVImgNet',
+            'Objectron',
+        ]
+        args.datasets_eval = [
+            'Nuscenes',
+            'KITTI',
+            'Cityscapes',
+            'NYUv2',
+            'ARKitScenes',
+            'MegaDepth',
+            'SUN3D',
+            'MVImgNet',
+            'Objectron',
+            'Waymo',
+            'BIWIRGBDID',
+            'RGBD',
+            'ScanNet',
+            'CAD120',
+            'MVS',
+            'Scenes11',
+        ]
+        main_worker(args, wtassumption=False)
+        main_worker(args, wtassumption=True)
+    elif args.experiment_name == 'gsv':
+        args.load_ckpt = os.path.join(project_root, 'model_zoo/Release', 'wild_camera_gsv.pth')
+        args.datasets_train = [
+            'GSV'
+        ]
+        args.datasets_eval = [
+            'GSV'
+        ]
+        main_worker(args, wtassumption=False)
+        main_worker(args, wtassumption=True)
+    else:
+        raise NotImplementedError()
+
+

external/WildCamera/WildCamera/benchmark/benchmark_crop.py

@@ -0,0 +1,63 @@
+from __future__ import print_function, division
+import os, sys, inspect, copy
+project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))))
+sys.path.insert(0, project_root)
+
+import warnings
+warnings.filterwarnings('ignore')
+import torch
+import argparse
+from loguru import logger
+from pprint import pprint
+
+from WildCamera.newcrfs.newcrf_incidencefield import NEWCRFIF
+from WildCamera.evaluation.evaluate_crop import EvaluateCrop
+
+parser = argparse.ArgumentParser(description='NeWCRFs PyTorch implementation.', fromfile_prefix_chars='@')
+parser.add_argument('--load_ckpt',                 type=str,   help='path of ckpt')
+parser.add_argument('--data_path',                 type=str,   help='path to the data', default='data/MonoCalib')
+
+def main_worker(args):
+    args.gpu = 0
+    pprint(vars(args))
+
+    model = NEWCRFIF(version='large07', pretrained=None)
+    model.load_state_dict(torch.load(args.load_ckpt, map_location="cpu"), strict=True)
+    model.eval()
+    model.cuda()
+    logger.info("Load Model from %s" % args.load_ckpt)
+
+    evaluate_crop = EvaluateCrop()
+    evaluate_crop.evaluate(model, args, group=None)
+
+if __name__ == '__main__':
+    args = parser.parse_args()
+
+    args.world_size = 1
+    args.augscale = 2.0
+    args.input_height = 480
+    args.input_width = 640
+    args.eval_workers = 4
+    args.l1_th = 0.02
+
+    args.datasets_train = [
+        'KITTI',
+        'NYUv2',
+        'ARKitScenes',
+        'Waymo',
+        'RGBD',
+        'ScanNet',
+        'MVS',
+    ]
+    args.datasets_eval = [
+        'KITTI',
+        'NYUv2',
+        'ARKitScenes',
+        'Waymo',
+        'RGBD',
+        'ScanNet',
+        'MVS',
+    ]
+
+    args.load_ckpt = os.path.join(project_root, 'model_zoo/Release', 'wild_camera_all.pth')
+    main_worker(args)

external/WildCamera/WildCamera/benchmark/benchmark_uncalibtwoview_megadepth.py

@@ -0,0 +1,168 @@
+import os, sys, inspect, pickle
+project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))))
+sys.path.insert(0, project_root)
+
+import numpy as np
+import torch
+from tabulate import tabulate
+from PIL import Image
+from tqdm import tqdm
+from argparse import ArgumentParser
+from WildCamera.evaluation.evaluate_pose import compute_pose_error, pose_auc, estimate_pose, compute_relative_pose
+from WildCamera.newcrfs.newcrf_incidencefield import NEWCRFIF
+
+class Megadepth1500Benchmark:
+    def __init__(self, data_root="data/megadepth", scene_names=None) -> None:
+        if scene_names is None:
+            self.scene_names = [
+                "0015_0.1_0.3.npz",
+                "0015_0.3_0.5.npz",
+                "0022_0.1_0.3.npz",
+                "0022_0.3_0.5.npz",
+                "0022_0.5_0.7.npz",
+            ]
+        else:
+            self.scene_names = scene_names
+        self.scenes = [
+            np.load("{}/scene_info/{}".format(data_root, scene), allow_pickle=True)
+            for scene in self.scene_names
+        ]
+        self.data_root = data_root
+
+    @torch.no_grad()
+    def benchmark(self, camera_calibrator, use_calibrated_intrinsic=False):
+        with torch.no_grad():
+            data_root = self.data_root
+            tot_e_t, tot_e_R, tot_e_pose = [], [], []
+            for scene_ind in range(len(self.scenes)):
+                scene = self.scenes[scene_ind]
+                pairs = scene["pair_infos"]
+                intrinsics = scene["intrinsics"]
+                poses = scene["poses"]
+                im_paths = scene["image_paths"]
+                pair_inds = range(len(pairs))
+                for pairind in tqdm(pair_inds, disable=False):
+                    idx1, idx2 = pairs[pairind][0]
+                    K1 = intrinsics[idx1].copy()
+                    T1 = poses[idx1].copy()
+                    R1, t1 = T1[:3, :3], T1[:3, 3]
+                    K2 = intrinsics[idx2].copy()
+                    T2 = poses[idx2].copy()
+                    R2, t2 = T2[:3, :3], T2[:3, 3]
+                    R, t = compute_relative_pose(R1, t1, R2, t2)
+                    im1_path = f"{data_root}/{im_paths[idx1]}"
+                    im2_path = f"{data_root}/{im_paths[idx2]}"
+                    im1 = Image.open(im1_path)
+                    w1, h1 = im1.size
+                    im2 = Image.open(im2_path)
+                    w2, h2 = im2.size
+
+                    if not use_calibrated_intrinsic:
+                        K1 = K1.copy()
+                        K2 = K2.copy()
+                    else:
+                        K1, _ = camera_calibrator.inference(im1, wtassumption=True)
+                        K1 = K1.astype(np.float64)
+                        K2, _ = camera_calibrator.inference(im2, wtassumption=True)
+                        K2 = K2.astype(np.float64)
+
+                    scale1 = 1200 / max(w1, h1)
+                    scale2 = 1200 / max(w2, h2)
+                    w1, h1 = scale1 * w1, scale1 * h1
+                    w2, h2 = scale2 * w2, scale2 * h2
+                    K1[:2] = K1[:2] * scale1
+                    K2[:2] = K2[:2] * scale2
+
+                    corres_fold = os.path.join(self.data_root, 'MegaDepthCorrespondence')
+                    sv_path = os.path.join(corres_fold, '{}_{}.pkl'.format(str(scene_ind), str(pairind)))
+                    with open(sv_path, 'rb') as f:
+                        sparse_matches = pickle.load(f)
+
+                    kpts1 = sparse_matches[:, :2]
+                    kpts1 = (
+                        np.stack(
+                            (
+                                w1 * (kpts1[:, 0] + 1) / 2,
+                                h1 * (kpts1[:, 1] + 1) / 2,
+                            ),
+                            axis=-1,
+                        )
+                    )
+                    kpts2 = sparse_matches[:, 2:]
+                    kpts2 = (
+                        np.stack(
+                            (
+                                w2 * (kpts2[:, 0] + 1) / 2,
+                                h2 * (kpts2[:, 1] + 1) / 2,
+                            ),
+                            axis=-1,
+                        )
+                    )
+
+                    for _ in range(5):
+                        shuffling = np.random.permutation(np.arange(len(kpts1)))
+                        kpts1 = kpts1[shuffling]
+                        kpts2 = kpts2[shuffling]
+                        try:
+                            norm_threshold = 0.5 / (
+                            np.mean(np.abs(K1[:2, :2])) + np.mean(np.abs(K2[:2, :2])))
+                            R_est, t_est, mask = estimate_pose(
+                                kpts1,
+                                kpts2,
+                                K1,
+                                K2,
+                                norm_threshold,
+                                conf=0.99999
+                            )
+                            T1_to_2_est = np.concatenate((R_est, t_est), axis=-1)  #
+                            e_t, e_R = compute_pose_error(T1_to_2_est, R, t)
+                            e_pose = max(e_t, e_R)
+                        except Exception as e:
+                            e_t, e_R = 90, 90
+                            e_pose = max(e_t, e_R)
+
+                        tot_e_t.append(e_t)
+                        tot_e_R.append(e_R)
+                        tot_e_pose.append(e_pose)
+
+            tot_e_pose = np.array(tot_e_pose)
+            thresholds = [5, 10, 20]
+            auc = pose_auc(tot_e_pose, thresholds)
+            acc_5 = (tot_e_pose < 5).mean()
+            acc_10 = (tot_e_pose < 10).mean()
+            acc_15 = (tot_e_pose < 15).mean()
+            acc_20 = (tot_e_pose < 20).mean()
+            map_5 = acc_5
+            map_10 = np.mean([acc_5, acc_10])
+            map_20 = np.mean([acc_5, acc_10, acc_15, acc_20])
+
+            result = {
+                "auc_5": auc[0],
+                "auc_10": auc[1],
+                "auc_20": auc[2],
+                "map_5": map_5,
+                "map_10": map_10,
+                "map_20": map_20,
+            }
+
+            for k in result.keys():
+                result[k] = result[k] * 100
+
+            return result
+
+if __name__ == "__main__":
+    parser = ArgumentParser()
+    parser.add_argument("--data_path", type=str, required=True)
+    parser.add_argument('--load_ckpt', type=str, help='path of ckpt')
+    args, _ = parser.parse_known_args()
+
+    megaloftr_benchmark = Megadepth1500Benchmark(args.data_path)
+
+    args.load_ckpt = os.path.join(project_root, 'model_zoo', 'Release', 'wild_camera_all.pth')
+    camera_calibrator = NEWCRFIF(version='large07', pretrained=None)
+    camera_calibrator.load_state_dict(torch.load(args.load_ckpt, map_location="cpu"), strict=True)
+    camera_calibrator.eval()
+    camera_calibrator.cuda()
+
+    result = megaloftr_benchmark.benchmark(camera_calibrator, use_calibrated_intrinsic=True)
+    print(tabulate(result.items(), headers=['Metric', 'Scores'], tablefmt='fancy_grid', floatfmt=".2f", numalign="left"))

external/WildCamera/WildCamera/benchmark/benchmark_uncalibtwoview_scannet.py

@@ -0,0 +1,165 @@
+import os, sys, inspect, tqdm, copy, pickle
+project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))))
+sys.path.insert(0, project_root)
+
+import numpy as np
+import torch
+from tabulate import tabulate
+from PIL import Image
+from tqdm import tqdm
+from argparse import ArgumentParser
+from WildCamera.evaluation.evaluate_pose import compute_pose_error, pose_auc, estimate_pose, compute_relative_pose
+from WildCamera.newcrfs.newcrf_incidencefield import NEWCRFIF
+
+class ScanNetBenchmark:
+    def __init__(self, data_root="data/scannet") -> None:
+        self.data_root = data_root
+
+    def benchmark(self, camera_calibrator, use_calibrated_intrinsic=False):
+        with torch.no_grad():
+            data_root = self.data_root
+            tmp = np.load(os.path.join(data_root, "test.npz"))
+            pairs, rel_pose = tmp["name"], tmp["rel_pose"]
+            tot_e_t, tot_e_R, tot_e_pose = [], [], []
+            np.random.seed(0)
+            pair_inds = np.random.choice(
+                range(len(pairs)), size=len(pairs), replace=False
+            )
+            for cnt, pairind in enumerate(tqdm(pair_inds)):
+                scene = pairs[pairind]
+                scene_name = f"scene0{scene[0]}_00"
+                im1_path = os.path.join(
+                        self.data_root,
+                        "scans_test",
+                        scene_name,
+                        "color",
+                        f"{scene[2]}.jpg",
+                    )
+                im1 = Image.open(im1_path)
+                im2_path = os.path.join(
+                        self.data_root,
+                        "scans_test",
+                        scene_name,
+                        "color",
+                        f"{scene[3]}.jpg",
+                    )
+                im2 = Image.open(im2_path)
+                T_gt = rel_pose[pairind].reshape(3, 4)
+                R, t = T_gt[:3, :3], T_gt[:3, 3]
+                K = np.stack(
+                    [
+                        np.array([float(i) for i in r.split()])
+                        for r in open(
+                            os.path.join(
+                                self.data_root,
+                                "scans_test",
+                                scene_name,
+                                "intrinsic",
+                                "intrinsic_color.txt",
+                            ),
+                            "r",
+                        )
+                        .read()
+                        .split("\n")
+                        if r
+                    ]
+                )
+                w1, h1 = im1.size
+                w2, h2 = im2.size
+
+                if not use_calibrated_intrinsic:
+                    K1 = K.copy()
+                    K2 = K.copy()
+                else:
+                    K1_, _ = camera_calibrator.inference(im1, wtassumption=True)
+                    K1_ = K1_.astype(np.float64)
+                    K2_, _ = camera_calibrator.inference(im2, wtassumption=True)
+                    K2_ = K2_.astype(np.float64)
+
+                    K1 = np.eye(4)
+                    K1[0:3, 0:3] = K1_
+
+                    K2 = np.eye(4)
+                    K2[0:3, 0:3] = K2_
+
+                scale1 = 480 / min(w1, h1)
+                scale2 = 480 / min(w2, h2)
+                w1, h1 = scale1 * w1, scale1 * h1
+                w2, h2 = scale2 * w2, scale2 * h2
+                K1 = K1 * scale1
+                K2 = K2 * scale2
+
+                corres_fold = os.path.join(self.data_root, 'ScanNetCorrespondence')
+                sv_path = os.path.join(corres_fold, '{}.pkl'.format(str(pairind)))
+                with open(sv_path, 'rb') as f:
+                    sparse_matches = pickle.load(f)
+
+                kpts1 = sparse_matches[:, :2]
+                kpts2 = sparse_matches[:, 2:]
+
+                for _ in range(5):
+                    shuffling = np.random.permutation(np.arange(len(kpts1)))
+                    kpts1 = kpts1[shuffling]
+                    kpts2 = kpts2[shuffling]
+                    try:
+                        norm_threshold = 0.8 / (
+                        np.mean(np.abs(K1[:2, :2])) + np.mean(np.abs(K2[:2, :2])))
+                        R_est, t_est, mask = estimate_pose(
+                            kpts1,
+                            kpts2,
+                            K1,
+                            K2,
+                            norm_threshold,
+                            conf=0.99999,
+                        )
+                        T1_to_2_est = np.concatenate((R_est, t_est), axis=-1)  #
+                        e_t, e_R = compute_pose_error(T1_to_2_est, R, t)
+                        e_pose = max(e_t, e_R)
+                    except Exception as _:
+                        e_t, e_R = 90, 90
+                        e_pose = max(e_t, e_R)
+                    tot_e_t.append(e_t)
+                    tot_e_R.append(e_R)
+                    tot_e_pose.append(e_pose)
+
+            tot_e_pose = np.array(tot_e_pose)
+            thresholds = [5, 10, 20]
+            auc = pose_auc(tot_e_pose, thresholds)
+            acc_5 = (tot_e_pose < 5).mean()
+            acc_10 = (tot_e_pose < 10).mean()
+            acc_15 = (tot_e_pose < 15).mean()
+            acc_20 = (tot_e_pose < 20).mean()
+            map_5 = acc_5
+            map_10 = np.mean([acc_5, acc_10])
+            map_20 = np.mean([acc_5, acc_10, acc_15, acc_20])
+
+            result = {
+                "auc_5": auc[0],
+                "auc_10": auc[1],
+                "auc_20": auc[2],
+                "map_5": map_5,
+                "map_10": map_10,
+                "map_20": map_20,
+            }
+
+            for k in result.keys():
+                result[k] = result[k] * 100
+
+            return result
+
+if __name__ == "__main__":
+    parser = ArgumentParser()
+    parser.add_argument("--data_path", type=str, required=True)
+    parser.add_argument('--load_ckpt', type=str, help='path of ckpt')
+    args, _ = parser.parse_known_args()
+
+    scannet_benchmark = ScanNetBenchmark(args.data_path)
+
+    args.load_ckpt = os.path.join(project_root, 'model_zoo', 'Release', 'wild_camera_all.pth')
+    camera_calibrator = NEWCRFIF(version='large07', pretrained=None)
+    camera_calibrator.load_state_dict(torch.load(args.load_ckpt, map_location="cpu"), strict=True)
+    camera_calibrator.eval()
+    camera_calibrator.cuda()
+
+    result = scannet_benchmark.benchmark(camera_calibrator, use_calibrated_intrinsic=True)
+    print(tabulate(result.items(), headers=['Metric', 'Scores'], tablefmt='fancy_grid', floatfmt=".2f", numalign="left"))

external/WildCamera/WildCamera/datasets/GSV.py

@@ -0,0 +1,73 @@
+import os, io, glob, natsort, random, copy
+import h5py
+import torch
+import numpy as np
+from PIL import Image
+from torchvision import transforms
+
+class GSV:
+    def __init__(self, data_root, ht=384, wt=512, shuffleseed=None, split='train') -> None:
+        split_path = os.path.join('splits', 'gsv_{}.txt'.format(split))
+
+        with open(split_path) as file:
+            data_names = [line.rstrip() for line in file]
+
+        if split == 'train':
+            if shuffleseed is not None:
+                random.seed(shuffleseed)
+            data_names = copy.deepcopy(data_names) + copy.deepcopy(data_names)
+            random.shuffle(data_names)
+
+        self.data_root = data_root
+        self.wt, self.ht = wt, ht
+        self.normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        self.tensor = transforms.ToTensor()
+        self.data_names = data_names
+
+    def __len__(self):
+        return len(self.data_names)
+
+    def load_im(self, im_ref):
+        im = Image.open(im_ref)
+        return im
+
+    def __getitem__(self, idx):
+        # read intrinsics of original size
+        scene_name, entry_name = self.data_names[idx].split(' ')
+        h5pypath = os.path.join(self.data_root, '{}.hdf5'.format(scene_name))
+
+        with h5py.File(h5pypath, 'r') as hf:
+            K_color = np.array(hf['intrinsic'][entry_name])
+
+            # Load positive pair data
+            rgb = self.load_im(io.BytesIO(np.array(hf['color'][entry_name])))
+            w, h = rgb.size
+            rgb = rgb.resize((self.wt, self.ht))
+
+            scaleM = np.eye(3)
+            scaleM[0, 0] = self.wt / w
+            scaleM[1, 1] = self.ht / h
+            aspect_ratio_restoration = (scaleM[1, 1] / scaleM[0, 0]).item()
+
+            K = torch.from_numpy(scaleM @ K_color).float()
+
+            fovy = 2 * np.arctan(h / K_color[1, 1] / 2)
+            fovy = fovy.item()
+
+        # Recompute camera intrinsic matrix due to the resize
+        rgb = self.normalize(self.tensor(rgb))
+
+        data_dict = {
+            'K': K,
+            'rgb': rgb,
+            'K_raw': torch.clone(K),
+            'rgb_raw': torch.clone(rgb),
+            'aspect_ratio_restoration': aspect_ratio_restoration,
+            'fovy': fovy,
+            # Only Required in Crop Evaluation and Visualization in Training
+            'T': torch.eye(3, dtype=torch.float32),
+            'scaleM': scaleM.astype(np.float32),
+            'size_wo_change': (h, w),
+        }
+
+        return data_dict

external/WildCamera/WildCamera/datasets/GenericDataset.py

@@ -0,0 +1,171 @@
+import os, io, glob, natsort, random, copy
+import h5py
+import torch
+import numpy as np
+import hashlib
+from PIL import Image
+from torchvision import transforms
+from tools.tools import coords_gridN, resample_rgb, apply_augmentation
+from torchvision.transforms import ColorJitter
+
+def add_white_noise(rgb):
+    w, h = rgb.size
+    rgb = np.array(rgb).astype(np.float32)
+    rgb = rgb + np.random.randint(9, size=(h, w, 3)) - 2
+    rgb = np.clip(rgb, a_min=0, a_max=255)
+    rgb = np.round(rgb).astype(np.uint8)
+    rgb = Image.fromarray(rgb)
+    return rgb
+
+class GenericDataset:
+    def __init__(self,
+                 data_root,
+                 ht=384, wt=512,
+                 augmentation=False,
+                 shuffleseed=None,
+                 split='train',
+                 datasetname='MegaDepth',
+                 augscale=2.0,
+                 no_change_prob=0.1,
+                 coloraugmentation=False,
+                 coloraugmentation_scale=0.1,
+                 transformcategory='transform_calibration'
+                 ) -> None:
+
+        name_mapping = {
+            'ScanNet': 'scannet',
+            'MegaDepth': 'megadepth',
+            'NYUv2': 'nyuv2',
+            'Cityscapes': 'cityscapes',
+            'MVS': 'mvs',
+            'RGBD': 'rgbd',
+            'Scenes11': 'scenes11',
+            'SUN3D': 'sun3d',
+            'BIWIRGBDID': 'biwirgbdid',
+            'CAD120': 'cad120',
+            'KITTI': 'kitti',
+            'Waymo': 'waymo',
+            'Nuscenes': 'nuscenes',
+            'ARKitScenes': 'arkitscenes',
+            'Objectron': 'objectron',
+            'MVImgNet': 'mvimgnet'
+        }
+        split_path = os.path.join('splits', '{}_{}.txt'.format(name_mapping[datasetname], split))
+        with open(split_path) as file:
+            data_names = [line.rstrip() for line in file]
+
+        if split == 'train':
+            if shuffleseed is not None:
+                random.seed(shuffleseed)
+            random.shuffle(data_names)
+            self.training = True
+        else:
+            self.training = False
+
+        self.data_root = data_root
+
+        self.wt, self.ht = wt, ht
+        self.normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        self.tensor = transforms.ToTensor()
+
+        self.data_names = data_names
+        self.augmentation = augmentation
+        self.augscale = augscale
+        self.no_change_prob = no_change_prob
+        self.coloraugmentation = coloraugmentation
+        self.coloraugmentation_scale = coloraugmentation_scale
+
+        self.datasetname = datasetname
+        self.transformcategory = transformcategory
+
+    def __len__(self):
+        return len(self.data_names)
+
+    def load_im(self, im_ref):
+        im = Image.open(im_ref)
+        return im
+
+    def color_augmentation_fun(self, rgb):
+        if random.uniform(0, 1) > 0.5:
+            colorjitter = ColorJitter(
+                brightness=self.coloraugmentation_scale,
+                contrast=self.coloraugmentation_scale,
+                saturation=self.coloraugmentation_scale,
+                hue=self.coloraugmentation_scale / 3.14
+            )
+            rgb = colorjitter(rgb)
+        rgb = add_white_noise(rgb)
+        return rgb
+
+    def __getitem__(self, idx):
+        # While augmenting novel intrinsic, we follow:
+        # Step 1 : Resize from original resolution to 480 x 640 (input height x input width)
+        # Step 2 : Apply random spatial augmentation
+
+        scene_name, stem_name = self.data_names[idx].split(' ')
+        h5pypath = os.path.join(self.data_root, '{}.hdf5'.format(scene_name))
+
+        if not os.path.exists(h5pypath):
+            print("H5 file %s missing" % h5pypath)
+            assert os.path.exists(h5pypath)
+
+        with h5py.File(h5pypath, 'r') as hf:
+            # Load Intrinsic
+            K_color = np.array(hf['intrinsic'][stem_name])
+
+            # Load RGB
+            rgb = self.load_im(io.BytesIO(np.array(hf['color'][stem_name])))
+
+        w, h = rgb.size
+
+        # Step 1 : Resize
+        rgb = rgb.resize((self.wt, self.ht))
+
+        scaleM = np.eye(3)
+        scaleM[0, 0] = self.wt / w
+        scaleM[1, 1] = self.ht / h
+        aspect_ratio_restoration = (scaleM[1, 1] / scaleM[0, 0]).item()
+
+        K = torch.from_numpy(scaleM @ K_color).float()
+
+        # Color Augmentation only in training
+        rgb = self.color_augmentation_fun(rgb) if self.coloraugmentation else rgb
+
+        # Normalization
+        rgb = self.normalize(self.tensor(rgb))
+
+        # Save RAW
+        K_raw = torch.clone(K)
+        rgb_raw = torch.clone(rgb)
+
+        # Step 2 : Random spatial augmentation
+        if self.augmentation:
+            if self.training:
+                rgb, K, T = apply_augmentation(
+                    rgb, K, seed=None, augscale=self.augscale, no_change_prob=self.no_change_prob
+                )
+            else:
+                T = np.array(h5py.File(h5pypath, 'r')[self.transformcategory][stem_name])
+                T = torch.from_numpy(T).float()
+                K = torch.inverse(T) @ K
+
+                _, h_, w_ = rgb.shape
+                rgb = resample_rgb(rgb.unsqueeze(0), T, 1, h_, w_, rgb.device).squeeze(0)
+        else:
+            T = torch.eye(3, dtype=torch.float32)
+
+        # Exportation
+        data_dict = {
+            'K': K,
+            'rgb': rgb,
+            'K_raw': K_raw,
+            'rgb_raw': rgb_raw,
+            'aspect_ratio_restoration': aspect_ratio_restoration,
+            'datasetname': self.datasetname,
+            # Only Required in Crop Evaluation
+            'T': T,
+            'scaleM': scaleM.astype(np.float32),
+            'size_wo_change': (h, w),
+        }
+
+        return data_dict

external/WildCamera/WildCamera/datasets/IncdDataset.py

@@ -0,0 +1,110 @@
+import os
+import torch
+import numpy as np
+
+from WildCamera.datasets.MegaDepth import MegaDepth
+from WildCamera.datasets.GSV import GSV
+from WildCamera.datasets.GenericDataset import GenericDataset
+
+from torch.utils.data import Subset
+
+def IncdDataset(
+        data_root,
+        datasets_included,
+        ht=384, wt=512,
+        augmentation=False,
+        shuffleseed=None,
+        split='train',
+        dataset_favour_long=0.0,
+        augscale=2.0,
+        no_change_prob=0.1,
+        coloraugmentation=False,
+        coloraugmentation_scale=0.0,
+        transformcategory='transform_crop' # For Evaluaiton Purpose
+) -> None:
+    datasets = dict()
+
+    for datasetname in datasets_included:
+        if datasetname == 'GSV':
+            datasets[datasetname] = GSV(
+                os.path.join(data_root, 'GSV'),
+                ht=ht, wt=wt,
+                shuffleseed=shuffleseed,
+                split=split
+            )
+        elif datasetname == 'MegaDepth':
+            datasets[datasetname] = MegaDepth(
+                os.path.join(data_root, 'MegaDepth'),
+                ht=ht, wt=wt,
+                shuffleseed=shuffleseed,
+                split=split,
+            )
+        elif datasetname == 'BIWIRGBDID':
+            datasets[datasetname] = GenericDataset(
+                os.path.join(data_root, 'BIWIRGBDID'),
+                ht=ht, wt=wt,
+                augmentation=False,
+                shuffleseed=shuffleseed,
+                split=split,
+                datasetname=datasetname,
+                coloraugmentation=coloraugmentation,
+                coloraugmentation_scale=coloraugmentation_scale
+            )
+        elif datasetname == 'CAD120':
+            datasets[datasetname] = GenericDataset(
+                os.path.join(data_root, 'CAD120'),
+                ht=ht, wt=wt,
+                augmentation=False,
+                shuffleseed=shuffleseed,
+                split=split,
+                datasetname=datasetname,
+                coloraugmentation=coloraugmentation,
+                coloraugmentation_scale=coloraugmentation_scale
+            )
+        elif (datasetname == 'Objectron') or (datasetname == 'MVImgNet'):
+            augscale_obj = 1 + (augscale - 1) / 5
+            datasets[datasetname] = GenericDataset(
+                os.path.join(data_root, datasetname),
+                ht=ht, wt=wt,
+                augmentation=True,
+                shuffleseed=shuffleseed,
+                split=split,
+                datasetname=datasetname,
+                augscale=augscale_obj,
+                no_change_prob=no_change_prob,
+                coloraugmentation=coloraugmentation,
+                coloraugmentation_scale=coloraugmentation_scale
+            )
+        else:
+            datasets[datasetname] = GenericDataset(
+                os.path.join(data_root, datasetname),
+                ht=ht, wt=wt,
+                augmentation=augmentation,
+                shuffleseed=shuffleseed,
+                split=split,
+                datasetname=datasetname,
+                augscale=augscale,
+                no_change_prob=no_change_prob,
+                coloraugmentation=coloraugmentation,
+                coloraugmentation_scale=coloraugmentation_scale,
+                transformcategory=transformcategory
+            )
+
+    if split == 'train':
+        min_len = np.array([len(datasets[key]) for key in datasets.keys()]).min()
+
+        datasets_sub = dict()
+        for key in datasets.keys():
+            dataset = datasets[key]
+            subsample_len = np.floor((1 - dataset_favour_long) * min_len + dataset_favour_long * len(dataset))
+            subsample_len = int(subsample_len)
+
+            indices = torch.randperm(len(dataset))
+            subsampled_dataset = Subset(dataset, indices[0:subsample_len])
+            datasets_sub[key] = subsampled_dataset
+
+        incdataset = torch.utils.data.ConcatDataset([datasets_sub[key] for key in datasets_sub.keys()])
+    else:
+        incdataset = torch.utils.data.ConcatDataset([datasets[key] for key in datasets.keys()])
+
+    return incdataset

external/WildCamera/WildCamera/datasets/MegaDepth.py

@@ -0,0 +1,76 @@
+import os, io, glob, natsort, random
+import h5py
+import torch
+import numpy as np
+from PIL import Image
+from torchvision import transforms
+
+class MegaDepth:
+    def __init__(self, data_root, ht=384, wt=512, shuffleseed=None, split='train') -> None:
+        split_path = os.path.join('splits', 'megadepth_{}.txt'.format(split))
+
+        with open(split_path) as file:
+            data_names = [line.rstrip() for line in file]
+
+        if split == 'train':
+            if shuffleseed is not None:
+                random.seed(shuffleseed)
+            random.shuffle(data_names)
+
+        self.data_root = data_root
+
+        self.wt, self.ht = wt, ht
+        self.normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        self.tensor = transforms.ToTensor()
+        self.data_names = data_names
+
+        self.datasetname = 'MegaDepth'
+
+    def __len__(self):
+        return len(self.data_names)
+
+    def load_im(self, im_ref):
+        im = Image.open(im_ref)
+        return im
+
+    def __getitem__(self, idx):
+        # read intrinsics of original size
+        scene_name, stem_name_color, stem_name_intrinsic = self.data_names[idx].split(' ')
+        h5pypath = os.path.join(self.data_root, '{}.hdf5'.format(scene_name))
+
+        with h5py.File(h5pypath, 'r') as hf:
+            K_color = np.array(hf['intrinsic'][stem_name_intrinsic])
+
+            # Load positive pair data
+            rgb = self.load_im(io.BytesIO(np.array(hf['color'][stem_name_color])))
+            w, h = rgb.size
+            rgb = rgb.resize((self.wt, self.ht))
+
+            scaleM = np.eye(3)
+            scaleM[0, 0] = self.wt / w
+            scaleM[1, 1] = self.ht / h
+            aspect_ratio_restoration = (scaleM[1, 1] / scaleM[0, 0]).item()
+
+            K = torch.from_numpy(scaleM @ K_color).float()
+
+        # Recompute camera intrinsic matrix due to the resize
+        rgb = self.normalize(self.tensor(rgb))
+
+        # Save RAW
+        K_raw = torch.clone(K)
+        rgb_raw = torch.clone(rgb)
+
+        data_dict = {
+            'K': K,
+            'rgb': rgb,
+            'K_raw': K_raw,
+            'rgb_raw': rgb_raw,
+            'aspect_ratio_restoration': aspect_ratio_restoration,
+            'datasetname': self.datasetname,
+            # Only Required in Crop Evaluation
+            'T': torch.eye(3, dtype=torch.float32),
+            'scaleM': scaleM.astype(np.float32),
+            'size_wo_change': (h, w),
+        }
+
+        return data_dict

external/WildCamera/WildCamera/evaluation/evaluate_crop.py

@@ -0,0 +1,157 @@
+import sys, os, time, inspect, tabulate
+import tqdm
+import numpy as np
+
+import torch
+import torch.distributed as dist
+from torch.utils.data import DataLoader
+from torchvision import transforms, ops
+
+from loguru import logger
+
+from tools.tools import to_cuda, DistributedSamplerNoEvenlyDivisible
+from tools.visualization import tensor2rgb
+from tools.calibrator import MonocularCalibrator
+from WildCamera.datasets.IncdDataset import IncdDataset
+
+class EvaluateCrop:
+    def __init__(self):
+        return
+
+    def evaluate(self, model, args, group=None):
+        measurements_all = dict()
+
+        for dataaset in args.datasets_eval:
+
+            augmentation = True
+
+            val_dataset = IncdDataset(
+                data_root=args.data_path,
+                datasets_included=[dataaset],
+                ht=args.input_height,
+                wt=args.input_width,
+                augmentation=augmentation,
+                shuffleseed=None,
+                split='test',
+                augscale=args.augscale,
+                no_change_prob=0.5,
+                transformcategory='transform_crop'
+            )
+            measurements = evaluate_crop(model, val_dataset, args, group)
+            measurements_all[dataaset] = measurements
+
+        if args.gpu == 0:
+            errors_all_mean = [['Datasets', 'miou', 'acc']]
+            for key in measurements_all.keys():
+                measurements = measurements_all[key]
+                errors_all_mean.append(
+                    [
+                        key,
+                        measurements['miou'],
+                        measurements['acc'],
+                    ]
+                )
+            logger.info(
+                "\n" +
+                tabulate.tabulate(errors_all_mean, headers='firstrow', tablefmt='fancy_grid', numalign="center", floatfmt=".3f"))
+
+        torch.cuda.synchronize()
+        return
+
+
+def acquire_bbox(K, h, w):
+    pts1 = torch.from_numpy(np.array([[0.5, 0.5, 1]])).float().cuda().T
+    pts2 = torch.from_numpy(np.array([[w - 0.5, 0.5, 1]])).float().cuda().T
+    pts3 = torch.from_numpy(np.array([[w - 0.5, h - 0.5, 1]])).float().cuda().T
+    pts4 = torch.from_numpy(np.array([[0.5, h - 0.5, 1]])).float().cuda().T
+
+    pts1 = K @ pts1
+    pts2 = K @ pts2
+    pts3 = K @ pts3
+    pts4 = K @ pts4
+
+    ptss = torch.cat([pts1, pts2, pts3, pts4])
+    ptss = ptss.squeeze().cpu().numpy()[:, 0:2]
+
+    ptss_ = [
+        min(ptss[:, 0]),
+        min(ptss[:, 1]),
+        max(ptss[:, 0]),
+        max(ptss[:, 1]),
+    ]
+    ptss_ = np.array(ptss_)
+    ptss_ = torch.from_numpy(ptss_).float().cuda()
+    return ptss_
+
+def bbox_auc(errors, thresholds):
+    sort_idx = np.argsort(errors)
+    errors = np.array(errors.copy())[sort_idx]
+    recall = (np.arange(len(errors)) + 1) / len(errors)
+    errors = np.r_[0.0, errors]
+    recall = np.r_[0.0, recall]
+    aucs = []
+    for t in thresholds:
+        last_index = np.searchsorted(errors, t)
+        r = np.r_[recall[:last_index], recall[last_index - 1]]
+        e = np.r_[errors[:last_index], t]
+        aucs.append(np.trapz(r, x=e) / t)
+    return aucs
+
+@torch.no_grad()
+def evaluate_crop(model, val_dataset, args, group=None):
+    """ In Validation, random sample N Images to mimic a real test set situation  """
+    monocalibrator = MonocularCalibrator(l1_th=args.l1_th)
+    model.eval()
+    if group is not None:
+        sampler = DistributedSamplerNoEvenlyDivisible(val_dataset, shuffle=False)
+        val_loader = DataLoader(val_dataset, batch_size=1, sampler=sampler, pin_memory=False, shuffle=False, num_workers=args.eval_workers, drop_last=False)
+    else:
+        val_loader = DataLoader(val_dataset, batch_size=1, pin_memory=False, shuffle=False, num_workers=args.eval_workers, drop_last=False)
+
+    measurements = torch.zeros(len(val_dataset), 2).cuda(device=args.gpu)
+    measurements_detection = torch.zeros(len(val_dataset)).cuda(device=args.gpu)
+    world_size = args.world_size
+
+    th = 0.2
+
+    for val_id, data_blob in enumerate(tqdm.tqdm(val_loader, disable=False)):
+        sample_batched = to_cuda(data_blob)
+        rgb, K, scaleM, T, K_raw, rgb_raw = sample_batched['rgb'], sample_batched['K'], sample_batched['scaleM'], sample_batched['T'], sample_batched['K_raw'], sample_batched['rgb_raw']
+
+        incidence = model(rgb)
+        Kgt, Kest = torch.clone(K).squeeze(0), monocalibrator.calibrate_camera_4DoF(incidence, RANSAC_trial=2048)
+
+        Kest_wo_change = torch.inverse(scaleM) @ Kest
+        fx_fy = (Kest_wo_change[0, 0, 0] / Kest_wo_change[0, 1, 1]).item()
+        fx_fy = max(fx_fy, 1 / fx_fy)
+        fx_fy = abs(fx_fy - 1)
+        diffx = abs(Kest_wo_change[0, 0, 2].item() - sample_batched['size_wo_change'][1].item() / 2)
+        diffx = diffx / sample_batched['size_wo_change'][1].item()
+        diffy = abs(Kest_wo_change[0, 1, 2].item() - sample_batched['size_wo_change'][0].item() / 2)
+        diffy = diffy / sample_batched['size_wo_change'][0].item()
+        diffb = max(diffx, diffy)
+        genuen = (fx_fy < th) and (diffb < th)
+
+        genuen_gt = ((T[0].cpu() - torch.eye(3)).abs().max() < 1e-2).item()
+
+        if genuen == genuen_gt:
+            measurements_detection[val_id * world_size + args.gpu] = 1
+
+        b, _, h, w = rgb.shape
+        bbox_est = acquire_bbox(K_raw @ torch.inverse(Kest), h, w)
+        bbox_gt = acquire_bbox(K_raw @ torch.inverse(Kgt), h, w)
+
+        iou = ops.box_iou(bbox_gt.unsqueeze(0), bbox_est.unsqueeze(0))
+        measurements[val_id * world_size + args.gpu, 0] = iou.squeeze().item()
+        measurements[val_id * world_size + args.gpu, 1] = 1 - float(genuen_gt)
+
+    if group is not None:
+        dist.all_reduce(tensor=measurements, op=dist.ReduceOp.SUM, group=group)
+
+    measurements = measurements.cpu().numpy()
+    miou = np.sum(measurements[:, 0] * measurements[:, 1]) / np.sum(measurements[:, 1])
+    measurements = {
+        'miou': miou,
+        'acc': measurements_detection.mean().item()
+    }
+    return measurements

external/WildCamera/WildCamera/evaluation/evaluate_fov.py

@@ -0,0 +1,142 @@
+import sys, os, time, inspect, tabulate
+import tqdm
+import numpy as np
+
+import torch
+import torch.distributed as dist
+from torch.utils.data import DataLoader
+
+from loguru import logger
+
+from tools.tools import to_cuda
+from tools.calibrator import MonocularCalibrator
+from tools.tools import DistributedSamplerNoEvenlyDivisible
+from WildCamera.datasets.IncdDataset import IncdDataset
+
+class EvaluateFov:
+
+    def __init__(self):
+        self.min_fovy = np.inf
+
+    def evaluate(self, model, args, steps, writer=None, group=None, wtassumption=False, split='test'):
+
+        if len(args.datasets_eval) > 1:
+            autosave = False
+        else:
+            autosave = True
+
+        measurements_all = dict()
+
+        for dataaset in args.datasets_eval:
+
+            if dataaset in args.datasets_train:
+                augmentation = True
+            else:
+                augmentation = False
+
+            val_dataset = IncdDataset(
+                data_root=args.data_path,
+                datasets_included=[dataaset],
+                ht=args.input_height,
+                wt=args.input_width,
+                augmentation=augmentation,
+                shuffleseed=None,
+                split=split,
+                augscale=args.augscale,
+                no_change_prob=0.0
+            )
+            measurements = evaluate_fov(model, val_dataset, args, group, wtassumption=wtassumption)
+            measurements_all[dataaset] = measurements
+
+            if args.gpu == 0:
+                if writer is not None and (steps > 0):
+                    for k in measurements.keys():
+                        writer.add_scalar('Eval_{}/{}'.format(dataaset, k), measurements[k], steps)
+
+            if args.gpu == 0 and autosave and (steps > 0):
+                if measurements['error_fovy'] < self.min_fovy:
+                    self.min_fovy = measurements['error_fovy']
+                    svpath = os.path.join(args.saving_location, 'model_zoo', args.experiment_name, 'min_fovy.ckpt')
+                    try:
+                        model_ = model.module
+                    except:
+                        model_ = model
+                    torch.save(model_.state_dict(), svpath)
+                    logger.info("Save to %s" % svpath)
+
+        if args.gpu == 0 and (not autosave) and (steps > 0):
+            try:
+                model_ = model.module
+            except:
+                model_ = model
+            torch.save(
+                model_.state_dict(),
+                os.path.join(args.saving_location, 'model_zoo', args.experiment_name, 'step_{}.ckpt'.format(str(steps)))
+            )
+
+        if args.gpu == 0:
+            errors_all_mean = [['Datasets', 'error_fovy', 'error_fovy_medi']]
+            for key in measurements_all.keys():
+                measurements = measurements_all[key]
+                errors_all_mean.append(
+                    [
+                        key,
+                        measurements['error_fovy'],
+                        measurements['error_fovy_medi'],
+                    ]
+                )
+            logger.info(
+                "\n====================  Performance at Step %d with Assumption %d ====================\n" % (steps, wtassumption) +
+                tabulate.tabulate(errors_all_mean, headers='firstrow', tablefmt='fancy_grid', numalign="center", floatfmt=".3f"))
+
+        torch.cuda.synchronize()
+        return
+
+@torch.no_grad()
+def evaluate_fov(model, val_dataset, args, group=None, wtassumption=False):
+    """ In Validation, random sample N Images to mimic a real test set situation  """
+    monocalibrator = MonocularCalibrator(l1_th=args.l1_th)
+    model.eval()
+    if args.world_size > 1:
+        sampler = DistributedSamplerNoEvenlyDivisible(val_dataset, shuffle=False)
+        val_loader = DataLoader(val_dataset, batch_size=1, sampler=sampler, pin_memory=False, shuffle=False, num_workers=args.eval_workers, drop_last=False)
+    else:
+        val_loader = DataLoader(val_dataset, batch_size=1, pin_memory=False, shuffle=False, num_workers=args.eval_workers, drop_last=False)
+
+    measurements = torch.zeros(len(val_dataset), 6).cuda(device=args.gpu)
+    world_size = args.world_size
+
+    for val_id, data_blob in enumerate(tqdm.tqdm(val_loader, disable=False)):
+        sample_batched = to_cuda(data_blob)
+        rgb, K, r = sample_batched['rgb'], sample_batched['K'], sample_batched['aspect_ratio_restoration']
+
+        incidence = model(rgb)
+        if not wtassumption:
+            Kgt, Kest = torch.clone(K).squeeze(0), monocalibrator.calibrate_camera_4DoF(incidence, RANSAC_trial=2048)
+        else:
+            Kgt, Kest = torch.clone(K).squeeze(0), monocalibrator.calibrate_camera_1DoF(incidence, r=r.item())
+
+        b, _, h, w = rgb.shape
+        device = rgb.device
+
+        fovy_est, fovy_gt = 2 * torch.arctan(h / Kest[1, 1] / 2), sample_batched['fovy']
+        error_fovy = np.abs(np.degrees(fovy_est.item()) - np.degrees(fovy_gt.item()))
+
+        error_all = np.array([error_fovy])
+        error_all = torch.from_numpy(error_all).float().to(device)
+
+        measurements[val_id * world_size + args.gpu] += error_all
+
+    if args.world_size > 1:
+        dist.all_reduce(tensor=measurements, op=dist.ReduceOp.SUM, group=group)
+
+    zero_entry = torch.sum(measurements.abs(), dim=1) == 0
+    assert torch.sum(zero_entry) == 0
+
+    fovy_median = torch.median(measurements.squeeze())
+    measurements = torch.mean(measurements, dim=0)
+    measurements = {
+        'error_fovy': measurements[0].item(),
+        'error_fovy_medi': fovy_median.item()
+    }
+    return measurements

external/WildCamera/WildCamera/evaluation/evaluate_intrinsic.py

@@ -0,0 +1,144 @@
+import sys, os, time, inspect, tabulate
+import tqdm
+import numpy as np
+
+import torch
+import torch.distributed as dist
+from torch.utils.data import DataLoader
+
+from loguru import logger
+
+from tools.tools import to_cuda
+from tools.calibrator import MonocularCalibrator
+from tools.evaluation import compute_intrinsic_measure
+from tools.tools import DistributedSamplerNoEvenlyDivisible
+from WildCamera.datasets.IncdDataset import IncdDataset
+
+class EvaluateIntrinsic:
+    def __init__(self):
+        self.min_focal = 1e10
+
+    def evaluate(self, model, args, steps, writer=None, group=None, wtassumption=False):
+
+        if len(args.datasets_eval) > 1:
+            autosave = False
+        else:
+            autosave = True
+
+        measurements_all = dict()
+
+        for dataaset in args.datasets_eval:
+
+            if dataaset in args.datasets_train:
+                augmentation = True
+            else:
+                augmentation = False
+
+            val_dataset = IncdDataset(
+                data_root=args.data_path,
+                datasets_included=[dataaset],
+                ht=args.input_height,
+                wt=args.input_width,
+                augmentation=augmentation,
+                shuffleseed=None,
+                split='test',
+                augscale=args.augscale,
+                no_change_prob=0.0,
+                transformcategory='transform_calibration'
+            )
+            measurements = evaluate_intrinsic(model, val_dataset, args, group, wtassumption=wtassumption)
+            measurements_all[dataaset] = measurements
+
+            if args.gpu == 0:
+                if writer is not None and (steps > 0):
+                    for k in measurements.keys():
+                        writer.add_scalar('Eval_{}/{}'.format(dataaset, k), measurements[k], steps)
+
+            if args.gpu == 0 and autosave and (steps > 0):
+                if measurements['error_f'] < self.min_focal:
+                    self.min_focal = measurements['error_f']
+                    svpath = os.path.join(args.saving_location, 'model_zoo', args.experiment_name, 'min_focal.ckpt')
+                    torch.save(model.state_dict(), svpath)
+                    logger.info("Save to %s" % svpath)
+
+        if args.gpu == 0 and (not autosave) and (steps > 0):
+            torch.save(model.state_dict(), os.path.join(args.saving_location, 'model_zoo', args.experiment_name, 'step_{}.ckpt'.format(str(steps))))
+
+        if args.gpu == 0:
+            errors_all_mean = [['Datasets', 'error_fx', 'error_fy', 'error_f', 'error_bx', 'error_by', 'error_b']]
+            for key in measurements_all.keys():
+                measurements = measurements_all[key]
+                errors_all_mean.append(
+                    [
+                        key,
+                        measurements['error_fx'],
+                        measurements['error_fy'],
+                        measurements['error_f'],
+                        measurements['error_bx'],
+                        measurements['error_by'],
+                        measurements['error_b']
+                    ]
+                )
+            logger.info(
+                "\n====================  Performance at Step %d with Assumption %d ====================\n" % (steps, wtassumption) +
+                tabulate.tabulate(errors_all_mean, headers='firstrow', tablefmt='fancy_grid', numalign="center", floatfmt=".3f"))
+
+        torch.cuda.synchronize()
+        return
+
+@torch.no_grad()
+def evaluate_intrinsic(model, val_dataset, args, group=None, wtassumption=False):
+    """ In Validation, random sample N Images to mimic a real test set situation  """
+    monocalibrator = MonocularCalibrator(l1_th=args.l1_th)
+    model.eval()
+    if args.world_size > 1:
+        sampler = DistributedSamplerNoEvenlyDivisible(val_dataset, shuffle=False)
+        val_loader = DataLoader(val_dataset, batch_size=1, sampler=sampler, pin_memory=False, shuffle=False, num_workers=args.eval_workers, drop_last=False)
+    else:
+        val_loader = DataLoader(val_dataset, batch_size=1, pin_memory=False, shuffle=False, num_workers=args.eval_workers, drop_last=False)
+
+    measurements = torch.zeros(len(val_dataset), 6).cuda(device=args.gpu)
+    world_size = args.world_size
+
+    for val_id, data_blob in enumerate(tqdm.tqdm(val_loader, disable=False)):
+        sample_batched = to_cuda(data_blob)
+        rgb, K, r = sample_batched['rgb'], sample_batched['K'], sample_batched['aspect_ratio_restoration']
+
+        incidence = model(rgb)
+        if not wtassumption:
+            Kgt, Kest = torch.clone(K).squeeze(0), monocalibrator.calibrate_camera_4DoF(incidence, RANSAC_trial=2048)
+        else:
+            Kgt, Kest = torch.clone(K).squeeze(0), monocalibrator.calibrate_camera_1DoF(incidence, r=r.item())
+
+        b, _, h, w = rgb.shape
+        device = rgb.device
+
+        error_fx, error_fy, error_f, error_bx, error_by, error_b = compute_intrinsic_measure(
+            Kest=torch.clone(Kest),
+            Kgt=torch.clone(Kgt),
+            h=h,
+            w=w
+        )
+
+        error_all = np.array([error_fx, error_fy, error_f, error_bx, error_by, error_b])
+        error_all = torch.from_numpy(error_all).float().to(device)
+
+        measurements[val_id * world_size + args.gpu] += error_all
+
+    if args.world_size > 1:
+        dist.all_reduce(tensor=measurements, op=dist.ReduceOp.SUM, group=group)
+
+    zero_entry = torch.sum(measurements.abs(), dim=1) == 0
+    assert torch.sum(zero_entry) == 0
+
+    measurements = torch.mean(measurements, dim=0)
+    measurements = {
+        'error_fx': measurements[0].item(),
+        'error_fy': measurements[1].item(),
+        'error_f': measurements[2].item(),
+        'error_bx': measurements[3].item(),
+        'error_by': measurements[4].item(),
+        'error_b': measurements[5].item()
+    }
+
+    return measurements

external/WildCamera/WildCamera/evaluation/evaluate_pose.py

@@ -0,0 +1,209 @@
+# Put most Common Functions Here
+import cv2
+import torch
+import numpy as np
+import torch.nn.functional as F
+
+from einops.einops import rearrange
+
+# -- # Pose Benchmark
+def angle_error_mat(R1, R2):
+    cos = (np.trace(np.dot(R1.T, R2)) - 1) / 2
+    cos = np.clip(cos, -1.0, 1.0)  # numercial errors can make it out of bounds
+    return np.rad2deg(np.abs(np.arccos(cos)))
+
+def angle_error_vec(v1, v2):
+    n = np.linalg.norm(v1) * np.linalg.norm(v2)
+    return np.rad2deg(np.arccos(np.clip(np.dot(v1, v2) / n, -1.0, 1.0)))
+
+def compute_pose_error(T_0to1, R, t):
+    R_gt = T_0to1[:3, :3]
+    t_gt = T_0to1[:3, 3]
+    error_t = angle_error_vec(t.squeeze(), t_gt)
+    error_t = np.minimum(error_t, 180 - error_t)  # ambiguity of E estimation
+    error_R = angle_error_mat(R, R_gt)
+    return error_t, error_R
+
+def pose_auc(errors, thresholds):
+    sort_idx = np.argsort(errors)
+    errors = np.array(errors.copy())[sort_idx]
+    recall = (np.arange(len(errors)) + 1) / len(errors)
+    errors = np.r_[0.0, errors]
+    recall = np.r_[0.0, recall]
+    aucs = []
+    for t in thresholds:
+        last_index = np.searchsorted(errors, t)
+        r = np.r_[recall[:last_index], recall[last_index - 1]]
+        e = np.r_[errors[:last_index], t]
+        aucs.append(np.trapz(r, x=e) / t)
+    return aucs
+
+def compute_relative_pose(R1, t1, R2, t2):
+    rots = R2 @ (R1.T)
+    trans = -rots @ t1 + t2
+    return rots, trans
+
+def rotate_intrinsic(K, n):
+    base_rot = np.array([[0, 1, 0], [-1, 0, 0], [0, 0, 1]])
+    rot = np.linalg.matrix_power(base_rot, n)
+    return rot @ K
+
+def estimate_pose(kpts0, kpts1, K0, K1, norm_thresh, conf=0.99999):
+    if len(kpts0) < 5:
+        return None
+    K0inv = np.linalg.inv(K0[:2,:2])
+    K1inv = np.linalg.inv(K1[:2,:2])
+
+    kpts0 = (K0inv @ (kpts0-K0[None,:2,2]).T).T
+    kpts1 = (K1inv @ (kpts1-K1[None,:2,2]).T).T
+
+    E, mask = cv2.findEssentialMat(
+        kpts0, kpts1, np.eye(3), threshold=norm_thresh, prob=conf, method=cv2.RANSAC
+    )
+
+    ret = None
+    if E is not None:
+        best_num_inliers = 0
+
+        for _E in np.split(E, len(E) / 3):
+            n, R, t, _ = cv2.recoverPose(_E, kpts0, kpts1, np.eye(3), 1e9, mask=mask)
+            if n > best_num_inliers:
+                best_num_inliers = n
+                ret = (R, t, mask.ravel() > 0)
+    return ret
+
+
+# -- # Compute Error in EPE
+
+def compute_flow_metrics(depth1, depth2, T_1to2, K1, K2, dense_matches):
+    """[summary]
+
+    Args:
+        H ([type]): [description]
+        scale ([type]): [description]
+
+    Returns:
+        [type]: [description]
+    """
+    dense_matches = rearrange(dense_matches, "b d h w -> b h w d")
+    b, h1, w1, d = dense_matches.shape
+    x1_n = torch.meshgrid(
+        *[
+            torch.linspace(
+                -1 + 1 / n, 1 - 1 / n, n, device=dense_matches.device
+            )
+            for n in (b, h1, w1)
+        ]
+    )
+    x1_n = torch.stack((x1_n[2], x1_n[1]), dim=-1).reshape(b, h1 * w1, 2)
+    mask, x2 = warp_kpts(
+        x1_n.double(),
+        depth1.double(),
+        depth2.double(),
+        T_1to2.double(),
+        K1.double(),
+        K2.double(),
+    )
+    mask_validation = mask.float().reshape(b, h1, w1) > 0
+    x2 = x2.reshape(b, h1, w1, 2)
+
+    dense_matches = unnorm_coords_Numpystyle(
+        rearrange(dense_matches, "b h w d -> b d h w"),
+        h=h1, w=w1
+    )
+
+    x2 = unnorm_coords_Numpystyle(
+        rearrange(x2, "b h w d -> b d h w"),
+        h=h1, w=w1
+    )
+
+    epe = (dense_matches - x2).norm(dim=1)  # *scale?
+
+    evaluated_pixel_num = torch.sum(mask_validation)
+    epe_sum = torch.sum(epe[mask_validation])
+    px1 = torch.sum((epe < 1)[mask_validation])
+    px5 = torch.sum((epe < 5)[mask_validation])
+    px8 = torch.sum((epe < 8)[mask_validation])
+
+    sub_measurements = torch.stack([epe_sum, px1, px5, px8, evaluated_pixel_num])
+    return sub_measurements
+
+
+
+@torch.no_grad()
+def warp_kpts(kpts0, depth0, depth1, T_0to1, K0, K1):
+    """Warp kpts0 from I0 to I1 with depth, K and Rt
+    Also check covisibility and depth consistency.
+    Depth is consistent if relative error < 0.2 (hard-coded).
+    # https://github.com/zju3dv/LoFTR/blob/94e98b695be18acb43d5d3250f52226a8e36f839/src/loftr/utils/geometry.py adapted from here
+    Args:
+        kpts0 (torch.Tensor): [N, L, 2] - <x, y>, should be normalized in (-1,1)
+        depth0 (torch.Tensor): [N, H, W],
+        depth1 (torch.Tensor): [N, H, W],
+        T_0to1 (torch.Tensor): [N, 3, 4],
+        K0 (torch.Tensor): [N, 3, 3],
+        K1 (torch.Tensor): [N, 3, 3],
+    Returns:
+        calculable_mask (torch.Tensor): [N, L]
+        warped_keypoints0 (torch.Tensor): [N, L, 2] <x0_hat, y1_hat>
+    """
+    (
+        n,
+        h,
+        w,
+    ) = depth0.shape
+    kpts0_depth = F.grid_sample(depth0[:, None], kpts0[:, :, None], mode="bilinear", align_corners=False)[
+        :, 0, :, 0
+    ]
+    kpts0 = torch.stack(
+        (w * (kpts0[..., 0] + 1) / 2, h * (kpts0[..., 1] + 1) / 2), dim=-1
+    )  # [-1+1/h, 1-1/h] -> [0.5, h-0.5]
+    # Sample depth, get calculable_mask on depth != 0
+    nonzero_mask = kpts0_depth != 0
+
+    # Unproject
+    kpts0_h = (
+        torch.cat([kpts0, torch.ones_like(kpts0[:, :, [0]])], dim=-1)
+        * kpts0_depth[..., None]
+    )  # (N, L, 3)
+    kpts0_n = K0.inverse() @ kpts0_h.transpose(2, 1)  # (N, 3, L)
+    kpts0_cam = kpts0_n
+
+    # Rigid Transform
+    w_kpts0_cam = T_0to1[:, :3, :3] @ kpts0_cam + T_0to1[:, :3, [3]]  # (N, 3, L)
+    w_kpts0_depth_computed = w_kpts0_cam[:, 2, :]
+
+    # Project
+    w_kpts0_h = (K1 @ w_kpts0_cam).transpose(2, 1)  # (N, L, 3)
+    w_kpts0 = w_kpts0_h[:, :, :2] / (
+        w_kpts0_h[:, :, [2]] + 1e-4
+    )  # (N, L, 2), +1e-4 to avoid zero depth
+
+    # Covisible Check
+    h, w = depth1.shape[1:3]
+    covisible_mask = (
+        (w_kpts0[:, :, 0] > 0)
+        * (w_kpts0[:, :, 0] < w - 1)
+        * (w_kpts0[:, :, 1] > 0)
+        * (w_kpts0[:, :, 1] < h - 1)
+    )
+    w_kpts0 = torch.stack(
+        (2 * w_kpts0[..., 0] / w - 1, 2 * w_kpts0[..., 1] / h - 1), dim=-1
+    )  # from [0.5,h-0.5] -> [-1+1/h, 1-1/h]
+    # w_kpts0[~covisible_mask, :] = -5 # xd
+
+    w_kpts0_depth = F.grid_sample(
+        depth1[:, None], w_kpts0[:, :, None], mode="bilinear", align_corners=False
+    )[:, 0, :, 0]
+    consistent_mask = (
+        (w_kpts0_depth - w_kpts0_depth_computed) / w_kpts0_depth
+    ).abs() < 0.05
+    valid_mask = nonzero_mask * covisible_mask * consistent_mask
+
+    return valid_mask, w_kpts0
+
+def unnorm_coords_Numpystyle(coords1, h, w):
+    coords1x, coords1y = torch.split(coords1, 1, dim=1)
+    coords1x = (coords1x + 1) / 2 * w
+    coords1y = (coords1y + 1) / 2 * h
+    return torch.cat([coords1x, coords1y], dim=1)

external/WildCamera/WildCamera/newcrfs/newcrf_incidencefield.py

@@ -0,0 +1,196 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import PIL.Image as Image
+
+import numpy as np
+
+from .swin_transformer import SwinTransformer
+from .newcrf_layers import NewCRF
+from .uper_crf_head import PSP
+
+from torchvision import transforms
+from tools.calibrator import MonocularCalibrator
+########################################################################################################################
+
+
+class NEWCRFIF(nn.Module):
+    """
+    Depth network based on neural window FC-CRFs architecture.
+    """
+    def __init__(self, pretrained=None, frozen_stages=-1, version='large07'):
+        super().__init__()
+
+        self.with_auxiliary_head = False
+        self.with_neck = False
+
+        norm_cfg = dict(type='BN', requires_grad=True)
+
+        window_size = int(version[-2:])
+
+        if version[:-2] == 'base':
+            embed_dim = 128
+            depths = [2, 2, 18, 2]
+            num_heads = [4, 8, 16, 32]
+            in_channels = [128, 256, 512, 1024]
+        elif version[:-2] == 'large':
+            embed_dim = 192
+            depths = [2, 2, 18, 2]
+            num_heads = [6, 12, 24, 48]
+            in_channels = [192, 384, 768, 1536]
+        elif version[:-2] == 'tiny':
+            embed_dim = 96
+            depths = [2, 2, 6, 2]
+            num_heads = [3, 6, 12, 24]
+            in_channels = [96, 192, 384, 768]
+
+        backbone_cfg = dict(
+            embed_dim=embed_dim,
+            depths=depths,
+            num_heads=num_heads,
+            window_size=window_size,
+            ape=False,
+            drop_path_rate=0.3,
+            patch_norm=True,
+            use_checkpoint=False,
+            frozen_stages=frozen_stages
+        )
+
+        embed_dim = 512
+        decoder_cfg = dict(
+            in_channels=in_channels,
+            in_index=[0, 1, 2, 3],
+            pool_scales=(1, 2, 3, 6),
+            channels=embed_dim,
+            dropout_ratio=0.0,
+            num_classes=32,
+            norm_cfg=norm_cfg,
+            align_corners=False
+        )
+
+        self.backbone = SwinTransformer(**backbone_cfg)
+        v_dim = decoder_cfg['num_classes']*4
+        win = 7
+        crf_dims = [128, 256, 512, 1024]
+        v_dims = [64, 128, 256, embed_dim]
+        self.crf3 = NewCRF(input_dim=in_channels[3], embed_dim=crf_dims[3], window_size=win, v_dim=v_dims[3], num_heads=32)
+        self.crf2 = NewCRF(input_dim=in_channels[2], embed_dim=crf_dims[2], window_size=win, v_dim=v_dims[2], num_heads=16)
+        self.crf1 = NewCRF(input_dim=in_channels[1], embed_dim=crf_dims[1], window_size=win, v_dim=v_dims[1], num_heads=8)
+        self.crf0 = NewCRF(input_dim=in_channels[0], embed_dim=crf_dims[0], window_size=win, v_dim=v_dims[0], num_heads=4)
+
+        self.decoder = PSP(**decoder_cfg)
+
+        self.incidence_head = IncidenceHead(input_dim=crf_dims[0], output_dim=3)
+
+        self.up_mode = 'bilinear'
+        if self.up_mode == 'mask':
+            self.mask_head = nn.Sequential(
+                nn.Conv2d(crf_dims[0], 64, 3, padding=1),
+                nn.ReLU(inplace=True),
+                nn.Conv2d(64, 16*9, 1, padding=0))
+
+        self.init_weights(pretrained=pretrained)
+
+    def init_weights(self, pretrained=None):
+        """Initialize the weights in backbone and heads.
+
+        Args:
+            pretrained (str, optional): Path to pre-trained weights.
+                Defaults to None.
+        """
+        print(f'== Load encoder backbone from: {pretrained}')
+        self.backbone.init_weights(pretrained=pretrained)
+        self.decoder.init_weights()
+        if self.with_auxiliary_head:
+            if isinstance(self.auxiliary_head, nn.ModuleList):
+                for aux_head in self.auxiliary_head:
+                    aux_head.init_weights()
+            else:
+                self.auxiliary_head.init_weights()
+
+    def upsample_mask(self, disp, mask):
+        """ Upsample disp [H/4, W/4, 1] -> [H, W, 1] using convex combination """
+        N, _, H, W = disp.shape
+        mask = mask.view(N, 1, 9, 4, 4, H, W)
+        mask = torch.softmax(mask, dim=2)
+
+        up_disp = F.unfold(disp, kernel_size=3, padding=1)
+        up_disp = up_disp.view(N, 1, 9, 1, 1, H, W)
+
+        up_disp = torch.sum(mask * up_disp, dim=2)
+        up_disp = up_disp.permute(0, 1, 4, 2, 5, 3)
+        return up_disp.reshape(N, 1, 4*H, 4*W)
+
+    def forward(self, imgs):
+        feats = self.backbone(imgs)
+        if self.with_neck:
+            feats = self.neck(feats)
+
+        ppm_out = self.decoder(feats)
+
+        e3 = self.crf3(feats[3], ppm_out)
+        e3 = nn.PixelShuffle(2)(e3)
+        e2 = self.crf2(feats[2], e3)
+        e2 = nn.PixelShuffle(2)(e2)
+        e1 = self.crf1(feats[1], e2)
+        e1 = nn.PixelShuffle(2)(e1)
+        e0 = self.crf0(feats[0], e1)
+
+        incidence = self.incidence_head(e0, 4)
+
+        return incidence
+
+    @torch.no_grad()
+    def inference(self, rgb, wtassumption=False):
+        self.eval()
+        input_wt, input_ht = 640, 480
+        w, h = rgb.size
+
+        rgb = rgb.resize((input_wt, input_ht), Image.Resampling.BILINEAR)
+
+        scaleM = np.eye(3)
+        scaleM[0, 0] = input_wt / w
+        scaleM[1, 1] = input_ht / h
+        scaleM = torch.from_numpy(scaleM).float().to(next(self.parameters()).device)
+
+        normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        totensor = transforms.ToTensor()
+
+        rgb = normalize(totensor(rgb))
+        rgb = rgb.unsqueeze(0).to(next(self.parameters()).device)
+
+        monocalibrator = MonocularCalibrator()
+        incidence = self.forward(rgb)
+
+        if not wtassumption:
+            Kest = monocalibrator.calibrate_camera_4DoF(incidence)
+        else:
+            r = (scaleM[1, 1] / scaleM[0, 0]).item()
+            Kest = monocalibrator.calibrate_camera_1DoF(incidence, r=r)
+
+        Kest = torch.inverse(scaleM) @ Kest
+        return Kest.detach().squeeze().cpu().numpy(), incidence
+
+    @torch.no_grad()
+    def restore_image(self, rgb, intrinsic, fixcrop=True):
+        monocalibrator = MonocularCalibrator()
+        return monocalibrator.restore_image(rgb, intrinsic, fixcrop)
+
+class IncidenceHead(nn.Module):
+    def __init__(self, input_dim=100, output_dim=3):
+        super(IncidenceHead, self).__init__()
+        self.conv1 = nn.Conv2d(input_dim, output_dim, 3, padding=1)
+
+    def forward(self, x, scale):
+        x = self.conv1(x)
+        if scale > 1:
+            x = upsample(x, scale_factor=scale)
+
+        incidence = torch.nn.functional.normalize(x, dim=1)
+        return incidence
+
+
+def upsample(x, scale_factor=2, mode="bilinear", align_corners=False):
+    """Upsample input tensor by a factor of 2
+    """
+    return F.interpolate(x, scale_factor=scale_factor, mode=mode, align_corners=align_corners)

external/WildCamera/WildCamera/newcrfs/newcrf_layers.py

@@ -0,0 +1,433 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.checkpoint as checkpoint
+import numpy as np
+from timm.models.layers import DropPath, to_2tuple, trunc_normal_
+
+
+class Mlp(nn.Module):
+    """ Multilayer perceptron."""
+
+    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
+        super().__init__()
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        self.fc1 = nn.Linear(in_features, hidden_features)
+        self.act = act_layer()
+        self.fc2 = nn.Linear(hidden_features, out_features)
+        self.drop = nn.Dropout(drop)
+
+    def forward(self, x):
+        x = self.fc1(x)
+        x = self.act(x)
+        x = self.drop(x)
+        x = self.fc2(x)
+        x = self.drop(x)
+        return x
+
+
+def window_partition(x, window_size):
+    """
+    Args:
+        x: (B, H, W, C)
+        window_size (int): window size
+
+    Returns:
+        windows: (num_windows*B, window_size, window_size, C)
+    """
+    B, H, W, C = x.shape
+    x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)
+    windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
+    return windows
+
+
+def window_reverse(windows, window_size, H, W):
+    """
+    Args:
+        windows: (num_windows*B, window_size, window_size, C)
+        window_size (int): Window size
+        H (int): Height of image
+        W (int): Width of image
+
+    Returns:
+        x: (B, H, W, C)
+    """
+    B = int(windows.shape[0] / (H * W / window_size / window_size))
+    x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)
+    x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
+    return x
+
+
+class WindowAttention(nn.Module):
+    """ Window based multi-head self attention (W-MSA) module with relative position bias.
+    It supports both of shifted and non-shifted window.
+
+    Args:
+        dim (int): Number of input channels.
+        window_size (tuple[int]): The height and width of the window.
+        num_heads (int): Number of attention heads.
+        qkv_bias (bool, optional):  If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set
+        attn_drop (float, optional): Dropout ratio of attention weight. Default: 0.0
+        proj_drop (float, optional): Dropout ratio of output. Default: 0.0
+    """
+
+    def __init__(self, dim, window_size, num_heads, v_dim, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.):
+
+        super().__init__()
+        self.dim = dim
+        self.window_size = window_size  # Wh, Ww
+        self.num_heads = num_heads
+        head_dim = dim // num_heads
+        self.scale = qk_scale or head_dim ** -0.5
+
+        # define a parameter table of relative position bias
+        self.relative_position_bias_table = nn.Parameter(
+            torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads))  # 2*Wh-1 * 2*Ww-1, nH
+
+        # get pair-wise relative position index for each token inside the window
+        coords_h = torch.arange(self.window_size[0])
+        coords_w = torch.arange(self.window_size[1])
+        coords = torch.stack(torch.meshgrid([coords_h, coords_w]))  # 2, Wh, Ww
+        coords_flatten = torch.flatten(coords, 1)  # 2, Wh*Ww
+        relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :]  # 2, Wh*Ww, Wh*Ww
+        relative_coords = relative_coords.permute(1, 2, 0).contiguous()  # Wh*Ww, Wh*Ww, 2
+        relative_coords[:, :, 0] += self.window_size[0] - 1  # shift to start from 0
+        relative_coords[:, :, 1] += self.window_size[1] - 1
+        relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1
+        relative_position_index = relative_coords.sum(-1)  # Wh*Ww, Wh*Ww
+        self.register_buffer("relative_position_index", relative_position_index)
+
+        self.qk = nn.Linear(dim, dim * 2, bias=qkv_bias)
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(v_dim, v_dim)
+        self.proj_drop = nn.Dropout(proj_drop)
+
+        trunc_normal_(self.relative_position_bias_table, std=.02)
+        self.softmax = nn.Softmax(dim=-1)
+
+    def forward(self, x, v, mask=None):
+        """ Forward function.
+
+        Args:
+            x: input features with shape of (num_windows*B, N, C)
+            mask: (0/-inf) mask with shape of (num_windows, Wh*Ww, Wh*Ww) or None
+        """
+        B_, N, C = x.shape
+        qk = self.qk(x).reshape(B_, N, 2, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+        q, k = qk[0], qk[1]  # make torchscript happy (cannot use tensor as tuple)
+
+        q = q * self.scale
+        attn = (q @ k.transpose(-2, -1))
+
+        relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(
+            self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1)  # Wh*Ww,Wh*Ww,nH
+        relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()  # nH, Wh*Ww, Wh*Ww
+        attn = attn + relative_position_bias.unsqueeze(0)
+
+        if mask is not None:
+            nW = mask.shape[0]
+            attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)
+            attn = attn.view(-1, self.num_heads, N, N)
+            attn = self.softmax(attn)
+        else:
+            attn = self.softmax(attn)
+
+        attn = self.attn_drop(attn)
+        
+        # assert self.dim % v.shape[-1] == 0, "self.dim % v.shape[-1] != 0"
+        # repeat_num = self.dim // v.shape[-1]
+        # v = v.view(B_, N, self.num_heads // repeat_num, -1).transpose(1, 2).repeat(1, repeat_num, 1, 1)
+
+        assert self.dim == v.shape[-1], "self.dim != v.shape[-1]"
+        v = v.view(B_, N, self.num_heads, -1).transpose(1, 2)
+
+        x = (attn @ v).transpose(1, 2).reshape(B_, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+
+class CRFBlock(nn.Module):
+    """ CRF Block.
+
+    Args:
+        dim (int): Number of input channels.
+        num_heads (int): Number of attention heads.
+        window_size (int): Window size.
+        shift_size (int): Shift size for SW-MSA.
+        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
+        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
+        drop (float, optional): Dropout rate. Default: 0.0
+        attn_drop (float, optional): Attention dropout rate. Default: 0.0
+        drop_path (float, optional): Stochastic depth rate. Default: 0.0
+        act_layer (nn.Module, optional): Activation layer. Default: nn.GELU
+        norm_layer (nn.Module, optional): Normalization layer.  Default: nn.LayerNorm
+    """
+
+    def __init__(self, dim, num_heads, v_dim, window_size=7, shift_size=0,
+                 mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0., drop_path=0.,
+                 act_layer=nn.GELU, norm_layer=nn.LayerNorm):
+        super().__init__()
+        self.dim = dim
+        self.num_heads = num_heads
+        self.v_dim = v_dim
+        self.window_size = window_size
+        self.shift_size = shift_size
+        self.mlp_ratio = mlp_ratio
+        assert 0 <= self.shift_size < self.window_size, "shift_size must in 0-window_size"
+
+        self.norm1 = norm_layer(dim)
+        self.attn = WindowAttention(
+            dim, window_size=to_2tuple(self.window_size), num_heads=num_heads, v_dim=v_dim,
+            qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)
+
+        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
+        self.norm2 = norm_layer(v_dim)
+        mlp_hidden_dim = int(v_dim * mlp_ratio)
+        self.mlp = Mlp(in_features=v_dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
+
+        self.H = None
+        self.W = None
+
+    def forward(self, x, v, mask_matrix):
+        """ Forward function.
+
+        Args:
+            x: Input feature, tensor size (B, H*W, C).
+            H, W: Spatial resolution of the input feature.
+            mask_matrix: Attention mask for cyclic shift.
+        """
+        B, L, C = x.shape
+        H, W = self.H, self.W
+        assert L == H * W, "input feature has wrong size"
+
+        shortcut = x
+        x = self.norm1(x)
+        x = x.view(B, H, W, C)
+
+        # pad feature maps to multiples of window size
+        pad_l = pad_t = 0
+        pad_r = (self.window_size - W % self.window_size) % self.window_size
+        pad_b = (self.window_size - H % self.window_size) % self.window_size
+        x = F.pad(x, (0, 0, pad_l, pad_r, pad_t, pad_b))
+        v = F.pad(v, (0, 0, pad_l, pad_r, pad_t, pad_b))
+        _, Hp, Wp, _ = x.shape
+
+        # cyclic shift
+        if self.shift_size > 0:
+            shifted_x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))
+            shifted_v = torch.roll(v, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))
+            attn_mask = mask_matrix
+        else:
+            shifted_x = x
+            shifted_v = v
+            attn_mask = None
+
+        # partition windows
+        x_windows = window_partition(shifted_x, self.window_size)  # nW*B, window_size, window_size, C
+        x_windows = x_windows.view(-1, self.window_size * self.window_size, C)  # nW*B, window_size*window_size, C
+        v_windows = window_partition(shifted_v, self.window_size)  # nW*B, window_size, window_size, C
+        v_windows = v_windows.view(-1, self.window_size * self.window_size, v_windows.shape[-1])  # nW*B, window_size*window_size, C
+        
+        # W-MSA/SW-MSA
+        attn_windows = self.attn(x_windows, v_windows, mask=attn_mask)  # nW*B, window_size*window_size, C
+
+        # merge windows
+        attn_windows = attn_windows.view(-1, self.window_size, self.window_size, self.v_dim)
+        shifted_x = window_reverse(attn_windows, self.window_size, Hp, Wp)  # B H' W' C
+
+        # reverse cyclic shift
+        if self.shift_size > 0:
+            x = torch.roll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2))
+        else:
+            x = shifted_x
+
+        if pad_r > 0 or pad_b > 0:
+            x = x[:, :H, :W, :].contiguous()
+
+        x = x.view(B, H * W, self.v_dim)
+
+        # FFN
+        x = shortcut + self.drop_path(x)
+        x = x + self.drop_path(self.mlp(self.norm2(x)))
+
+        return x
+
+
+class BasicCRFLayer(nn.Module):
+    """ A basic NeWCRFs layer for one stage.
+
+    Args:
+        dim (int): Number of feature channels
+        depth (int): Depths of this stage.
+        num_heads (int): Number of attention head.
+        window_size (int): Local window size. Default: 7.
+        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4.
+        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
+        drop (float, optional): Dropout rate. Default: 0.0
+        attn_drop (float, optional): Attention dropout rate. Default: 0.0
+        drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0
+        norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
+        downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None
+        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
+    """
+
+    def __init__(self,
+                 dim,
+                 depth,
+                 num_heads,
+                 v_dim,
+                 window_size=7,
+                 mlp_ratio=4.,
+                 qkv_bias=True,
+                 qk_scale=None,
+                 drop=0.,
+                 attn_drop=0.,
+                 drop_path=0.,
+                 norm_layer=nn.LayerNorm,
+                 downsample=None,
+                 use_checkpoint=False):
+        super().__init__()
+        self.window_size = window_size
+        self.shift_size = window_size // 2
+        self.depth = depth
+        self.use_checkpoint = use_checkpoint
+
+        # build blocks
+        self.blocks = nn.ModuleList([
+            CRFBlock(
+                dim=dim,
+                num_heads=num_heads,
+                v_dim=v_dim,
+                window_size=window_size,
+                shift_size=0 if (i % 2 == 0) else window_size // 2,
+                mlp_ratio=mlp_ratio,
+                qkv_bias=qkv_bias,
+                qk_scale=qk_scale,
+                drop=drop,
+                attn_drop=attn_drop,
+                drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,
+                norm_layer=norm_layer)
+            for i in range(depth)])
+
+        # patch merging layer
+        if downsample is not None:
+            self.downsample = downsample(dim=dim, norm_layer=norm_layer)
+        else:
+            self.downsample = None
+
+    def forward(self, x, v, H, W):
+        """ Forward function.
+
+        Args:
+            x: Input feature, tensor size (B, H*W, C).
+            H, W: Spatial resolution of the input feature.
+        """
+
+        # calculate attention mask for SW-MSA
+        Hp = int(np.ceil(H / self.window_size)) * self.window_size
+        Wp = int(np.ceil(W / self.window_size)) * self.window_size
+        img_mask = torch.zeros((1, Hp, Wp, 1), device=x.device)  # 1 Hp Wp 1
+        h_slices = (slice(0, -self.window_size),
+                    slice(-self.window_size, -self.shift_size),
+                    slice(-self.shift_size, None))
+        w_slices = (slice(0, -self.window_size),
+                    slice(-self.window_size, -self.shift_size),
+                    slice(-self.shift_size, None))
+        cnt = 0
+        for h in h_slices:
+            for w in w_slices:
+                img_mask[:, h, w, :] = cnt
+                cnt += 1
+
+        mask_windows = window_partition(img_mask, self.window_size)  # nW, window_size, window_size, 1
+        mask_windows = mask_windows.view(-1, self.window_size * self.window_size)
+        attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
+        attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))
+
+        for blk in self.blocks:
+            blk.H, blk.W = H, W
+            if self.use_checkpoint:
+                x = checkpoint.checkpoint(blk, x, attn_mask)
+            else:
+                x = blk(x, v, attn_mask)
+        if self.downsample is not None:
+            x_down = self.downsample(x, H, W)
+            Wh, Ww = (H + 1) // 2, (W + 1) // 2
+            return x, H, W, x_down, Wh, Ww
+        else:
+            return x, H, W, x, H, W
+
+
+class NewCRF(nn.Module):
+    def __init__(self,
+                 input_dim=96,
+                 embed_dim=96,
+                 v_dim=64,
+                 window_size=7,
+                 num_heads=4,
+                 depth=2,
+                 patch_size=4,
+                 in_chans=3,
+                 norm_layer=nn.LayerNorm,
+                 patch_norm=True):
+        super().__init__()
+
+        self.embed_dim = embed_dim
+        self.patch_norm = patch_norm
+        
+        if input_dim != embed_dim:
+            self.proj_x = nn.Conv2d(input_dim, embed_dim, 3, padding=1)
+        else:
+            self.proj_x = None
+
+        if v_dim != embed_dim:
+            self.proj_v = nn.Conv2d(v_dim, embed_dim, 3, padding=1)
+        elif embed_dim % v_dim == 0:
+            self.proj_v = None
+
+        # For now, v_dim need to be equal to embed_dim, because the output of window-attn is the input of shift-window-attn
+        v_dim = embed_dim
+        assert v_dim == embed_dim
+
+        self.crf_layer = BasicCRFLayer(
+                dim=embed_dim,
+                depth=depth,
+                num_heads=num_heads,
+                v_dim=v_dim,
+                window_size=window_size,
+                mlp_ratio=4.,
+                qkv_bias=True,
+                qk_scale=None,
+                drop=0.,
+                attn_drop=0.,
+                drop_path=0.,
+                norm_layer=norm_layer,
+                downsample=None,
+                use_checkpoint=False)
+
+        layer = norm_layer(embed_dim)
+        layer_name = 'norm_crf'
+        self.add_module(layer_name, layer)
+
+
+    def forward(self, x, v):
+        if self.proj_x is not None:
+            x = self.proj_x(x)
+        if self.proj_v is not None:
+            v = self.proj_v(v)
+
+        Wh, Ww = x.size(2), x.size(3)
+        x = x.flatten(2).transpose(1, 2)
+        v = v.transpose(1, 2).transpose(2, 3)
+
+        x_out, H, W, x, Wh, Ww = self.crf_layer(x, v, Wh, Ww)
+        norm_layer = getattr(self, f'norm_crf')
+        x_out = norm_layer(x_out)
+        out = x_out.view(-1, H, W, self.embed_dim).permute(0, 3, 1, 2).contiguous()
+
+        return out

external/WildCamera/WildCamera/newcrfs/newcrf_utils.py

@@ -0,0 +1,264 @@
+import warnings
+import os
+import os.path as osp
+import pkgutil
+import warnings
+from collections import OrderedDict
+from importlib import import_module
+
+import torch
+import torchvision
+import torch.nn as nn
+from torch.utils import model_zoo
+from torch.nn import functional as F
+from torch.nn.parallel import DataParallel, DistributedDataParallel
+from torch import distributed as dist
+
+TORCH_VERSION = torch.__version__
+
+
+def resize(input,
+           size=None,
+           scale_factor=None,
+           mode='nearest',
+           align_corners=None,
+           warning=True):
+    if warning:
+        if size is not None and align_corners:
+            input_h, input_w = tuple(int(x) for x in input.shape[2:])
+            output_h, output_w = tuple(int(x) for x in size)
+            if output_h > input_h or output_w > output_h:
+                if ((output_h > 1 and output_w > 1 and input_h > 1
+                     and input_w > 1) and (output_h - 1) % (input_h - 1)
+                        and (output_w - 1) % (input_w - 1)):
+                    warnings.warn(
+                        f'When align_corners={align_corners}, '
+                        'the output would more aligned if '
+                        f'input size {(input_h, input_w)} is `x+1` and '
+                        f'out size {(output_h, output_w)} is `nx+1`')
+    if isinstance(size, torch.Size):
+        size = tuple(int(x) for x in size)
+    return F.interpolate(input, size, scale_factor, mode, align_corners)
+
+
+def normal_init(module, mean=0, std=1, bias=0):
+    if hasattr(module, 'weight') and module.weight is not None:
+        nn.init.normal_(module.weight, mean, std)
+    if hasattr(module, 'bias') and module.bias is not None:
+        nn.init.constant_(module.bias, bias)
+
+
+def is_module_wrapper(module):
+    module_wrappers = (DataParallel, DistributedDataParallel)
+    return isinstance(module, module_wrappers)
+
+
+def get_dist_info():
+    if TORCH_VERSION < '1.0':
+        initialized = dist._initialized
+    else:
+        if dist.is_available():
+            initialized = dist.is_initialized()
+        else:
+            initialized = False
+    if initialized:
+        rank = dist.get_rank()
+        world_size = dist.get_world_size()
+    else:
+        rank = 0
+        world_size = 1
+    return rank, world_size
+
+
+def load_state_dict(module, state_dict, strict=False, logger=None):
+    """Load state_dict to a module.
+
+    This method is modified from :meth:`torch.nn.Module.load_state_dict`.
+    Default value for ``strict`` is set to ``False`` and the message for
+    param mismatch will be shown even if strict is False.
+
+    Args:
+        module (Module): Module that receives the state_dict.
+        state_dict (OrderedDict): Weights.
+        strict (bool): whether to strictly enforce that the keys
+            in :attr:`state_dict` match the keys returned by this module's
+            :meth:`~torch.nn.Module.state_dict` function. Default: ``False``.
+        logger (:obj:`logging.Logger`, optional): Logger to log the error
+            message. If not specified, print function will be used.
+    """
+    unexpected_keys = []
+    all_missing_keys = []
+    err_msg = []
+
+    metadata = getattr(state_dict, '_metadata', None)
+    state_dict = state_dict.copy()
+    if metadata is not None:
+        state_dict._metadata = metadata
+
+    # use _load_from_state_dict to enable checkpoint version control
+    def load(module, prefix=''):
+        # recursively check parallel module in case that the model has a
+        # complicated structure, e.g., nn.Module(nn.Module(DDP))
+        if is_module_wrapper(module):
+            module = module.module
+        local_metadata = {} if metadata is None else metadata.get(
+            prefix[:-1], {})
+        module._load_from_state_dict(state_dict, prefix, local_metadata, True,
+                                     all_missing_keys, unexpected_keys,
+                                     err_msg)
+        for name, child in module._modules.items():
+            if child is not None:
+                load(child, prefix + name + '.')
+
+    load(module)
+    load = None  # break load->load reference cycle
+
+    # ignore "num_batches_tracked" of BN layers
+    missing_keys = [
+        key for key in all_missing_keys if 'num_batches_tracked' not in key
+    ]
+
+    if unexpected_keys:
+        err_msg.append('unexpected key in source '
+                       f'state_dict: {", ".join(unexpected_keys)}\n')
+    if missing_keys:
+        err_msg.append(
+            f'missing keys in source state_dict: {", ".join(missing_keys)}\n')
+
+    rank, _ = get_dist_info()
+    if len(err_msg) > 0 and rank == 0:
+        err_msg.insert(
+            0, 'The model and loaded state dict do not match exactly\n')
+        err_msg = '\n'.join(err_msg)
+        if strict:
+            raise RuntimeError(err_msg)
+        elif logger is not None:
+            logger.warning(err_msg)
+        else:
+            print(err_msg)
+
+
+def load_url_dist(url, model_dir=None):
+    """In distributed setting, this function only download checkpoint at local
+    rank 0."""
+    rank, world_size = get_dist_info()
+    rank = int(os.environ.get('LOCAL_RANK', rank))
+    if rank == 0:
+        checkpoint = model_zoo.load_url(url, model_dir=model_dir)
+    if world_size > 1:
+        torch.distributed.barrier()
+        if rank > 0:
+            checkpoint = model_zoo.load_url(url, model_dir=model_dir)
+    return checkpoint
+
+
+def get_torchvision_models():
+    model_urls = dict()
+    for _, name, ispkg in pkgutil.walk_packages(torchvision.models.__path__):
+        if ispkg:
+            continue
+        _zoo = import_module(f'torchvision.models.{name}')
+        if hasattr(_zoo, 'model_urls'):
+            _urls = getattr(_zoo, 'model_urls')
+            model_urls.update(_urls)
+    return model_urls
+
+
+def _load_checkpoint(filename, map_location=None):
+    """Load checkpoint from somewhere (modelzoo, file, url).
+
+    Args:
+        filename (str): Accept local filepath, URL, ``torchvision://xxx``,
+            ``open-mmlab://xxx``. Please refer to ``docs/model_zoo.md`` for
+            details.
+        map_location (str | None): Same as :func:`torch.load`. Default: None.
+
+    Returns:
+        dict | OrderedDict: The loaded checkpoint. It can be either an
+            OrderedDict storing model weights or a dict containing other
+            information, which depends on the checkpoint.
+    """
+    if filename.startswith('modelzoo://'):
+        warnings.warn('The URL scheme of "modelzoo://" is deprecated, please '
+                      'use "torchvision://" instead')
+        model_urls = get_torchvision_models()
+        model_name = filename[11:]
+        checkpoint = load_url_dist(model_urls[model_name])
+    else:
+        if not osp.isfile(filename):
+            raise IOError(f'{filename} is not a checkpoint file')
+        checkpoint = torch.load(filename, map_location=map_location)
+    return checkpoint
+
+
+def load_checkpoint(model,
+                    filename,
+                    map_location='cpu',
+                    strict=False,
+                    logger=None):
+    """Load checkpoint from a file or URI.
+
+    Args:
+        model (Module): Module to load checkpoint.
+        filename (str): Accept local filepath, URL, ``torchvision://xxx``,
+            ``open-mmlab://xxx``. Please refer to ``docs/model_zoo.md`` for
+            details.
+        map_location (str): Same as :func:`torch.load`.
+        strict (bool): Whether to allow different params for the model and
+            checkpoint.
+        logger (:mod:`logging.Logger` or None): The logger for error message.
+
+    Returns:
+        dict or OrderedDict: The loaded checkpoint.
+    """
+    checkpoint = _load_checkpoint(filename, map_location)
+    # OrderedDict is a subclass of dict
+    if not isinstance(checkpoint, dict):
+        raise RuntimeError(
+            f'No state_dict found in checkpoint file {filename}')
+    # get state_dict from checkpoint
+    if 'state_dict' in checkpoint:
+        state_dict = checkpoint['state_dict']
+    elif 'model' in checkpoint:
+        state_dict = checkpoint['model']
+    else:
+        state_dict = checkpoint
+    # strip prefix of state_dict
+    if list(state_dict.keys())[0].startswith('module.'):
+        state_dict = {k[7:]: v for k, v in state_dict.items()}
+
+    # for MoBY, load model of online branch
+    if sorted(list(state_dict.keys()))[0].startswith('encoder'):
+        state_dict = {k.replace('encoder.', ''): v for k, v in state_dict.items() if k.startswith('encoder.')}
+
+    # reshape absolute position embedding
+    if state_dict.get('absolute_pos_embed') is not None:
+        absolute_pos_embed = state_dict['absolute_pos_embed']
+        N1, L, C1 = absolute_pos_embed.size()
+        N2, C2, H, W = model.absolute_pos_embed.size()
+        if N1 != N2 or C1 != C2 or L != H*W:
+            logger.warning("Error in loading absolute_pos_embed, pass")
+        else:
+            state_dict['absolute_pos_embed'] = absolute_pos_embed.view(N2, H, W, C2).permute(0, 3, 1, 2)
+
+    # interpolate position bias table if needed
+    relative_position_bias_table_keys = [k for k in state_dict.keys() if "relative_position_bias_table" in k]
+    for table_key in relative_position_bias_table_keys:
+        table_pretrained = state_dict[table_key]
+        table_current = model.state_dict()[table_key]
+        L1, nH1 = table_pretrained.size()
+        L2, nH2 = table_current.size()
+        if nH1 != nH2:
+            logger.warning(f"Error in loading {table_key}, pass")
+        else:
+            if L1 != L2:
+                S1 = int(L1 ** 0.5)
+                S2 = int(L2 ** 0.5)
+                table_pretrained_resized = F.interpolate(
+                     table_pretrained.permute(1, 0).view(1, nH1, S1, S1),
+                     size=(S2, S2), mode='bicubic')
+                state_dict[table_key] = table_pretrained_resized.view(nH2, L2).permute(1, 0)
+
+    # load state_dict
+    load_state_dict(model, state_dict, strict, logger)
+    return checkpoint

external/WildCamera/WildCamera/newcrfs/swin_transformer.py

@@ -0,0 +1,619 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.checkpoint as checkpoint
+import numpy as np
+from timm.models.layers import DropPath, to_2tuple, trunc_normal_
+
+from .newcrf_utils import load_checkpoint
+
+class Mlp(nn.Module):
+    """ Multilayer perceptron."""
+
+    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
+        super().__init__()
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        self.fc1 = nn.Linear(in_features, hidden_features)
+        self.act = act_layer()
+        self.fc2 = nn.Linear(hidden_features, out_features)
+        self.drop = nn.Dropout(drop)
+
+    def forward(self, x):
+        x = self.fc1(x)
+        x = self.act(x)
+        x = self.drop(x)
+        x = self.fc2(x)
+        x = self.drop(x)
+        return x
+
+
+def window_partition(x, window_size):
+    """
+    Args:
+        x: (B, H, W, C)
+        window_size (int): window size
+
+    Returns:
+        windows: (num_windows*B, window_size, window_size, C)
+    """
+    B, H, W, C = x.shape
+    x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)
+    windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
+    return windows
+
+
+def window_reverse(windows, window_size, H, W):
+    """
+    Args:
+        windows: (num_windows*B, window_size, window_size, C)
+        window_size (int): Window size
+        H (int): Height of image
+        W (int): Width of image
+
+    Returns:
+        x: (B, H, W, C)
+    """
+    B = int(windows.shape[0] / (H * W / window_size / window_size))
+    x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)
+    x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
+    return x
+
+
+class WindowAttention(nn.Module):
+    """ Window based multi-head self attention (W-MSA) module with relative position bias.
+    It supports both of shifted and non-shifted window.
+
+    Args:
+        dim (int): Number of input channels.
+        window_size (tuple[int]): The height and width of the window.
+        num_heads (int): Number of attention heads.
+        qkv_bias (bool, optional):  If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set
+        attn_drop (float, optional): Dropout ratio of attention weight. Default: 0.0
+        proj_drop (float, optional): Dropout ratio of output. Default: 0.0
+    """
+
+    def __init__(self, dim, window_size, num_heads, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.):
+
+        super().__init__()
+        self.dim = dim
+        self.window_size = window_size  # Wh, Ww
+        self.num_heads = num_heads
+        head_dim = dim // num_heads
+        self.scale = qk_scale or head_dim ** -0.5
+
+        # define a parameter table of relative position bias
+        self.relative_position_bias_table = nn.Parameter(
+            torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads))  # 2*Wh-1 * 2*Ww-1, nH
+
+        # get pair-wise relative position index for each token inside the window
+        coords_h = torch.arange(self.window_size[0])
+        coords_w = torch.arange(self.window_size[1])
+        coords = torch.stack(torch.meshgrid([coords_h, coords_w]))  # 2, Wh, Ww
+        coords_flatten = torch.flatten(coords, 1)  # 2, Wh*Ww
+        relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :]  # 2, Wh*Ww, Wh*Ww
+        relative_coords = relative_coords.permute(1, 2, 0).contiguous()  # Wh*Ww, Wh*Ww, 2
+        relative_coords[:, :, 0] += self.window_size[0] - 1  # shift to start from 0
+        relative_coords[:, :, 1] += self.window_size[1] - 1
+        relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1
+        relative_position_index = relative_coords.sum(-1)  # Wh*Ww, Wh*Ww
+        self.register_buffer("relative_position_index", relative_position_index)
+
+        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(dim, dim)
+        self.proj_drop = nn.Dropout(proj_drop)
+
+        trunc_normal_(self.relative_position_bias_table, std=.02)
+        self.softmax = nn.Softmax(dim=-1)
+
+    def forward(self, x, mask=None):
+        """ Forward function.
+
+        Args:
+            x: input features with shape of (num_windows*B, N, C)
+            mask: (0/-inf) mask with shape of (num_windows, Wh*Ww, Wh*Ww) or None
+        """
+        B_, N, C = x.shape
+        qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv[0], qkv[1], qkv[2]  # make torchscript happy (cannot use tensor as tuple)
+
+        q = q * self.scale
+        attn = (q @ k.transpose(-2, -1))
+
+        relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(
+            self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1)  # Wh*Ww,Wh*Ww,nH
+        relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()  # nH, Wh*Ww, Wh*Ww
+        attn = attn + relative_position_bias.unsqueeze(0)
+
+        if mask is not None:
+            nW = mask.shape[0]
+            attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)
+            attn = attn.view(-1, self.num_heads, N, N)
+            attn = self.softmax(attn)
+        else:
+            attn = self.softmax(attn)
+
+        attn = self.attn_drop(attn)
+
+        x = (attn @ v).transpose(1, 2).reshape(B_, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+
+class SwinTransformerBlock(nn.Module):
+    """ Swin Transformer Block.
+
+    Args:
+        dim (int): Number of input channels.
+        num_heads (int): Number of attention heads.
+        window_size (int): Window size.
+        shift_size (int): Shift size for SW-MSA.
+        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
+        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
+        drop (float, optional): Dropout rate. Default: 0.0
+        attn_drop (float, optional): Attention dropout rate. Default: 0.0
+        drop_path (float, optional): Stochastic depth rate. Default: 0.0
+        act_layer (nn.Module, optional): Activation layer. Default: nn.GELU
+        norm_layer (nn.Module, optional): Normalization layer.  Default: nn.LayerNorm
+    """
+
+    def __init__(self, dim, num_heads, window_size=7, shift_size=0,
+                 mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0., drop_path=0.,
+                 act_layer=nn.GELU, norm_layer=nn.LayerNorm):
+        super().__init__()
+        self.dim = dim
+        self.num_heads = num_heads
+        self.window_size = window_size
+        self.shift_size = shift_size
+        self.mlp_ratio = mlp_ratio
+        assert 0 <= self.shift_size < self.window_size, "shift_size must in 0-window_size"
+
+        self.norm1 = norm_layer(dim)
+        self.attn = WindowAttention(
+            dim, window_size=to_2tuple(self.window_size), num_heads=num_heads,
+            qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)
+
+        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
+        self.norm2 = norm_layer(dim)
+        mlp_hidden_dim = int(dim * mlp_ratio)
+        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
+
+        self.H = None
+        self.W = None
+
+    def forward(self, x, mask_matrix):
+        """ Forward function.
+
+        Args:
+            x: Input feature, tensor size (B, H*W, C).
+            H, W: Spatial resolution of the input feature.
+            mask_matrix: Attention mask for cyclic shift.
+        """
+        B, L, C = x.shape
+        H, W = self.H, self.W
+        assert L == H * W, "input feature has wrong size"
+
+        shortcut = x
+        x = self.norm1(x)
+        x = x.view(B, H, W, C)
+
+        # pad feature maps to multiples of window size
+        pad_l = pad_t = 0
+        pad_r = (self.window_size - W % self.window_size) % self.window_size
+        pad_b = (self.window_size - H % self.window_size) % self.window_size
+        x = F.pad(x, (0, 0, pad_l, pad_r, pad_t, pad_b))
+        _, Hp, Wp, _ = x.shape
+
+        # cyclic shift
+        if self.shift_size > 0:
+            shifted_x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))
+            attn_mask = mask_matrix
+        else:
+            shifted_x = x
+            attn_mask = None
+
+        # partition windows
+        x_windows = window_partition(shifted_x, self.window_size)  # nW*B, window_size, window_size, C
+        x_windows = x_windows.view(-1, self.window_size * self.window_size, C)  # nW*B, window_size*window_size, C
+
+        # W-MSA/SW-MSA
+        attn_windows = self.attn(x_windows, mask=attn_mask)  # nW*B, window_size*window_size, C
+
+        # merge windows
+        attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C)
+        shifted_x = window_reverse(attn_windows, self.window_size, Hp, Wp)  # B H' W' C
+
+        # reverse cyclic shift
+        if self.shift_size > 0:
+            x = torch.roll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2))
+        else:
+            x = shifted_x
+
+        if pad_r > 0 or pad_b > 0:
+            x = x[:, :H, :W, :].contiguous()
+
+        x = x.view(B, H * W, C)
+
+        # FFN
+        x = shortcut + self.drop_path(x)
+        x = x + self.drop_path(self.mlp(self.norm2(x)))
+
+        return x
+
+
+class PatchMerging(nn.Module):
+    """ Patch Merging Layer
+
+    Args:
+        dim (int): Number of input channels.
+        norm_layer (nn.Module, optional): Normalization layer.  Default: nn.LayerNorm
+    """
+    def __init__(self, dim, norm_layer=nn.LayerNorm):
+        super().__init__()
+        self.dim = dim
+        self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False)
+        self.norm = norm_layer(4 * dim)
+
+    def forward(self, x, H, W):
+        """ Forward function.
+
+        Args:
+            x: Input feature, tensor size (B, H*W, C).
+            H, W: Spatial resolution of the input feature.
+        """
+        B, L, C = x.shape
+        assert L == H * W, "input feature has wrong size"
+
+        x = x.view(B, H, W, C)
+
+        # padding
+        pad_input = (H % 2 == 1) or (W % 2 == 1)
+        if pad_input:
+            x = F.pad(x, (0, 0, 0, W % 2, 0, H % 2))
+
+        x0 = x[:, 0::2, 0::2, :]  # B H/2 W/2 C
+        x1 = x[:, 1::2, 0::2, :]  # B H/2 W/2 C
+        x2 = x[:, 0::2, 1::2, :]  # B H/2 W/2 C
+        x3 = x[:, 1::2, 1::2, :]  # B H/2 W/2 C
+        x = torch.cat([x0, x1, x2, x3], -1)  # B H/2 W/2 4*C
+        x = x.view(B, -1, 4 * C)  # B H/2*W/2 4*C
+
+        x = self.norm(x)
+        x = self.reduction(x)
+
+        return x
+
+
+class BasicLayer(nn.Module):
+    """ A basic Swin Transformer layer for one stage.
+
+    Args:
+        dim (int): Number of feature channels
+        depth (int): Depths of this stage.
+        num_heads (int): Number of attention head.
+        window_size (int): Local window size. Default: 7.
+        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4.
+        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
+        drop (float, optional): Dropout rate. Default: 0.0
+        attn_drop (float, optional): Attention dropout rate. Default: 0.0
+        drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0
+        norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
+        downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None
+        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
+    """
+
+    def __init__(self,
+                 dim,
+                 depth,
+                 num_heads,
+                 window_size=7,
+                 mlp_ratio=4.,
+                 qkv_bias=True,
+                 qk_scale=None,
+                 drop=0.,
+                 attn_drop=0.,
+                 drop_path=0.,
+                 norm_layer=nn.LayerNorm,
+                 downsample=None,
+                 use_checkpoint=False):
+        super().__init__()
+        self.window_size = window_size
+        self.shift_size = window_size // 2
+        self.depth = depth
+        self.use_checkpoint = use_checkpoint
+
+        # build blocks
+        self.blocks = nn.ModuleList([
+            SwinTransformerBlock(
+                dim=dim,
+                num_heads=num_heads,
+                window_size=window_size,
+                shift_size=0 if (i % 2 == 0) else window_size // 2,
+                mlp_ratio=mlp_ratio,
+                qkv_bias=qkv_bias,
+                qk_scale=qk_scale,
+                drop=drop,
+                attn_drop=attn_drop,
+                drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,
+                norm_layer=norm_layer)
+            for i in range(depth)])
+
+        # patch merging layer
+        if downsample is not None:
+            self.downsample = downsample(dim=dim, norm_layer=norm_layer)
+        else:
+            self.downsample = None
+
+    def forward(self, x, H, W):
+        """ Forward function.
+
+        Args:
+            x: Input feature, tensor size (B, H*W, C).
+            H, W: Spatial resolution of the input feature.
+        """
+
+        # calculate attention mask for SW-MSA
+        Hp = int(np.ceil(H / self.window_size)) * self.window_size
+        Wp = int(np.ceil(W / self.window_size)) * self.window_size
+        img_mask = torch.zeros((1, Hp, Wp, 1), device=x.device)  # 1 Hp Wp 1
+        h_slices = (slice(0, -self.window_size),
+                    slice(-self.window_size, -self.shift_size),
+                    slice(-self.shift_size, None))
+        w_slices = (slice(0, -self.window_size),
+                    slice(-self.window_size, -self.shift_size),
+                    slice(-self.shift_size, None))
+        cnt = 0
+        for h in h_slices:
+            for w in w_slices:
+                img_mask[:, h, w, :] = cnt
+                cnt += 1
+
+        mask_windows = window_partition(img_mask, self.window_size)  # nW, window_size, window_size, 1
+        mask_windows = mask_windows.view(-1, self.window_size * self.window_size)
+        attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
+        attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))
+
+        for blk in self.blocks:
+            blk.H, blk.W = H, W
+            if self.use_checkpoint:
+                x = checkpoint.checkpoint(blk, x, attn_mask)
+            else:
+                x = blk(x, attn_mask)
+        if self.downsample is not None:
+            x_down = self.downsample(x, H, W)
+            Wh, Ww = (H + 1) // 2, (W + 1) // 2
+            return x, H, W, x_down, Wh, Ww
+        else:
+            return x, H, W, x, H, W
+
+
+class PatchEmbed(nn.Module):
+    """ Image to Patch Embedding
+
+    Args:
+        patch_size (int): Patch token size. Default: 4.
+        in_chans (int): Number of input image channels. Default: 3.
+        embed_dim (int): Number of linear projection output channels. Default: 96.
+        norm_layer (nn.Module, optional): Normalization layer. Default: None
+    """
+
+    def __init__(self, patch_size=4, in_chans=3, embed_dim=96, norm_layer=None):
+        super().__init__()
+        patch_size = to_2tuple(patch_size)
+        self.patch_size = patch_size
+
+        self.in_chans = in_chans
+        self.embed_dim = embed_dim
+
+        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
+        if norm_layer is not None:
+            self.norm = norm_layer(embed_dim)
+        else:
+            self.norm = None
+
+    def forward(self, x):
+        """Forward function."""
+        # padding
+        _, _, H, W = x.size()
+        if W % self.patch_size[1] != 0:
+            x = F.pad(x, (0, self.patch_size[1] - W % self.patch_size[1]))
+        if H % self.patch_size[0] != 0:
+            x = F.pad(x, (0, 0, 0, self.patch_size[0] - H % self.patch_size[0]))
+
+        x = self.proj(x)  # B C Wh Ww
+        if self.norm is not None:
+            Wh, Ww = x.size(2), x.size(3)
+            x = x.flatten(2).transpose(1, 2)
+            x = self.norm(x)
+            x = x.transpose(1, 2).view(-1, self.embed_dim, Wh, Ww)
+
+        return x
+
+
+class SwinTransformer(nn.Module):
+    """ Swin Transformer backbone.
+        A PyTorch impl of : `Swin Transformer: Hierarchical Vision Transformer using Shifted Windows`  -
+          https://arxiv.org/pdf/2103.14030
+
+    Args:
+        pretrain_img_size (int): Input image size for training the pretrained model,
+            used in absolute postion embedding. Default 224.
+        patch_size (int | tuple(int)): Patch size. Default: 4.
+        in_chans (int): Number of input image channels. Default: 3.
+        embed_dim (int): Number of linear projection output channels. Default: 96.
+        depths (tuple[int]): Depths of each Swin Transformer stage.
+        num_heads (tuple[int]): Number of attention head of each stage.
+        window_size (int): Window size. Default: 7.
+        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4.
+        qkv_bias (bool): If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float): Override default qk scale of head_dim ** -0.5 if set.
+        drop_rate (float): Dropout rate.
+        attn_drop_rate (float): Attention dropout rate. Default: 0.
+        drop_path_rate (float): Stochastic depth rate. Default: 0.2.
+        norm_layer (nn.Module): Normalization layer. Default: nn.LayerNorm.
+        ape (bool): If True, add absolute position embedding to the patch embedding. Default: False.
+        patch_norm (bool): If True, add normalization after patch embedding. Default: True.
+        out_indices (Sequence[int]): Output from which stages.
+        frozen_stages (int): Stages to be frozen (stop grad and set eval mode).
+            -1 means not freezing any parameters.
+        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
+    """
+
+    def __init__(self,
+                 pretrain_img_size=224,
+                 patch_size=4,
+                 in_chans=3,
+                 embed_dim=96,
+                 depths=[2, 2, 6, 2],
+                 num_heads=[3, 6, 12, 24],
+                 window_size=7,
+                 mlp_ratio=4.,
+                 qkv_bias=True,
+                 qk_scale=None,
+                 drop_rate=0.,
+                 attn_drop_rate=0.,
+                 drop_path_rate=0.2,
+                 norm_layer=nn.LayerNorm,
+                 ape=False,
+                 patch_norm=True,
+                 out_indices=(0, 1, 2, 3),
+                 frozen_stages=-1,
+                 use_checkpoint=False):
+        super().__init__()
+
+        self.pretrain_img_size = pretrain_img_size
+        self.num_layers = len(depths)
+        self.embed_dim = embed_dim
+        self.ape = ape
+        self.patch_norm = patch_norm
+        self.out_indices = out_indices
+        self.frozen_stages = frozen_stages
+
+        # split image into non-overlapping patches
+        self.patch_embed = PatchEmbed(
+            patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim,
+            norm_layer=norm_layer if self.patch_norm else None)
+
+        # absolute position embedding
+        if self.ape:
+            pretrain_img_size = to_2tuple(pretrain_img_size)
+            patch_size = to_2tuple(patch_size)
+            patches_resolution = [pretrain_img_size[0] // patch_size[0], pretrain_img_size[1] // patch_size[1]]
+
+            self.absolute_pos_embed = nn.Parameter(torch.zeros(1, embed_dim, patches_resolution[0], patches_resolution[1]))
+            trunc_normal_(self.absolute_pos_embed, std=.02)
+
+        self.pos_drop = nn.Dropout(p=drop_rate)
+
+        # stochastic depth
+        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))]  # stochastic depth decay rule
+
+        # build layers
+        self.layers = nn.ModuleList()
+        for i_layer in range(self.num_layers):
+            layer = BasicLayer(
+                dim=int(embed_dim * 2 ** i_layer),
+                depth=depths[i_layer],
+                num_heads=num_heads[i_layer],
+                window_size=window_size,
+                mlp_ratio=mlp_ratio,
+                qkv_bias=qkv_bias,
+                qk_scale=qk_scale,
+                drop=drop_rate,
+                attn_drop=attn_drop_rate,
+                drop_path=dpr[sum(depths[:i_layer]):sum(depths[:i_layer + 1])],
+                norm_layer=norm_layer,
+                downsample=PatchMerging if (i_layer < self.num_layers - 1) else None,
+                use_checkpoint=use_checkpoint)
+            self.layers.append(layer)
+
+        num_features = [int(embed_dim * 2 ** i) for i in range(self.num_layers)]
+        self.num_features = num_features
+
+        # add a norm layer for each output
+        for i_layer in out_indices:
+            layer = norm_layer(num_features[i_layer])
+            layer_name = f'norm{i_layer}'
+            self.add_module(layer_name, layer)
+
+        self._freeze_stages()
+
+    def _freeze_stages(self):
+        if self.frozen_stages >= 0:
+            self.patch_embed.eval()
+            for param in self.patch_embed.parameters():
+                param.requires_grad = False
+
+        if self.frozen_stages >= 1 and self.ape:
+            self.absolute_pos_embed.requires_grad = False
+
+        if self.frozen_stages >= 2:
+            self.pos_drop.eval()
+            for i in range(0, self.frozen_stages - 1):
+                m = self.layers[i]
+                m.eval()
+                for param in m.parameters():
+                    param.requires_grad = False
+
+    def init_weights(self, pretrained=None):
+        """Initialize the weights in backbone.
+
+        Args:
+            pretrained (str, optional): Path to pre-trained weights.
+                Defaults to None.
+        """
+
+        def _init_weights(m):
+            if isinstance(m, nn.Linear):
+                trunc_normal_(m.weight, std=.02)
+                if isinstance(m, nn.Linear) and m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.LayerNorm):
+                nn.init.constant_(m.bias, 0)
+                nn.init.constant_(m.weight, 1.0)
+
+        if isinstance(pretrained, str):
+            self.apply(_init_weights)
+            # logger = get_root_logger()
+            load_checkpoint(self, pretrained, strict=False)
+        elif pretrained is None:
+            self.apply(_init_weights)
+        else:
+            raise TypeError('pretrained must be a str or None')
+
+    def forward(self, x):
+        """Forward function."""
+        x = self.patch_embed(x)
+
+        Wh, Ww = x.size(2), x.size(3)
+        if self.ape:
+            # interpolate the position embedding to the corresponding size
+            absolute_pos_embed = F.interpolate(self.absolute_pos_embed, size=(Wh, Ww), mode='bicubic')
+            x = (x + absolute_pos_embed).flatten(2).transpose(1, 2)  # B Wh*Ww C
+        else:
+            x = x.flatten(2).transpose(1, 2)
+        x = self.pos_drop(x)
+
+        outs = []
+        for i in range(self.num_layers):
+            layer = self.layers[i]
+            x_out, H, W, x, Wh, Ww = layer(x, Wh, Ww)
+
+            if i in self.out_indices:
+                norm_layer = getattr(self, f'norm{i}')
+                x_out = norm_layer(x_out)
+
+                out = x_out.view(-1, H, W, self.num_features[i]).permute(0, 3, 1, 2).contiguous()
+                outs.append(out)
+
+        return tuple(outs)
+
+    def train(self, mode=True):
+        """Convert the model into training mode while keep layers freezed."""
+        super(SwinTransformer, self).train(mode)
+        self._freeze_stages()

external/WildCamera/WildCamera/newcrfs/uper_crf_head.py

@@ -0,0 +1,350 @@
+import torch
+import torch.nn as nn
+
+from mmcv.cnn import ConvModule
+from .newcrf_utils import resize
+
+
+class PPM(nn.ModuleList):
+    """Pooling Pyramid Module used in PSPNet.
+
+    Args:
+        pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid
+            Module.
+        in_channels (int): Input channels.
+        channels (int): Channels after modules, before conv_seg.
+        conv_cfg (dict|None): Config of conv layers.
+        norm_cfg (dict|None): Config of norm layers.
+        act_cfg (dict): Config of activation layers.
+        align_corners (bool): align_corners argument of F.interpolate.
+    """
+
+    def __init__(self, pool_scales, in_channels, channels, conv_cfg, norm_cfg,
+                 act_cfg, align_corners):
+        super(PPM, self).__init__()
+        self.pool_scales = pool_scales
+        self.align_corners = align_corners
+        self.in_channels = in_channels
+        self.channels = channels
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        for pool_scale in pool_scales:
+            # == if batch size = 1, BN is not supported, change to GN
+            if pool_scale == 1: norm_cfg = dict(type='GN', requires_grad=True, num_groups=256)
+            self.append(
+                nn.Sequential(
+                    nn.AdaptiveAvgPool2d(pool_scale),
+                    ConvModule(
+                        self.in_channels,
+                        self.channels,
+                        1,
+                        conv_cfg=self.conv_cfg,
+                        norm_cfg=norm_cfg,
+                        act_cfg=self.act_cfg)))
+
+    def forward(self, x):
+        """Forward function."""
+        ppm_outs = []
+        for ppm in self:
+            ppm_out = ppm(x)
+            upsampled_ppm_out = resize(
+                ppm_out,
+                size=x.size()[2:],
+                mode='bilinear',
+                align_corners=self.align_corners)
+            ppm_outs.append(upsampled_ppm_out)
+        return ppm_outs
+
+
+class BaseDecodeHead(nn.Module):
+    """Base class for BaseDecodeHead.
+
+    Args:
+        in_channels (int|Sequence[int]): Input channels.
+        channels (int): Channels after modules, before conv_seg.
+        num_classes (int): Number of classes.
+        dropout_ratio (float): Ratio of dropout layer. Default: 0.1.
+        conv_cfg (dict|None): Config of conv layers. Default: None.
+        norm_cfg (dict|None): Config of norm layers. Default: None.
+        act_cfg (dict): Config of activation layers.
+            Default: dict(type='ReLU')
+        in_index (int|Sequence[int]): Input feature index. Default: -1
+        input_transform (str|None): Transformation type of input features.
+            Options: 'resize_concat', 'multiple_select', None.
+            'resize_concat': Multiple feature maps will be resize to the
+                same size as first one and than concat together.
+                Usually used in FCN head of HRNet.
+            'multiple_select': Multiple feature maps will be bundle into
+                a list and passed into decode head.
+            None: Only one select feature map is allowed.
+            Default: None.
+        loss_decode (dict): Config of decode loss.
+            Default: dict(type='CrossEntropyLoss').
+        ignore_index (int | None): The label index to be ignored. When using
+            masked BCE loss, ignore_index should be set to None. Default: 255
+        sampler (dict|None): The config of segmentation map sampler.
+            Default: None.
+        align_corners (bool): align_corners argument of F.interpolate.
+            Default: False.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 channels,
+                 *,
+                 num_classes,
+                 dropout_ratio=0.1,
+                 conv_cfg=None,
+                 norm_cfg=None,
+                 act_cfg=dict(type='ReLU'),
+                 in_index=-1,
+                 input_transform=None,
+                 loss_decode=None,
+                 ignore_index=255,
+                 sampler=None,
+                 align_corners=False):
+        super(BaseDecodeHead, self).__init__()
+        self._init_inputs(in_channels, in_index, input_transform)
+        self.channels = channels
+        self.num_classes = num_classes
+        self.dropout_ratio = dropout_ratio
+        self.conv_cfg = conv_cfg
+        self.norm_cfg = norm_cfg
+        self.act_cfg = act_cfg
+        self.in_index = in_index
+        self.ignore_index = ignore_index
+        self.align_corners = align_corners
+        if dropout_ratio > 0:
+            self.dropout = nn.Dropout2d(dropout_ratio)
+        else:
+            self.dropout = None
+        self.fp16_enabled = False
+
+    def extra_repr(self):
+        """Extra repr."""
+        s = f'input_transform={self.input_transform}, ' \
+            f'ignore_index={self.ignore_index}, ' \
+            f'align_corners={self.align_corners}'
+        return s
+
+    def _init_inputs(self, in_channels, in_index, input_transform):
+        """Check and initialize input transforms.
+
+        The in_channels, in_index and input_transform must match.
+        Specifically, when input_transform is None, only single feature map
+        will be selected. So in_channels and in_index must be of type int.
+        When input_transform
+
+        Args:
+            in_channels (int|Sequence[int]): Input channels.
+            in_index (int|Sequence[int]): Input feature index.
+            input_transform (str|None): Transformation type of input features.
+                Options: 'resize_concat', 'multiple_select', None.
+                'resize_concat': Multiple feature maps will be resize to the
+                    same size as first one and than concat together.
+                    Usually used in FCN head of HRNet.
+                'multiple_select': Multiple feature maps will be bundle into
+                    a list and passed into decode head.
+                None: Only one select feature map is allowed.
+        """
+
+        if input_transform is not None:
+            assert input_transform in ['resize_concat', 'multiple_select']
+        self.input_transform = input_transform
+        self.in_index = in_index
+        if input_transform is not None:
+            assert isinstance(in_channels, (list, tuple))
+            assert isinstance(in_index, (list, tuple))
+            assert len(in_channels) == len(in_index)
+            if input_transform == 'resize_concat':
+                self.in_channels = sum(in_channels)
+            else:
+                self.in_channels = in_channels
+        else:
+            assert isinstance(in_channels, int)
+            assert isinstance(in_index, int)
+            self.in_channels = in_channels
+
+    def init_weights(self):
+        """Initialize weights of classification layer."""
+        # normal_init(self.conv_seg, mean=0, std=0.01)
+        # normal_init(self.conv1, mean=0, std=0.01)
+
+    def _transform_inputs(self, inputs):
+        """Transform inputs for decoder.
+
+        Args:
+            inputs (list[Tensor]): List of multi-level img features.
+
+        Returns:
+            Tensor: The transformed inputs
+        """
+
+        if self.input_transform == 'resize_concat':
+            inputs = [inputs[i] for i in self.in_index]
+            upsampled_inputs = [
+                resize(
+                    input=x,
+                    size=inputs[0].shape[2:],
+                    mode='bilinear',
+                    align_corners=self.align_corners) for x in inputs
+            ]
+            inputs = torch.cat(upsampled_inputs, dim=1)
+        elif self.input_transform == 'multiple_select':
+            inputs = [inputs[i] for i in self.in_index]
+        else:
+            inputs = inputs[self.in_index]
+
+        return inputs
+
+    def forward(self, inputs):
+        """Placeholder of forward function."""
+        pass
+
+    def forward_train(self, inputs, img_metas, gt_semantic_seg, train_cfg):
+        """Forward function for training.
+        Args:
+            inputs (list[Tensor]): List of multi-level img features.
+            img_metas (list[dict]): List of image info dict where each dict
+                has: 'img_shape', 'scale_factor', 'flip', and may also contain
+                'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
+                For details on the values of these keys see
+                `mmseg/datasets/pipelines/formatting.py:Collect`.
+            gt_semantic_seg (Tensor): Semantic segmentation masks
+                used if the architecture supports semantic segmentation task.
+            train_cfg (dict): The training config.
+
+        Returns:
+            dict[str, Tensor]: a dictionary of loss components
+        """
+        seg_logits = self.forward(inputs)
+        losses = self.losses(seg_logits, gt_semantic_seg)
+        return losses
+
+    def forward_test(self, inputs, img_metas, test_cfg):
+        """Forward function for testing.
+
+        Args:
+            inputs (list[Tensor]): List of multi-level img features.
+            img_metas (list[dict]): List of image info dict where each dict
+                has: 'img_shape', 'scale_factor', 'flip', and may also contain
+                'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
+                For details on the values of these keys see
+                `mmseg/datasets/pipelines/formatting.py:Collect`.
+            test_cfg (dict): The testing config.
+
+        Returns:
+            Tensor: Output segmentation map.
+        """
+        return self.forward(inputs)
+
+
+class UPerHead(BaseDecodeHead):
+    def __init__(self, pool_scales=(1, 2, 3, 6), **kwargs):
+        super(UPerHead, self).__init__(
+            input_transform='multiple_select', **kwargs)
+        # FPN Module
+        self.lateral_convs = nn.ModuleList()
+        self.fpn_convs = nn.ModuleList()
+        for in_channels in self.in_channels:  # skip the top layer
+            l_conv = ConvModule(
+                in_channels,
+                self.channels,
+                1,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg,
+                inplace=True)
+            fpn_conv = ConvModule(
+                self.channels,
+                self.channels,
+                3,
+                padding=1,
+                conv_cfg=self.conv_cfg,
+                norm_cfg=self.norm_cfg,
+                act_cfg=self.act_cfg,
+                inplace=True)
+            self.lateral_convs.append(l_conv)
+            self.fpn_convs.append(fpn_conv)
+
+    def forward(self, inputs):
+        """Forward function."""
+
+        inputs = self._transform_inputs(inputs)
+
+        # build laterals
+        laterals = [
+            lateral_conv(inputs[i])
+            for i, lateral_conv in enumerate(self.lateral_convs)
+        ]
+
+        # laterals.append(self.psp_forward(inputs))
+
+        # build top-down path
+        used_backbone_levels = len(laterals)
+        for i in range(used_backbone_levels - 1, 0, -1):
+            prev_shape = laterals[i - 1].shape[2:]
+            laterals[i - 1] += resize(
+                laterals[i],
+                size=prev_shape,
+                mode='bilinear',
+                align_corners=self.align_corners)
+
+        # build outputs
+        fpn_outs = [
+            self.fpn_convs[i](laterals[i])
+            for i in range(used_backbone_levels - 1)
+        ]
+        # append psp feature
+        fpn_outs.append(laterals[-1])
+
+        return fpn_outs[0]
+
+class PSP(BaseDecodeHead):
+    """Unified Perceptual Parsing for Scene Understanding.
+
+    This head is the implementation of `UPerNet
+    <https://arxiv.org/abs/1807.10221>`_.
+
+    Args:
+        pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid
+            Module applied on the last feature. Default: (1, 2, 3, 6).
+    """
+
+    def __init__(self, pool_scales=(1, 2, 3, 6), **kwargs):
+        super(PSP, self).__init__(
+            input_transform='multiple_select', **kwargs)
+        # PSP Module
+        self.psp_modules = PPM(
+            pool_scales,
+            self.in_channels[-1],
+            self.channels,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg,
+            align_corners=self.align_corners)
+        self.bottleneck = ConvModule(
+            self.in_channels[-1] + len(pool_scales) * self.channels,
+            self.channels,
+            3,
+            padding=1,
+            conv_cfg=self.conv_cfg,
+            norm_cfg=self.norm_cfg,
+            act_cfg=self.act_cfg)
+
+    def psp_forward(self, inputs):
+        """Forward function of PSP module."""
+        x = inputs[-1]
+        psp_outs = [x]
+        psp_outs.extend(self.psp_modules(x))
+        psp_outs = torch.cat(psp_outs, dim=1)
+        output = self.bottleneck(psp_outs)
+
+        return output
+
+    def forward(self, inputs):
+        """Forward function."""
+        inputs = self._transform_inputs(inputs)
+        
+        return self.psp_forward(inputs)

external/WildCamera/WildCamera/train/train_calibrator.py

@@ -0,0 +1,297 @@
+from __future__ import print_function, division
+import os, sys, inspect, time, copy, warnings
+project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))))
+sys.path.insert(0, project_root)
+warnings.filterwarnings('ignore')
+
+import torch
+import torch.backends.cudnn as cudnn
+import torch.distributed as dist
+import torch.multiprocessing as mp
+from torch.utils.tensorboard import SummaryWriter
+from torch.utils.data import ConcatDataset
+from torchvision import transforms
+
+import argparse
+import numpy as np
+from loguru import logger
+from einops import rearrange
+from pprint import pprint
+
+from WildCamera.newcrfs.newcrf_incidencefield import NEWCRFIF
+from WildCamera.datasets.IncdDataset import IncdDataset
+from tools.tools import to_cuda, intrinsic2incidence, resample_rgb, DistributedSamplerNoEvenlyDivisible, IncidenceLoss
+from tools.visualization import tensor2disp, tensor2rgb
+
+parser = argparse.ArgumentParser(description='NeWCRFs PyTorch implementation.', fromfile_prefix_chars='@')
+
+parser.add_argument('--experiment_name',           type=str,   help='experiment name', default='multi-modality newcrfs')
+parser.add_argument('--experiment_set',            type=str,   choices=['gsv', 'in_the_wild'], required=True)
+parser.add_argument('--saving_location',           type=str,   help='saving location', default=None)
+parser.add_argument('--encoder',                   type=str,   help='type of encoder, base07, large07', default='large07')
+parser.add_argument('--pretrain',                  type=str,   help='path of pretrained encoder', default='model_zoo/swin_transformer/swin_large_patch4_window7_224_22k.pth')
+parser.add_argument('--load_ckpt',                 type=str,   help='path of ckpt', default=None)
+parser.add_argument('--evaluation_only',           action="store_true")
+parser.add_argument('--l1_th',                     type=int,  help='RANSAC threshold', default=0.02)
+
+# Dataset
+parser.add_argument('--data_path',                 type=str,   help='path to the data', default='data/MonoCalib')
+parser.add_argument('--input_height',              type=int,   help='input height', default=480)
+parser.add_argument('--input_width',               type=int,   help='input width',  default=640)
+
+# Training
+parser.add_argument('--batch_size',                type=int,   help='batch size', default=16)
+parser.add_argument('--loss',                      type=str,   default='cosine', help='You can also choees l1 loss')
+parser.add_argument('--steps_per_epoch',           type=int,   help='frequency for evaluation', default=1000)
+parser.add_argument('--termination_epoch',         type=int,   help='epoch to stop training', default=25)
+
+# Training Misc
+parser.add_argument('--weight_decay',              type=float, help='weight decay factor for optimization', default=1e-2)
+parser.add_argument('--adam_eps',                  type=float, help='epsilon in Adam optimizer', default=1e-6)
+parser.add_argument('--train_workers',             type=int,   help='dataloader workers', default=32)
+parser.add_argument('--eval_workers',              type=int,   help='dataloader workers', default=2)
+parser.add_argument('--learning_rate',             type=float, help='initial learning rate', default=1e-5)
+parser.add_argument('--end_learning_rate',         type=float, help='end learning rate', default=-1)
+
+# Augmentation
+parser.add_argument('--dataset_favour_long',       type=float, default=0.1, help='whether in training will see more samples from large dataset')
+parser.add_argument('--augscale',                  type=float, default=2.0, help='The scale of Augmentation')
+parser.add_argument('--no_change_prob',            type=float, default=0.1, help='The probability of seeing original image')
+parser.add_argument('--coloraugmentation',         action="store_true")
+parser.add_argument('--coloraugmentation_scale',   type=float, default=0.0)
+
+# Multi-gpu training
+parser.add_argument('--gpu',                       type=int,  help='GPU id to use.', default=None)
+parser.add_argument('--dist_url',                  type=str,  help='url used to set up distributed training', default='tcp://127.0.0.1:1235')
+parser.add_argument('--dist_backend',              type=str,  help='distributed backend', default='nccl')
+
+def main_worker(gpu, ngpus_per_node, args):
+    args.gpu = gpu
+    group = dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url, world_size=args.world_size, rank=args.gpu)
+
+    # NeWCRFs model
+    model = NEWCRFIF(version=args.encoder, pretrained=args.pretrain)
+    model.train()
+
+    if args.load_ckpt is not None:
+        model.load_state_dict(torch.load(args.load_ckpt, map_location="cpu"), strict=True)
+        model.eval()
+        logger.info("Load Model from %s" % args.load_ckpt)
+
+    if args.distributed:
+        if args.gpu is not None:
+            torch.cuda.set_device(args.gpu)
+            model.cuda(args.gpu)
+            args.batch_size = int(args.batch_size / ngpus_per_node)
+            args.train_workers = int(args.train_workers / ngpus_per_node)
+            model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu], find_unused_parameters=False)
+        else:
+            model.cuda()
+            model = torch.nn.parallel.DistributedDataParallel(model, find_unused_parameters=False)
+    else:
+        model = torch.nn.DataParallel(model)
+        model.cuda()
+
+    if args.distributed:
+        print("== Model Initialized on GPU: {}".format(args.gpu))
+    else:
+        print("== Model Initialized")
+
+    # Training parameters
+    optimizer = torch.optim.Adam([{'params': model.module.parameters()}], lr=args.learning_rate)
+
+    cudnn.benchmark = True
+
+    incidence_criterion = IncidenceLoss(loss=args.loss)
+
+    end_learning_rate = args.end_learning_rate if args.end_learning_rate != -1 else 0.1 * args.learning_rate
+
+    steps_per_epoch = args.steps_per_epoch
+    num_total_steps = 250000
+    epoch = int(num_total_steps / steps_per_epoch)
+
+    inv_normalize = transforms.Normalize(
+        mean=[-0.485 / 0.229, -0.456 / 0.224, -0.406 / 0.225],
+        std=[1 / 0.229, 1 / 0.224, 1 / 0.225]
+    )
+
+    if args.gpu == 0:
+        checkpoint_dir = os.path.join(args.saving_location, 'model_zoo', args.experiment_name)
+        writer = SummaryWriter(checkpoint_dir, flush_secs=30)
+        logger.add(os.path.join(checkpoint_dir, "{}.log".format(args.experiment_name)))
+    else:
+        writer = None
+        logger.remove()
+        logger.add(sys.stderr, level="ERROR")
+
+    if args.experiment_set == 'gsv':
+        from WildCamera.evaluation.evaluate_fov import EvaluateFov
+        evaluator = EvaluateFov()
+    elif args.experiment_set == 'in_the_wild':
+        from WildCamera.evaluation.evaluate_intrinsic import EvaluateIntrinsic
+        evaluator = EvaluateIntrinsic()
+    else:
+        raise NotImplementedError()
+
+    if args.evaluation_only:
+        evaluator.evaluate(
+            model,
+            args,
+            steps=0,
+            writer=writer,
+            group=group,
+            wtassumption=False,
+        )
+        evaluator.evaluate(
+            model,
+            args,
+            steps=0,
+            writer=writer,
+            group=group,
+            wtassumption=True,
+        )
+        return
+
+    for n_0 in range(epoch):
+
+        if n_0 > args.termination_epoch:
+            break
+
+        incdataset = IncdDataset(
+            data_root=args.data_path,
+            datasets_included=args.datasets_train,
+            ht=args.input_height,
+            wt=args.input_width,
+            augmentation=True,
+            split='train',
+            shuffleseed=int(n_0 + 1),
+            dataset_favour_long=args.dataset_favour_long,
+            augscale=args.augscale,
+            no_change_prob=args.no_change_prob,
+            coloraugmentation=args.coloraugmentation,
+            coloraugmentation_scale=args.coloraugmentation_scale
+        )
+        sampler = DistributedSamplerNoEvenlyDivisible(incdataset, shuffle=True)
+        dataloader = torch.utils.data.DataLoader(
+            incdataset,
+            sampler=sampler,
+            batch_size=int(args.batch_size),
+            num_workers=int(args.train_workers)
+        )
+        assert len(dataloader) > steps_per_epoch
+        dataloader = iter(dataloader)
+        sampler.set_epoch(n_0)
+        for global_step in range(int(n_0 * steps_per_epoch), int((n_0 + 1) * steps_per_epoch)):
+            sample_batched = next(dataloader)
+            sample_batched = to_cuda(sample_batched)
+
+            rgb, K = sample_batched['rgb'], sample_batched['K']
+
+            model.train()
+            incidence = model(rgb)
+            optimizer.zero_grad()
+
+            # Loss For Normal
+            loss = incidence_criterion(incidence, K)
+            loss.backward()
+
+            for param_group in optimizer.param_groups:
+                current_lr = (args.learning_rate - end_learning_rate) * (1 - global_step / num_total_steps) ** 0.9 + end_learning_rate
+                param_group['lr'] = current_lr
+
+            optimizer.step()
+
+            if np.mod(global_step, 1000) == 0 and args.gpu == 0:
+                b = 1
+                _, _, h, w = rgb.shape
+
+                rgb = inv_normalize(rgb)
+                vls1 = tensor2rgb(rgb, viewind=0)
+
+                device = rgb.device
+                incidence_gt = intrinsic2incidence(K[0:1], b, h, w, device)
+                incidence_gt = rearrange(incidence_gt.squeeze(dim=4), 'b h w d -> b d h w')
+                vls3 = tensor2rgb((incidence + 1) / 2, viewind=0)
+                vls4 = tensor2rgb((incidence_gt + 1) / 2, viewind=0)
+
+                vls = np.concatenate([np.array(vls1), np.array(vls3), np.array(vls4)], axis=0)
+                writer.add_image('visualization', (torch.from_numpy(vls).float() / 255).permute([2, 0, 1]), global_step)
+
+            if writer is not None and args.gpu == 0:
+                writer.add_scalar('loss/loss_incidence', loss.item(), global_step)
+                if np.mod(global_step, 500) == 0:
+                    logger.info('Step %d, Epoch %d, loss %.3f' % (global_step, n_0, loss.item()))
+
+        evaluator.evaluate(
+            model,
+            args,
+            steps=global_step,
+            writer=writer,
+            group=group,
+            wtassumption=False,
+        )
+
+        evaluator.evaluate(
+            model,
+            args,
+            steps=global_step,
+            writer=writer,
+            group=group,
+            wtassumption=True,
+        )
+
+def main():
+    args = parser.parse_args()
+    torch.cuda.empty_cache()
+    args.world_size = torch.cuda.device_count()
+    args.distributed = True
+    args.dist_url = 'tcp://127.0.0.1:' + str(np.random.randint(2000, 3000, 1).item())
+
+    if args.saving_location is None:
+        args.saving_location = project_root
+
+    if args.experiment_set == 'gsv':
+        args.datasets_train = [
+            'GSV'
+        ]
+        args.datasets_eval = [
+            'GSV'
+        ]
+    elif args.experiment_set == 'in_the_wild':
+        args.datasets_train = [
+            'Nuscenes',
+            'KITTI',
+            'Cityscapes',
+            'NYUv2',
+            'ARKitScenes',
+            'MegaDepth',
+            'SUN3D',
+            'MVImgNet',
+            'Objectron'
+        ]
+        args.datasets_eval = [
+            'Nuscenes',
+            'KITTI',
+            'Cityscapes',
+            'NYUv2',
+            'ARKitScenes',
+            'MegaDepth',
+            'SUN3D',
+            'MVImgNet',
+            'Objectron',
+            'Waymo',
+            'BIWIRGBDID',
+            'RGBD',
+            'ScanNet',
+            'MVS',
+            'Scenes11'
+        ]
+
+    else:
+        raise NotImplementedError()
+
+    pprint(vars(args))
+    mp.spawn(main_worker, nprocs=args.world_size, args=(args.world_size, args))
+
+if __name__ == '__main__':
+    main()

external/WildCamera/asset/download_demo_images.sh

@@ -0,0 +1,8 @@
+cd asset
+wget https://huggingface.co/datasets/Shengjie/WildCamera/resolve/main/asset/dollyzoom.tar
+tar -xvf dollyzoom.tar
+rm dollyzoom.tar
+wget https://huggingface.co/datasets/Shengjie/WildCamera/resolve/main/asset/images-from-github-wt-intrinsic.tar
+tar -xvf images-from-github-wt-intrinsic.tar
+rm images-from-github-wt-intrinsic.tar
+cd ..

external/WildCamera/asset/download_wildcamera_checkpoint.sh

@@ -0,0 +1,13 @@
+cd model_zoo
+mkdir Release
+cd Release
+wget https://huggingface.co/datasets/Shengjie/WildCamera/resolve/main/checkpoint/wild_camera_all.pth?download=true
+mv wild_camera_all.pth?download=true wild_camera_all.pth
+wget https://huggingface.co/datasets/Shengjie/WildCamera/resolve/main/checkpoint/wild_camera_gsv.pth?download=true
+mv wild_camera_gsv.pth?download=true wild_camera_gsv.pth
+cd ..
+mkdir swin_transformer
+cd swin_transformer
+wget https://huggingface.co/datasets/Shengjie/WildCamera/resolve/main/checkpoint/swin_large_patch4_window7_224_22k.pth?download=true
+mv swin_large_patch4_window7_224_22k.pth?download=true swin_large_patch4_window7_224_22k.pth
+cd ..

external/WildCamera/demo/demo_dollyzoom.py

@@ -0,0 +1,133 @@
+import os, copy, tqdm, glob, natsort, torch
+import numpy as np
+project_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+
+from WildCamera.newcrfs.newcrf_incidencefield import NEWCRFIF
+from PIL import Image, ImageDraw, ImageFont
+
+def draw_focalbar(rgbaug, fest, minfocal, maxfocal):
+    tmp = copy.deepcopy(rgbaug)
+
+    font_size = 28
+    font = ImageFont.truetype("arial.ttf", size=font_size)
+
+    rgbaug = copy.deepcopy(tmp)
+    w, h = rgbaug.size
+    rgbaug.putalpha(255)
+
+    paddingr = 0.1
+    barsty = h * paddingr
+    baredy = h * (1 - paddingr)
+    barx = w * 0.9
+    horizonbarnum = 7 * 5
+    horizonbarlen = 0.01
+
+    white = Image.new('RGBA', rgbaug.size, (255, 255, 255, 0))
+    draw = ImageDraw.Draw(white)
+    draw.rectangle(
+        [
+            (w * 0.9 - w * horizonbarlen - 15 / 640 * w, h * paddingr - 15 / 480 * h),
+            w * 0.9 + w * horizonbarlen + 35 / 640 * w, h * (1 - paddingr) + 15 / 480 * h
+        ],
+        fill=(255, 255, 255, 128)
+    )
+    rgbaug = Image.alpha_composite(rgbaug, white)
+
+    draw = ImageDraw.Draw(rgbaug)
+    draw.line((barx, barsty, barx, baredy), fill=(0, 0, 0, 255), width=5)
+
+    for i in range(horizonbarnum + 1):
+        r = i / horizonbarnum
+        bary = h * paddingr * r + h * (1 - paddingr) * (1 - r)
+        barstx = w * 0.9 - w * horizonbarlen
+        baredx = w * 0.9 + w * horizonbarlen
+        draw.line((barstx, bary, baredx, bary), fill=(0, 0, 0, 255), width=int(3))
+
+    horizonbarnum = 7
+    horizonbarlen = 0.02
+
+    for i in range(horizonbarnum + 1):
+        r = i / horizonbarnum
+        bary = h * paddingr * r + h * (1 - paddingr) * (1 - r)
+        barstx = w * 0.9 - w * horizonbarlen
+        baredx = w * 0.9 + w * horizonbarlen
+        draw.line((barstx, bary, baredx, bary), fill=(0, 0, 0, 255), width=3)
+
+        textpadding = 30 / 640 * w
+        draw.text((barstx + textpadding, bary - 5 / 480 * h), str(int(maxfocal * r + minfocal * (1 - r))), fill=(0, 0, 0, 255), font=font)
+
+    r = (fest - minfocal) / (maxfocal - minfocal)
+    bary = h * paddingr * r + h * (1 - paddingr) * (1 - r)
+    barstx = w * 0.9 - w * horizonbarlen
+    baredx = w * 0.9 + w * horizonbarlen
+    draw.line((barstx, bary, baredx, bary), fill=(255, 165, 0, 255), width=5)
+    return rgbaug
+
+def smooth_width(fests_precomputed, idx, width=3):
+    # Smooth as an average of Three Frames
+    stidx = idx - int((width - 1) / 2)
+    edidx = idx + int((width - 1) / 2)
+
+    if stidx < 0:
+        stidx = 0
+
+    if edidx >= len(fests_precomputed):
+        edidx = len(fests_precomputed) - 1
+
+    return np.mean(fests_precomputed[stidx:edidx+1])
+
+
+@torch.no_grad()
+def draw_dollyzoom(model):
+    """ In Validation, random sample N Images to mimic a real test set situation  """
+    model.eval()
+
+    dollyzoom_folder = os.path.join(project_dir, 'asset', 'dollyzoom')
+    output_dollyzoom = os.path.join(project_dir, 'output', 'dollyzoom')
+    dollyzoomvideos = [
+        'dz1',
+        'dz2',
+        'dz3'
+    ]
+
+    for dollyzoomvideo in dollyzoomvideos:
+        dollyzoomimg_folder = os.path.join(dollyzoom_folder, dollyzoomvideo)
+        jpgs = glob.glob(os.path.join(dollyzoomimg_folder, '*.jpg'))
+        jpgs = natsort.natsorted(jpgs)
+
+        fests = list()
+        for jpg in tqdm.tqdm(jpgs):
+            intrinsic, _ = model.inference(Image.open(jpg), wtassumption=False)
+            fest = intrinsic[0, 0]
+            fests.append(fest)
+
+        fests = np.array(fests)
+        minfocal = fests.min()
+        maxfocal = fests.max()
+
+        focalpadding = 0.1 * minfocal
+
+        jpgs_focalbar = list()
+        for idx, jpg in enumerate(jpgs):
+            fest = smooth_width(fests, idx, width=3)
+            jpgs_focalbar.append(draw_focalbar(Image.open(jpg), fest, minfocal=int(minfocal - focalpadding), maxfocal=int(maxfocal + focalpadding)))
+
+        output_folder = os.path.join(output_dollyzoom, dollyzoomvideo)
+        os.makedirs(output_folder, exist_ok=True)
+        for idx, jpgimgage in enumerate(jpgs_focalbar):
+            jpg_path = os.path.join(output_folder, '{}.png'.format(str(idx)))
+            jpgimgage.save(jpg_path)
+
+    return
+
+if __name__ == '__main__':
+    # NeWCRFs model
+    model = NEWCRFIF(version='large07', pretrained=None)
+    model.eval()
+    model.cuda()
+
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    ckpt_path = os.path.join(os.path.dirname(script_dir), 'model_zoo/Release', 'wild_camera_all.pth')
+    model.load_state_dict(torch.load(ckpt_path, map_location="cpu"), strict=True)
+
+    draw_dollyzoom(model)

external/WildCamera/demo/demo_inference.py

@@ -0,0 +1,30 @@
+import os, torch
+project_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+
+from PIL import Image
+from WildCamera.newcrfs.newcrf_incidencefield import NEWCRFIF
+
+
+if __name__ == '__main__':
+    # NeWCRFs model
+    model = NEWCRFIF(version='large07', pretrained=None)
+    model.eval()
+    model.cuda()
+
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    ckpt_path = os.path.join(os.path.dirname(script_dir), 'model_zoo/Release', 'wild_camera_all.pth')
+    model.load_state_dict(torch.load(ckpt_path, map_location="cpu"), strict=True)
+
+    images_folder = os.path.join(project_dir, 'asset', 'images-from-github-wt-intrinsic')
+    info_path = os.path.join(images_folder, 'intrinsic_gt.txt')
+    with open(info_path) as file:
+        infos = [line.rstrip() for line in file]
+
+    for idx, info in enumerate(infos):
+        imgname, focalgt, source = info.split(' ')
+
+        images_path = os.path.join(images_folder, imgname)
+        intrinsic, _ = model.inference(Image.open(images_path), wtassumption=False)
+        focal = intrinsic[0, 0].item()
+
+        print("Image Name: %s, Est Focal %.1f, Gt Focal %.1f, Source - %s" % (imgname, focal, float(focalgt), source))

external/WildCamera/demo/demo_restoration.py

@@ -0,0 +1,33 @@
+import os, sys, inspect
+project_root = os.path.dirname(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))))
+sys.path.insert(0, project_root)
+
+import PIL.Image as Image
+import torch
+from WildCamera.newcrfs.newcrf_incidencefield import NEWCRFIF
+
+@torch.no_grad()
+def main():
+    model = NEWCRFIF(version='large07', pretrained=None)
+    model.eval()
+    model.cuda()
+
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    ckpt_path = os.path.join(os.path.dirname(script_dir), 'model_zoo/Release', 'wild_camera_all.pth')
+    model.load_state_dict(torch.load(ckpt_path, map_location="cpu"), strict=True)
+
+    img_folder = os.path.join(project_root, 'asset', 'image_restoration')
+    img_names = [
+        'lenna_distorted_cropright.jpg',
+        'lenna_distorted_cropleft.jpg',
+    ]
+    for img_name in img_names:
+        img_path = os.path.join(img_folder, img_name)
+        img = Image.open(img_path)
+
+        export_root = os.path.join(img_folder, '{}_restored.jpg'.format(img_name.split('.')[0]))
+        intrinsic, _ = model.inference(img, wtassumption=False)
+        model.restore_image(img, intrinsic).save(export_root)
+
+if __name__ == '__main__':
+    main()

external/WildCamera/splits/arkitscenes_test.txt

@@ -0,0 +1,800 @@
+ARKitScenes_test Validation_41069021_401.371_00005806
+ARKitScenes_test Validation_41069021_412.367_00006466
+ARKitScenes_test Validation_41069021_417.365_00006766
+ARKitScenes_test Validation_41069021_421.363_00007006
+ARKitScenes_test Validation_41069021_423.362_00007126
+ARKitScenes_test Validation_41069021_435.357_00007846
+ARKitScenes_test Validation_41069021_450.368_00008747
+ARKitScenes_test Validation_41069025_624.863_00002137
+ARKitScenes_test Validation_41069025_648.870_00003578
+ARKitScenes_test Validation_41069025_731.869_00008560
+ARKitScenes_test Validation_41069042_3044.239_00000085
+ARKitScenes_test Validation_41069042_3045.222_00000144
+ARKitScenes_test Validation_41069042_3063.231_00001225
+ARKitScenes_test Validation_41069042_3070.228_00001645
+ARKitScenes_test Validation_41069042_3073.227_00001825
+ARKitScenes_test Validation_41069043_2820.631_00001297
+ARKitScenes_test Validation_41069043_2826.629_00001657
+ARKitScenes_test Validation_41069043_2830.627_00001897
+ARKitScenes_test Validation_41069043_2892.635_00005619
+ARKitScenes_test Validation_41069046_2929.336_00001117
+ARKitScenes_test Validation_41069046_2988.328_00004658
+ARKitScenes_test Validation_41069046_2989.328_00004718
+ARKitScenes_test Validation_41069046_2997.325_00005198
+ARKitScenes_test Validation_41069046_3024.330_00006819
+ARKitScenes_test Validation_41069051_5085.217_00000211
+ARKitScenes_test Validation_41142278_4003.081_00000097
+ARKitScenes_test Validation_41142278_4070.070_00004118
+ARKitScenes_test Validation_41142280_3837.982_00000937
+ARKitScenes_test Validation_41142281_3964.380_00002798
+ARKitScenes_test Validation_42444946_223634.869_00001657
+ARKitScenes_test Validation_42444946_223654.878_00002858
+ARKitScenes_test Validation_42444946_223693.879_00005199
+ARKitScenes_test Validation_42444950_223834.571_00002198
+ARKitScenes_test Validation_42444950_223862.577_00003879
+ARKitScenes_test Validation_42444966_40376.779_00002863
+ARKitScenes_test Validation_42444966_40381.794_00003164
+ARKitScenes_test Validation_42444966_40382.793_00003224
+ARKitScenes_test Validation_42444966_40391.790_00003764
+ARKitScenes_test Validation_42444966_40403.785_00004484
+ARKitScenes_test Validation_42444968_40282.385_00002269
+ARKitScenes_test Validation_42444968_40298.395_00003230
+ARKitScenes_test Validation_42444968_40314.388_00004190
+ARKitScenes_test Validation_42444968_40317.387_00004370
+ARKitScenes_test Validation_42444976_40167.383_00001597
+ARKitScenes_test Validation_42444976_40181.394_00002438
+ARKitScenes_test Validation_42444976_40230.390_00005379
+ARKitScenes_test Validation_42445021_48888.256_00000516
+ARKitScenes_test Validation_42445026_48955.063_00001189
+ARKitScenes_test Validation_42445031_49451.392_00000403
+ARKitScenes_test Validation_42445031_49460.389_00000943
+ARKitScenes_test Validation_42445031_49507.387_00003764
+ARKitScenes_test Validation_42445031_49509.403_00003885
+ARKitScenes_test Validation_42445031_49515.400_00004245
+ARKitScenes_test Validation_42445429_50317.089_00000037
+ARKitScenes_test Validation_42445441_50215.779_00000096
+ARKitScenes_test Validation_42445441_50225.792_00000697
+ARKitScenes_test Validation_42445448_50409.603_00000056
+ARKitScenes_test Validation_42445448_50484.590_00004557
+ARKitScenes_test Validation_42445448_50505.581_00005817
+ARKitScenes_test Validation_42445991_75294.425_00002323
+ARKitScenes_test Validation_42445991_75309.436_00003224
+ARKitScenes_test Validation_42445991_75325.429_00004184
+ARKitScenes_test Validation_42446038_347874.972_00000943
+ARKitScenes_test Validation_42446049_347782.076_00000517
+ARKitScenes_test Validation_42446100_77922.291_00000937
+ARKitScenes_test Validation_42446100_77925.290_00001117
+ARKitScenes_test Validation_42446100_77951.280_00002677
+ARKitScenes_test Validation_42446100_77954.295_00002858
+ARKitScenes_test Validation_42446100_77956.294_00002978
+ARKitScenes_test Validation_42446100_77967.290_00003638
+ARKitScenes_test Validation_42446100_77971.288_00003878
+ARKitScenes_test Validation_42446100_77978.285_00004298
+ARKitScenes_test Validation_42446100_78000.293_00005619
+ARKitScenes_test Validation_42446100_78004.292_00005859
+ARKitScenes_test Validation_42446100_78012.289_00006339
+ARKitScenes_test Validation_42446100_78018.286_00006699
+ARKitScenes_test Validation_42446100_78021.285_00006879
+ARKitScenes_test Validation_42446100_78025.284_00007119
+ARKitScenes_test Validation_42446103_78053.189_00000043
+ARKitScenes_test Validation_42446103_78059.187_00000403
+ARKitScenes_test Validation_42446103_78098.188_00002744
+ARKitScenes_test Validation_42446103_78113.182_00003644
+ARKitScenes_test Validation_42446103_78120.196_00004065
+ARKitScenes_test Validation_42446103_78124.194_00004305
+ARKitScenes_test Validation_42446103_78125.194_00004365
+ARKitScenes_test Validation_42446103_78131.192_00004725
+ARKitScenes_test Validation_42446103_78165.195_00006766
+ARKitScenes_test Validation_42446103_78170.193_00007066
+ARKitScenes_test Validation_42446103_78176.191_00007426
+ARKitScenes_test Validation_42446114_78209.994_00001298
+ARKitScenes_test Validation_42446114_78218.990_00001838
+ARKitScenes_test Validation_42446114_78220.989_00001958
+ARKitScenes_test Validation_42446114_78221.989_00002018
+ARKitScenes_test Validation_42446114_78238.982_00003038
+ARKitScenes_test Validation_42446114_78241.981_00003218
+ARKitScenes_test Validation_42446114_78258.991_00004239
+ARKitScenes_test Validation_42446114_78289.995_00006100
+ARKitScenes_test Validation_42446114_78314.986_00007600
+ARKitScenes_test Validation_42446114_78322.982_00008080
+ARKitScenes_test Validation_42446114_78327.997_00008381
+ARKitScenes_test Validation_42446156_79145.119_00000577
+ARKitScenes_test Validation_42446163_79567.523_00000097
+ARKitScenes_test Validation_42446163_79575.520_00000577
+ARKitScenes_test Validation_42446165_79787.719_00004358
+ARKitScenes_test Validation_42446167_79666.734_00001424
+ARKitScenes_test Validation_42446167_79674.731_00001904
+ARKitScenes_test Validation_42446167_79675.730_00001964
+ARKitScenes_test Validation_42446167_79693.723_00003044
+ARKitScenes_test Validation_42446167_79708.734_00003945
+ARKitScenes_test Validation_42446517_197446.270_00001717
+ARKitScenes_test Validation_42446517_197455.283_00002258
+ARKitScenes_test Validation_42446519_197493.884_00000578
+ARKitScenes_test Validation_42446519_197515.875_00001898
+ARKitScenes_test Validation_42446519_197554.875_00004239
+ARKitScenes_test Validation_42446519_197555.875_00004299
+ARKitScenes_test Validation_42446519_197593.876_00006580
+ARKitScenes_test Validation_42446522_197357.873_00002647
+ARKitScenes_test Validation_42446522_197389.877_00004568
+ARKitScenes_test Validation_42446522_197392.875_00004748
+ARKitScenes_test Validation_42446522_197394.874_00004868
+ARKitScenes_test Validation_42446527_198630.850_00000301
+ARKitScenes_test Validation_42446529_198723.845_00000133
+ARKitScenes_test Validation_42446529_198742.837_00001273
+ARKitScenes_test Validation_42446529_198770.842_00002954
+ARKitScenes_test Validation_42446532_198850.942_00002600
+ARKitScenes_test Validation_42446532_198871.950_00003861
+ARKitScenes_test Validation_42446533_200402.294_00000535
+ARKitScenes_test Validation_42446533_200404.294_00000655
+ARKitScenes_test Validation_42446535_200530.492_00003188
+ARKitScenes_test Validation_42446540_201462.348_00000691
+ARKitScenes_test Validation_42446540_201472.344_00001291
+ARKitScenes_test Validation_42446540_201478.342_00001651
+ARKitScenes_test Validation_42446540_201482.340_00001891
+ARKitScenes_test Validation_42446540_201489.337_00002311
+ARKitScenes_test Validation_42446540_201499.350_00002912
+ARKitScenes_test Validation_42446540_201502.348_00003092
+ARKitScenes_test Validation_42446540_201517.342_00003992
+ARKitScenes_test Validation_42446540_201524.339_00004412
+ARKitScenes_test Validation_42446540_201526.338_00004532
+ARKitScenes_test Validation_42446540_201534.335_00005012
+ARKitScenes_test Validation_42446540_201536.351_00005133
+ARKitScenes_test Validation_42446541_201563.440_00000943
+ARKitScenes_test Validation_42446541_201567.438_00001183
+ARKitScenes_test Validation_42446541_201628.446_00004845
+ARKitScenes_test Validation_42446541_201636.443_00005325
+ARKitScenes_test Validation_42446541_201638.442_00005445
+ARKitScenes_test Validation_42446541_201657.434_00006585
+ARKitScenes_test Validation_42446541_201661.433_00006825
+ARKitScenes_test Validation_42897501_270032.593_00001466
+ARKitScenes_test Validation_42897501_270048.586_00002426
+ARKitScenes_test Validation_42897501_270050.586_00002546
+ARKitScenes_test Validation_42897501_270053.584_00002726
+ARKitScenes_test Validation_42897501_270069.578_00003686
+ARKitScenes_test Validation_42897504_269846.486_00000259
+ARKitScenes_test Validation_42897504_269883.487_00002480
+ARKitScenes_test Validation_42897504_269889.485_00002840
+ARKitScenes_test Validation_42897504_269902.479_00003620
+ARKitScenes_test Validation_42897508_269962.088_00002384
+ARKitScenes_test Validation_42897508_269975.083_00003164
+ARKitScenes_test Validation_42897521_273988.900_00002162
+ARKitScenes_test Validation_42897526_273865.400_00001255
+ARKitScenes_test Validation_42897526_273873.397_00001735
+ARKitScenes_test Validation_42897528_273919.095_00001141
+ARKitScenes_test Validation_42897528_273940.103_00002402
+ARKitScenes_test Validation_42897541_275396.527_00001285
+ARKitScenes_test Validation_42897541_275404.540_00001766
+ARKitScenes_test Validation_42897541_275436.527_00003686
+ARKitScenes_test Validation_42897542_275468.131_00000811
+ARKitScenes_test Validation_42897542_275483.141_00001712
+ARKitScenes_test Validation_42897549_276508.368_00001387
+ARKitScenes_test Validation_42897549_276512.366_00001627
+ARKitScenes_test Validation_42897552_277361.813_00000217
+ARKitScenes_test Validation_42897554_277333.008_00001135
+ARKitScenes_test Validation_42897559_277434.600_00000241
+ARKitScenes_test Validation_42897561_278930.716_00001159
+ARKitScenes_test Validation_42897561_278945.710_00002059
+ARKitScenes_test Validation_42897561_278946.710_00002119
+ARKitScenes_test Validation_42897561_278950.708_00002359
+ARKitScenes_test Validation_42897566_279057.014_00001076
+ARKitScenes_test Validation_42897566_279079.005_00002396
+ARKitScenes_test Validation_42897599_476331.200_00001789
+ARKitScenes_test Validation_42897599_476342.212_00002450
+ARKitScenes_test Validation_42897599_476351.209_00002990
+ARKitScenes_test Validation_42897599_476408.202_00006411
+ARKitScenes_test Validation_42897599_476442.205_00008452
+ARKitScenes_test Validation_42897599_476474.208_00010373
+ARKitScenes_test Validation_42897599_476495.200_00011633
+ARKitScenes_test Validation_42897599_476498.199_00011813
+ARKitScenes_test Validation_42897599_476518.207_00013014
+ARKitScenes_test Validation_42897599_476522.205_00013254
+ARKitScenes_test Validation_42897599_476559.207_00015475
+ARKitScenes_test Validation_42897647_478140.187_00000643
+ARKitScenes_test Validation_42897647_478179.188_00002984
+ARKitScenes_test Validation_42897647_478188.184_00003524
+ARKitScenes_test Validation_42897647_478200.179_00004244
+ARKitScenes_test Validation_42897647_478203.178_00004424
+ARKitScenes_test Validation_42897647_478207.176_00004664
+ARKitScenes_test Validation_42897647_478215.190_00005145
+ARKitScenes_test Validation_42897651_478324.278_00004796
+ARKitScenes_test Validation_42897651_478325.278_00004856
+ARKitScenes_test Validation_42897651_478334.274_00005396
+ARKitScenes_test Validation_42897651_478344.286_00005997
+ARKitScenes_test Validation_42897651_478354.282_00006597
+ARKitScenes_test Validation_42897651_478357.281_00006777
+ARKitScenes_test Validation_42897651_478370.276_00007557
+ARKitScenes_test Validation_42897651_478433.283_00011339
+ARKitScenes_test Validation_42897651_478439.281_00011699
+ARKitScenes_test Validation_42897651_478440.280_00011759
+ARKitScenes_test Validation_42897651_478458.273_00012839
+ARKitScenes_test Validation_42897651_478463.271_00013139
+ARKitScenes_test Validation_42897651_478473.283_00013740
+ARKitScenes_test Validation_42897651_478477.282_00013980
+ARKitScenes_test Validation_42897651_478481.280_00014220
+ARKitScenes_test Validation_42897651_478482.280_00014280
+ARKitScenes_test Validation_42897651_478498.273_00015240
+ARKitScenes_test Validation_42897667_478043.077_00002797
+ARKitScenes_test Validation_42897667_478052.090_00003338
+ARKitScenes_test Validation_42897667_478080.078_00005018
+ARKitScenes_test Validation_42897667_478084.077_00005258
+ARKitScenes_test Validation_42897667_478120.079_00007419
+ARKitScenes_test Validation_42897688_479152.078_00000516
+ARKitScenes_test Validation_42897688_479155.076_00000696
+ARKitScenes_test Validation_42897688_479181.082_00002257
+ARKitScenes_test Validation_42897688_479189.079_00002737
+ARKitScenes_test Validation_42897688_479227.080_00005018
+ARKitScenes_test Validation_42897688_479273.078_00007779
+ARKitScenes_test Validation_42897688_479276.077_00007959
+ARKitScenes_test Validation_42897688_479302.082_00009520
+ARKitScenes_test Validation_42897688_479303.082_00009580
+ARKitScenes_test Validation_42898811_167554.386_00005018
+ARKitScenes_test Validation_42898816_167393.902_00002444
+ARKitScenes_test Validation_42898818_168178.187_00001598
+ARKitScenes_test Validation_42898822_168207.574_00000157
+ARKitScenes_test Validation_42898822_168249.574_00002678
+ARKitScenes_test Validation_42898822_168262.585_00003459
+ARKitScenes_test Validation_42898826_168099.186_00000103
+ARKitScenes_test Validation_42898849_196451.916_00000397
+ARKitScenes_test Validation_42898849_196462.928_00001058
+ARKitScenes_test Validation_42898849_196469.926_00001478
+ARKitScenes_test Validation_42898849_196475.923_00001838
+ARKitScenes_test Validation_42898849_196483.920_00002318
+ARKitScenes_test Validation_42898849_196484.920_00002378
+ARKitScenes_test Validation_42898849_196497.915_00003158
+ARKitScenes_test Validation_42898849_196517.923_00004359
+ARKitScenes_test Validation_42898849_196543.913_00005919
+ARKitScenes_test Validation_42898849_196544.913_00005979
+ARKitScenes_test Validation_42898849_196546.928_00006100
+ARKitScenes_test Validation_42898849_196563.922_00007120
+ARKitScenes_test Validation_42898849_196582.914_00008260
+ARKitScenes_test Validation_42898854_196214.727_00001928
+ARKitScenes_test Validation_42898854_196218.725_00002168
+ARKitScenes_test Validation_42898854_196260.725_00004689
+ARKitScenes_test Validation_42898854_196276.719_00005649
+ARKitScenes_test Validation_42898854_196281.717_00005949
+ARKitScenes_test Validation_42898854_196289.714_00006429
+ARKitScenes_test Validation_42898854_196292.712_00006609
+ARKitScenes_test Validation_42898854_196297.727_00006910
+ARKitScenes_test Validation_42898862_196317.719_00000391
+ARKitScenes_test Validation_42898862_196324.716_00000811
+ARKitScenes_test Validation_42898862_196328.715_00001051
+ARKitScenes_test Validation_42898862_196330.714_00001171
+ARKitScenes_test Validation_42898862_196343.726_00001952
+ARKitScenes_test Validation_42898862_196348.724_00002252
+ARKitScenes_test Validation_42898862_196352.722_00002492
+ARKitScenes_test Validation_42898862_196361.718_00003032
+ARKitScenes_test Validation_42898862_196364.717_00003212
+ARKitScenes_test Validation_42898862_196371.714_00003632
+ARKitScenes_test Validation_42898862_196382.727_00004293
+ARKitScenes_test Validation_42898862_196385.726_00004473
+ARKitScenes_test Validation_42898862_196387.725_00004593
+ARKitScenes_test Validation_42898862_196396.721_00005133
+ARKitScenes_test Validation_42898862_196418.713_00006453
+ARKitScenes_test Validation_42898862_196423.727_00006754
+ARKitScenes_test Validation_42899461_195801.429_00000997
+ARKitScenes_test Validation_42899461_195803.428_00001117
+ARKitScenes_test Validation_42899461_195807.426_00001357
+ARKitScenes_test Validation_42899461_195865.419_00004838
+ARKitScenes_test Validation_42899461_195869.434_00005079
+ARKitScenes_test Validation_42899461_195881.429_00005799
+ARKitScenes_test Validation_42899471_195673.532_00000938
+ARKitScenes_test Validation_42899471_195705.535_00002859
+ARKitScenes_test Validation_42899471_195706.535_00002919
+ARKitScenes_test Validation_42899471_195710.533_00003159
+ARKitScenes_test Validation_42899611_228365.713_00000997
+ARKitScenes_test Validation_42899611_228379.724_00001838
+ARKitScenes_test Validation_42899611_228387.721_00002318
+ARKitScenes_test Validation_42899611_228400.716_00003098
+ARKitScenes_test Validation_42899611_228401.716_00003158
+ARKitScenes_test Validation_42899611_228411.712_00003758
+ARKitScenes_test Validation_42899612_228429.521_00000229
+ARKitScenes_test Validation_42899612_228433.520_00000469
+ARKitScenes_test Validation_42899612_228469.522_00002630
+ARKitScenes_test Validation_42899612_228476.519_00003050
+ARKitScenes_test Validation_42899612_228479.518_00003230
+ARKitScenes_test Validation_42899612_228481.517_00003350
+ARKitScenes_test Validation_42899612_228503.525_00004671
+ARKitScenes_test Validation_42899612_228515.521_00005391
+ARKitScenes_test Validation_42899613_228274.016_00000102
+ARKitScenes_test Validation_42899613_228311.018_00002323
+ARKitScenes_test Validation_42899613_228315.017_00002563
+ARKitScenes_test Validation_42899619_228890.872_00000157
+ARKitScenes_test Validation_42899619_228899.869_00000697
+ARKitScenes_test Validation_42899620_228848.672_00000097
+ARKitScenes_test Validation_44358442_42896.098_00000343
+ARKitScenes_test Validation_44358442_42911.092_00001243
+ARKitScenes_test Validation_44358446_43064.895_00003398
+ARKitScenes_test Validation_44358446_43120.888_00006759
+ARKitScenes_test Validation_44358448_42965.802_00000955
+ARKitScenes_test Validation_44358448_42978.797_00001735
+ARKitScenes_test Validation_44358448_42996.790_00002815
+ARKitScenes_test Validation_44358448_42998.789_00002935
+ARKitScenes_test Validation_44358448_43000.805_00003056
+ARKitScenes_test Validation_44358451_43608.890_00000217
+ARKitScenes_test Validation_44358451_43610.889_00000337
+ARKitScenes_test Validation_44358451_43614.888_00000577
+ARKitScenes_test Validation_44358451_43619.886_00000877
+ARKitScenes_test Validation_44358451_43640.894_00002138
+ARKitScenes_test Validation_44358451_43669.881_00003878
+ARKitScenes_test Validation_44358451_43714.896_00006580
+ARKitScenes_test Validation_44358452_43508.598_00000517
+ARKitScenes_test Validation_44358452_43509.598_00000577
+ARKitScenes_test Validation_44358452_43586.583_00005198
+ARKitScenes_test Validation_44358452_43590.598_00005439
+ARKitScenes_test Validation_45260854_575.085_00001129
+ARKitScenes_test Validation_45260854_578.084_00001309
+ARKitScenes_test Validation_45260854_593.078_00002209
+ARKitScenes_test Validation_45260854_604.090_00002870
+ARKitScenes_test Validation_45260856_632.278_00000396
+ARKitScenes_test Validation_45260856_635.277_00000576
+ARKitScenes_test Validation_45260856_656.285_00001837
+ARKitScenes_test Validation_45260856_694.286_00004118
+ARKitScenes_test Validation_45260856_707.281_00004898
+ARKitScenes_test Validation_45260856_713.278_00005258
+ARKitScenes_test Validation_45260857_501.682_00000277
+ARKitScenes_test Validation_45260857_509.679_00000757
+ARKitScenes_test Validation_45260857_515.693_00001118
+ARKitScenes_test Validation_45260857_518.692_00001298
+ARKitScenes_test Validation_45260857_533.686_00002198
+ARKitScenes_test Validation_45260857_542.682_00002738
+ARKitScenes_test Validation_45260898_786.983_00001429
+ARKitScenes_test Validation_45260899_887.793_00002384
+ARKitScenes_test Validation_45260899_896.789_00002924
+ARKitScenes_test Validation_45260900_833.481_00001813
+ARKitScenes_test Validation_45260920_2470.417_00000228
+ARKitScenes_test Validation_45260920_2475.432_00000529
+ARKitScenes_test Validation_45260920_2493.425_00001609
+ARKitScenes_test Validation_45260920_2508.419_00002509
+ARKitScenes_test Validation_45260920_2534.425_00004070
+ARKitScenes_test Validation_45260925_2396.830_00000157
+ARKitScenes_test Validation_45260925_2429.817_00002137
+ARKitScenes_test Validation_45260925_2432.816_00002317
+ARKitScenes_test Validation_45260925_2434.831_00002438
+ARKitScenes_test Validation_45260928_2379.220_00002498
+ARKitScenes_test Validation_45261121_3431.070_00001034
+ARKitScenes_test Validation_45261121_3433.069_00001154
+ARKitScenes_test Validation_45261121_3445.064_00001874
+ARKitScenes_test Validation_45261121_3446.063_00001934
+ARKitScenes_test Validation_45261121_3449.062_00002114
+ARKitScenes_test Validation_45261121_3451.061_00002234
+ARKitScenes_test Validation_45261121_3455.060_00002474
+ARKitScenes_test Validation_45261121_3460.058_00002774
+ARKitScenes_test Validation_45261128_3497.159_00000457
+ARKitScenes_test Validation_45261128_3500.158_00000637
+ARKitScenes_test Validation_45261128_3502.157_00000757
+ARKitScenes_test Validation_45261128_3534.160_00002678
+ARKitScenes_test Validation_45261133_4053.263_00002797
+ARKitScenes_test Validation_45261133_4093.263_00005198
+ARKitScenes_test Validation_45261133_4098.261_00005498
+ARKitScenes_test Validation_45261133_4108.273_00006099
+ARKitScenes_test Validation_45261133_4134.262_00007659
+ARKitScenes_test Validation_45261133_4135.262_00007719
+ARKitScenes_test Validation_45261133_4139.260_00007959
+ARKitScenes_test Validation_45261133_4141.259_00008079
+ARKitScenes_test Validation_45261140_3956.270_00000583
+ARKitScenes_test Validation_45261140_3958.269_00000703
+ARKitScenes_test Validation_45261140_3977.261_00001843
+ARKitScenes_test Validation_45261140_3985.274_00002324
+ARKitScenes_test Validation_45261142_3924.466_00002335
+ARKitScenes_test Validation_45261143_4589.702_00000643
+ARKitScenes_test Validation_45261143_4602.714_00001424
+ARKitScenes_test Validation_45261143_4630.702_00003104
+ARKitScenes_test Validation_45261144_4656.008_00000337
+ARKitScenes_test Validation_45261150_4553.301_00001657
+ARKitScenes_test Validation_45261182_2970.729_00003398
+ARKitScenes_test Validation_45261182_2972.728_00003518
+ARKitScenes_test Validation_45261185_3551.484_00000283
+ARKitScenes_test Validation_45261185_3561.480_00000883
+ARKitScenes_test Validation_45261185_3581.489_00002084
+ARKitScenes_test Validation_45261190_3699.892_00000823
+ARKitScenes_test Validation_45261190_3709.888_00001423
+ARKitScenes_test Validation_45261190_3735.895_00002984
+ARKitScenes_test Validation_45261193_3621.190_00000169
+ARKitScenes_test Validation_45261193_3646.180_00001669
+ARKitScenes_test Validation_45261193_3654.194_00002150
+ARKitScenes_test Validation_45261575_77494.516_00001538
+ARKitScenes_test Validation_45261581_77517.507_00000097
+ARKitScenes_test Validation_45261581_77537.515_00001298
+ARKitScenes_test Validation_45261581_77538.515_00001358
+ARKitScenes_test Validation_45261581_77539.514_00001418
+ARKitScenes_test Validation_45261581_77560.505_00002678
+ARKitScenes_test Validation_45261581_77587.511_00004299
+ARKitScenes_test Validation_45261581_77590.510_00004479
+ARKitScenes_test Validation_45261588_78074.609_00000637
+ARKitScenes_test Validation_45261588_78081.606_00001057
+ARKitScenes_test Validation_45261588_78083.605_00001177
+ARKitScenes_test Validation_45261588_78091.602_00001657
+ARKitScenes_test Validation_45261594_78053.201_00001477
+ARKitScenes_test Validation_45261619_55117.682_00003176
+ARKitScenes_test Validation_45261620_54953.280_00001297
+ARKitScenes_test Validation_45261631_56074.403_00002858
+ARKitScenes_test Validation_45261631_56077.402_00003038
+ARKitScenes_test Validation_45261632_55901.188_00000678
+ARKitScenes_test Validation_45261637_55970.494_00000877
+ARKitScenes_test Validation_45662921_21777.915_00001627
+ARKitScenes_test Validation_45662921_21785.928_00002108
+ARKitScenes_test Validation_45662921_21792.926_00002528
+ARKitScenes_test Validation_45662921_21795.924_00002708
+ARKitScenes_test Validation_45662921_21830.926_00004809
+ARKitScenes_test Validation_45662921_21843.921_00005589
+ARKitScenes_test Validation_45662921_21844.921_00005649
+ARKitScenes_test Validation_45662921_21852.917_00006129
+ARKitScenes_test Validation_45662924_21565.920_00000637
+ARKitScenes_test Validation_45662924_21575.916_00001237
+ARKitScenes_test Validation_45662924_21603.921_00002918
+ARKitScenes_test Validation_45662926_21672.326_00002048
+ARKitScenes_test Validation_45662926_21678.323_00002408
+ARKitScenes_test Validation_45662926_21679.323_00002468
+ARKitScenes_test Validation_45662926_21701.330_00003789
+ARKitScenes_test Validation_45662926_21718.323_00004809
+ARKitScenes_test Validation_45662926_21719.323_00004869
+ARKitScenes_test Validation_45662926_21720.322_00004929
+ARKitScenes_test Validation_45662942_22882.675_00000037
+ARKitScenes_test Validation_45662942_22899.668_00001057
+ARKitScenes_test Validation_45662942_22915.661_00002017
+ARKitScenes_test Validation_45662942_22930.672_00002918
+ARKitScenes_test Validation_45662943_23021.267_00000157
+ARKitScenes_test Validation_45662943_23140.268_00007300
+ARKitScenes_test Validation_45662943_23172.254_00009220
+ARKitScenes_test Validation_45662943_23198.260_00010781
+ARKitScenes_test Validation_45662943_23200.259_00010901
+ARKitScenes_test Validation_45662943_23203.258_00011081
+ARKitScenes_test Validation_45662944_22955.761_00000817
+ARKitScenes_test Validation_45662970_26110.534_00000247
+ARKitScenes_test Validation_45662970_26162.530_00003368
+ARKitScenes_test Validation_45662970_26164.529_00003488
+ARKitScenes_test Validation_45662970_26169.527_00003788
+ARKitScenes_test Validation_45662970_26170.527_00003848
+ARKitScenes_test Validation_45662975_26067.134_00000163
+ARKitScenes_test Validation_45662975_26074.131_00000583
+ARKitScenes_test Validation_45662981_27941.098_00000289
+ARKitScenes_test Validation_45662981_28034.095_00005871
+ARKitScenes_test Validation_45662983_27797.888_00000097
+ARKitScenes_test Validation_45662983_27799.887_00000217
+ARKitScenes_test Validation_45662983_27803.886_00000457
+ARKitScenes_test Validation_45662987_27872.192_00000349
+ARKitScenes_test Validation_45663113_55333.668_00001778
+ARKitScenes_test Validation_45663114_55382.864_00000397
+ARKitScenes_test Validation_45663114_55385.863_00000577
+ARKitScenes_test Validation_45663114_55413.868_00002258
+ARKitScenes_test Validation_45663114_55415.867_00002378
+ARKitScenes_test Validation_45663115_55471.860_00002558
+ARKitScenes_test Validation_45663149_63308.707_00000757
+ARKitScenes_test Validation_45663149_63312.706_00000997
+ARKitScenes_test Validation_45663150_63508.953_00000108
+ARKitScenes_test Validation_45663150_63515.950_00000528
+ARKitScenes_test Validation_45663150_63519.949_00000768
+ARKitScenes_test Validation_45663150_63548.954_00002509
+ARKitScenes_test Validation_45663150_63575.960_00004130
+ARKitScenes_test Validation_45663150_63579.958_00004370
+ARKitScenes_test Validation_45663150_63582.957_00004550
+ARKitScenes_test Validation_45663154_63400.863_00000133
+ARKitScenes_test Validation_45663154_63407.860_00000553
+ARKitScenes_test Validation_45663154_63408.859_00000613
+ARKitScenes_test Validation_45663154_63435.849_00002233
+ARKitScenes_test Validation_45663154_63436.848_00002293
+ARKitScenes_test Validation_45663154_63451.859_00003194
+ARKitScenes_test Validation_45663164_65934.817_00000234
+ARKitScenes_test Validation_45663164_65937.816_00000414
+ARKitScenes_test Validation_45663164_65954.825_00001435
+ARKitScenes_test Validation_45663164_65965.821_00002095
+ARKitScenes_test Validation_45663164_65971.819_00002455
+ARKitScenes_test Validation_45663164_65981.815_00003055
+ARKitScenes_test Validation_45663164_65990.828_00003596
+ARKitScenes_test Validation_45663164_66002.823_00004316
+ARKitScenes_test Validation_45663165_65825.027_00001238
+ARKitScenes_test Validation_45663165_65826.026_00001298
+ARKitScenes_test Validation_45663175_65888.618_00001033
+ARKitScenes_test Validation_45663175_65895.616_00001453
+ARKitScenes_test Validation_45663175_65900.614_00001753
+ARKitScenes_test Validation_47115452_13059.567_00000217
+ARKitScenes_test Validation_47115452_13068.580_00000758
+ARKitScenes_test Validation_47115452_13087.572_00001898
+ARKitScenes_test Validation_47115452_13111.579_00003339
+ARKitScenes_test Validation_47115452_13118.576_00003759
+ARKitScenes_test Validation_47115452_13119.575_00003819
+ARKitScenes_test Validation_47115460_13170.771_00002029
+ARKitScenes_test Validation_47115463_13276.477_00003458
+ARKitScenes_test Validation_47115463_13302.466_00005018
+ARKitScenes_test Validation_47115469_14015.292_00000277
+ARKitScenes_test Validation_47115469_14028.286_00001057
+ARKitScenes_test Validation_47115469_14030.285_00001177
+ARKitScenes_test Validation_47115473_14110.785_00002330
+ARKitScenes_test Validation_47115473_14130.777_00003530
+ARKitScenes_test Validation_47115473_14143.788_00004311
+ARKitScenes_test Validation_47115473_14173.776_00006111
+ARKitScenes_test Validation_47115474_13964.679_00000282
+ARKitScenes_test Validation_47115474_13981.689_00001303
+ARKitScenes_test Validation_47204552_3362.090_00000577
+ARKitScenes_test Validation_47204552_3393.094_00002438
+ARKitScenes_test Validation_47204552_3399.091_00002798
+ARKitScenes_test Validation_47204552_3401.091_00002918
+ARKitScenes_test Validation_47204552_3402.090_00002978
+ARKitScenes_test Validation_47204552_3415.101_00003759
+ARKitScenes_test Validation_47204552_3423.098_00004239
+ARKitScenes_test Validation_47204552_3427.097_00004479
+ARKitScenes_test Validation_47204552_3438.092_00005139
+ARKitScenes_test Validation_47204552_3450.087_00005859
+ARKitScenes_test Validation_47204552_3478.092_00007540
+ARKitScenes_test Validation_47204554_3222.198_00000697
+ARKitScenes_test Validation_47204554_3262.198_00003098
+ARKitScenes_test Validation_47204554_3276.192_00003938
+ARKitScenes_test Validation_47204556_3287.388_00000096
+ARKitScenes_test Validation_47204556_3289.387_00000216
+ARKitScenes_test Validation_47204556_3296.401_00000637
+ARKitScenes_test Validation_47204556_3318.392_00001957
+ARKitScenes_test Validation_47204556_3339.400_00003218
+ARKitScenes_test Validation_47204559_4004.548_00000997
+ARKitScenes_test Validation_47204559_4005.547_00001057
+ARKitScenes_test Validation_47204563_4035.451_00000157
+ARKitScenes_test Validation_47204566_4079.050_00000217
+ARKitScenes_test Validation_47204566_4108.038_00001957
+ARKitScenes_test Validation_47204566_4112.036_00002197
+ARKitScenes_test Validation_47204566_4122.049_00002798
+ARKitScenes_test Validation_47204566_4127.047_00003098
+ARKitScenes_test Validation_47204573_4957.623_00000038
+ARKitScenes_test Validation_47204573_4997.607_00002438
+ARKitScenes_test Validation_47204573_5033.609_00004599
+ARKitScenes_test Validation_47204573_5037.607_00004839
+ARKitScenes_test Validation_47204575_4843.221_00000529
+ARKitScenes_test Validation_47204575_4872.209_00002269
+ARKitScenes_test Validation_47204575_4874.208_00002389
+ARKitScenes_test Validation_47204578_4911.209_00001063
+ARKitScenes_test Validation_47204578_4929.219_00002144
+ARKitScenes_test Validation_47204605_2404.299_00000121
+ARKitScenes_test Validation_47204605_2412.295_00000601
+ARKitScenes_test Validation_47204605_2419.293_00001021
+ARKitScenes_test Validation_47204605_2420.292_00001081
+ARKitScenes_test Validation_47204605_2431.305_00001742
+ARKitScenes_test Validation_47204605_2436.303_00002042
+ARKitScenes_test Validation_47204605_2440.301_00002282
+ARKitScenes_test Validation_47204607_2528.799_00000517
+ARKitScenes_test Validation_47204607_2560.803_00002438
+ARKitScenes_test Validation_47204607_2561.803_00002498
+ARKitScenes_test Validation_47204607_2569.800_00002978
+ARKitScenes_test Validation_47204607_2573.798_00003218
+ARKitScenes_test Validation_47204607_2574.798_00003278
+ARKitScenes_test Validation_47204607_2577.797_00003458
+ARKitScenes_test Validation_47204607_2583.794_00003818
+ARKitScenes_test Validation_47204607_2591.791_00004298
+ARKitScenes_test Validation_47204607_2626.794_00006399
+ARKitScenes_test Validation_47204607_2634.791_00006879
+ARKitScenes_test Validation_47204607_2664.796_00008680
+ARKitScenes_test Validation_47204609_2453.013_00000038
+ARKitScenes_test Validation_47204609_2485.000_00001958
+ARKitScenes_test Validation_47331068_131078.065_00000817
+ARKitScenes_test Validation_47331069_131220.357_00004598
+ARKitScenes_test Validation_47331071_131007.360_00000817
+ARKitScenes_test Validation_47331265_90013.317_00000134
+ARKitScenes_test Validation_47331265_90032.293_00001273
+ARKitScenes_test Validation_47331265_90067.295_00003374
+ARKitScenes_test Validation_47331266_89823.527_00000141
+ARKitScenes_test Validation_47331266_89825.493_00000259
+ARKitScenes_test Validation_47331266_89873.490_00003140
+ARKitScenes_test Validation_47331319_179040.028_00000234
+ARKitScenes_test Validation_47331319_179072.032_00002155
+ARKitScenes_test Validation_47331322_179115.348_00000110
+ARKitScenes_test Validation_47331322_179135.339_00001310
+ARKitScenes_test Validation_47331324_179185.452_00000122
+ARKitScenes_test Validation_47331324_179188.434_00000301
+ARKitScenes_test Validation_47331324_179200.430_00001021
+ARKitScenes_test Validation_47331324_179214.424_00001861
+ARKitScenes_test Validation_47331324_179216.440_00001982
+ARKitScenes_test Validation_47331651_22862.230_00000757
+ARKitScenes_test Validation_47331651_22892.235_00002558
+ARKitScenes_test Validation_47331651_22893.235_00002618
+ARKitScenes_test Validation_47331651_22920.224_00004238
+ARKitScenes_test Validation_47331651_22973.235_00007420
+ARKitScenes_test Validation_47331653_23010.337_00001538
+ARKitScenes_test Validation_47331653_23016.334_00001898
+ARKitScenes_test Validation_47331653_23030.329_00002738
+ARKitScenes_test Validation_47331653_23034.327_00002978
+ARKitScenes_test Validation_47331653_23076.326_00005499
+ARKitScenes_test Validation_47331653_23080.325_00005739
+ARKitScenes_test Validation_47331653_23090.337_00006340
+ARKitScenes_test Validation_47331653_23092.337_00006460
+ARKitScenes_test Validation_47331653_23132.320_00008860
+ARKitScenes_test Validation_47331654_22744.828_00000517
+ARKitScenes_test Validation_47331654_22746.827_00000637
+ARKitScenes_test Validation_47331654_22751.825_00000937
+ARKitScenes_test Validation_47331654_22772.834_00002198
+ARKitScenes_test Validation_47331654_22781.830_00002738
+ARKitScenes_test Validation_47331654_22787.827_00003098
+ARKitScenes_test Validation_47331654_22797.823_00003698
+ARKitScenes_test Validation_47331654_22833.825_00005859
+ARKitScenes_test Validation_47331661_23629.582_00002630
+ARKitScenes_test Validation_47331661_23690.590_00006292
+ARKitScenes_test Validation_47331662_23429.080_00000516
+ARKitScenes_test Validation_47331662_23466.082_00002737
+ARKitScenes_test Validation_47331662_23470.080_00002977
+ARKitScenes_test Validation_47331662_23472.079_00003097
+ARKitScenes_test Validation_47331988_170658.548_00003824
+ARKitScenes_test Validation_47331988_170671.559_00004605
+ARKitScenes_test Validation_47331988_170673.559_00004725
+ARKitScenes_test Validation_47331988_170674.558_00004785
+ARKitScenes_test Validation_47331988_170681.555_00005205
+ARKitScenes_test Validation_47331989_170440.853_00001597
+ARKitScenes_test Validation_47331990_170486.951_00000408
+ARKitScenes_test Validation_47331990_170529.950_00002989
+ARKitScenes_test Validation_47331990_170567.951_00005270
+ARKitScenes_test Validation_47331990_170578.963_00005931
+ARKitScenes_test Validation_47332004_171938.432_00000997
+ARKitScenes_test Validation_47332005_172095.735_00001963
+ARKitScenes_test Validation_47332005_172102.732_00002383
+ARKitScenes_test Validation_47332005_172149.729_00005204
+ARKitScenes_test Validation_47332885_7500.859_00001003
+ARKitScenes_test Validation_47332885_7517.869_00002024
+ARKitScenes_test Validation_47332886_7549.256_00000474
+ARKitScenes_test Validation_47332886_7550.256_00000534
+ARKitScenes_test Validation_47332886_7562.267_00001255
+ARKitScenes_test Validation_47332886_7567.265_00001555
+ARKitScenes_test Validation_47332886_7582.259_00002455
+ARKitScenes_test Validation_47332890_7653.364_00003398
+ARKitScenes_test Validation_47332890_7662.360_00003938
+ARKitScenes_test Validation_47332890_7663.360_00003998
+ARKitScenes_test Validation_47332890_7667.358_00004238
+ARKitScenes_test Validation_47332890_7668.358_00004298
+ARKitScenes_test Validation_47332893_9315.687_00007719
+ARKitScenes_test Validation_47332895_9057.792_00000715
+ARKitScenes_test Validation_47332895_9066.788_00001255
+ARKitScenes_test Validation_47332899_9174.194_00003308
+ARKitScenes_test Validation_47332899_9175.194_00003368
+ARKitScenes_test Validation_47332899_9177.193_00003488
+ARKitScenes_test Validation_47332899_9179.192_00003608
+ARKitScenes_test Validation_47332901_11032.594_00000985
+ARKitScenes_test Validation_47332901_11062.598_00002786
+ARKitScenes_test Validation_47332904_11093.386_00000943
+ARKitScenes_test Validation_47332904_11096.385_00001123
+ARKitScenes_test Validation_47332904_11149.396_00004305
+ARKitScenes_test Validation_47332905_10961.889_00000709
+ARKitScenes_test Validation_47332905_10964.888_00000889
+ARKitScenes_test Validation_47332910_12198.325_00000708
+ARKitScenes_test Validation_47332911_12283.823_00001483
+ARKitScenes_test Validation_47332911_12347.831_00005325
+ARKitScenes_test Validation_47332911_12351.829_00005565
+ARKitScenes_test Validation_47332915_13476.969_00000643
+ARKitScenes_test Validation_47332915_13505.974_00002384
+ARKitScenes_test Validation_47332915_13538.977_00004365
+ARKitScenes_test Validation_47332915_13547.973_00004905
+ARKitScenes_test Validation_47332915_13552.971_00005205
+ARKitScenes_test Validation_47332915_13560.968_00005685
+ARKitScenes_test Validation_47332918_13321.866_00000349
+ARKitScenes_test Validation_47332918_13363.865_00002870
+ARKitScenes_test Validation_47333440_53806.225_00000757
+ARKitScenes_test Validation_47333443_53755.129_00000397
+ARKitScenes_test Validation_47333443_53760.127_00000697
+ARKitScenes_test Validation_47333452_54966.217_00000883
+ARKitScenes_test Validation_47333452_54993.223_00002504
+ARKitScenes_test Validation_47333452_54995.222_00002624
+ARKitScenes_test Validation_47333456_55028.108_00001237
+ARKitScenes_test Validation_47333456_55030.107_00001357
+ARKitScenes_test Validation_47333456_55035.122_00001658
+ARKitScenes_test Validation_47333456_55058.112_00003038
+ARKitScenes_test Validation_47333456_55067.109_00003578
+ARKitScenes_test Validation_47333898_81325.974_00000397
+ARKitScenes_test Validation_47333898_81346.966_00001657
+ARKitScenes_test Validation_47333898_81372.972_00003218
+ARKitScenes_test Validation_47333898_81377.970_00003518
+ARKitScenes_test Validation_47333898_81378.969_00003578
+ARKitScenes_test Validation_47333899_81255.070_00000877
+ARKitScenes_test Validation_47333899_81271.063_00001837
+ARKitScenes_test Validation_47333899_81306.066_00003938
+ARKitScenes_test Validation_47333904_81416.371_00000877
+ARKitScenes_test Validation_47333904_81425.367_00001417
+ARKitScenes_test Validation_47333904_81432.364_00001837
+ARKitScenes_test Validation_47333916_82430.565_00003759
+ARKitScenes_test Validation_47333916_82435.563_00004059
+ARKitScenes_test Validation_47333918_82512.465_00003404
+ARKitScenes_test Validation_47333918_82533.457_00004664
+ARKitScenes_test Validation_47333920_82642.262_00005856
+ARKitScenes_test Validation_47333920_82666.253_00007296
+ARKitScenes_test Validation_47333923_83604.501_00000396
+ARKitScenes_test Validation_47333925_83573.613_00001964
+ARKitScenes_test Validation_47333927_84005.212_00000944
+ARKitScenes_test Validation_47333927_84013.209_00001424
+ARKitScenes_test Validation_47333927_84020.206_00001844
+ARKitScenes_test Validation_47333927_84025.204_00002144
+ARKitScenes_test Validation_47333927_84028.203_00002324
+ARKitScenes_test Validation_47333931_83940.705_00001658
+ARKitScenes_test Validation_47333931_83943.704_00001838
+ARKitScenes_test Validation_47333932_84109.203_00002798
+ARKitScenes_test Validation_47333932_84184.206_00007300
+ARKitScenes_test Validation_47333934_85556.772_00000469
+ARKitScenes_test Validation_47333934_85572.765_00001429
+ARKitScenes_test Validation_47333934_85623.778_00004491
+ARKitScenes_test Validation_47333934_85636.773_00005271
+ARKitScenes_test Validation_47333934_85638.772_00005391
+ARKitScenes_test Validation_47333934_85646.769_00005871
+ARKitScenes_test Validation_47333934_85659.763_00006651
+ARKitScenes_test Validation_47333937_85498.362_00000540
+ARKitScenes_test Validation_47333937_85501.378_00000721
+ARKitScenes_test Validation_47333937_85528.367_00002341
+ARKitScenes_test Validation_47333937_85541.378_00003122
+ARKitScenes_test Validation_47333937_85543.377_00003242
+ARKitScenes_test Validation_47333940_85418.978_00000517
+ARKitScenes_test Validation_47333940_85420.977_00000637
+ARKitScenes_test Validation_47333940_85422.976_00000757
+ARKitScenes_test Validation_47333940_85438.969_00001717
+ARKitScenes_test Validation_47333940_85480.969_00004238
+ARKitScenes_test Validation_47334105_92943.745_00003650
+ARKitScenes_test Validation_47334105_92981.746_00005931
+ARKitScenes_test Validation_47334105_93005.753_00007372
+ARKitScenes_test Validation_47334239_111152.021_00002918
+ARKitScenes_test Validation_47334240_111223.425_00003818
+ARKitScenes_test Validation_47429912_136038.580_00000937
+ARKitScenes_test Validation_47429912_136057.589_00002078
+ARKitScenes_test Validation_47429922_136625.256_00000577
+ARKitScenes_test Validation_47429971_16341.763_00003758
+ARKitScenes_test Validation_47429995_16689.687_00000229
+ARKitScenes_test Validation_47430024_18796.033_00001657
+ARKitScenes_test Validation_47430026_18833.034_00001297
+ARKitScenes_test Validation_47430026_18844.046_00001958
+ARKitScenes_test Validation_47430033_19430.380_00001363
+ARKitScenes_test Validation_47430036_19503.284_00000277
+ARKitScenes_test Validation_47430043_20580.283_00000156
+ARKitScenes_test Validation_47430045_20645.389_00001177
+ARKitScenes_test Validation_47430047_21106.832_00000937
+ARKitScenes_test Validation_47430047_21107.832_00000997
+ARKitScenes_test Validation_47895341_96434.329_00002918
+ARKitScenes_test Validation_47895348_96489.523_00001837
+ARKitScenes_test Validation_47895348_96510.515_00003097
+ARKitScenes_test Validation_47895348_96535.521_00004598
+ARKitScenes_test Validation_47895348_96543.518_00005078
+ARKitScenes_test Validation_47895350_96587.817_00002197
+ARKitScenes_test Validation_47895350_96593.814_00002557
+ARKitScenes_test Validation_47895350_96598.812_00002857
+ARKitScenes_test Validation_47895350_96692.824_00008500
+ARKitScenes_test Validation_47895355_98785.640_00001898
+ARKitScenes_test Validation_47895355_98786.640_00001958
+ARKitScenes_test Validation_47895355_98811.630_00003458
+ARKitScenes_test Validation_47895355_98813.629_00003578
+ARKitScenes_test Validation_47895355_98817.627_00003818
+ARKitScenes_test Validation_47895355_98873.638_00007180
+ARKitScenes_test Validation_47895355_98884.633_00007840
+ARKitScenes_test Validation_47895355_98890.631_00008200
+ARKitScenes_test Validation_47895355_98898.628_00008680
+ARKitScenes_test Validation_47895355_98911.639_00009461
+ARKitScenes_test Validation_47895355_98953.639_00011982
+ARKitScenes_test Validation_47895364_100176.943_00000457
+ARKitScenes_test Validation_47895364_100304.941_00008140
+ARKitScenes_test Validation_47895365_100109.337_00000637
+ARKitScenes_test Validation_47895556_457844.157_00003123
+ARKitScenes_test Validation_47895783_387008.265_00000337
+ARKitScenes_test Validation_47895783_387020.260_00001057
+ARKitScenes_test Validation_48018367_389470.584_00001538
+ARKitScenes_test Validation_48018368_389568.277_00002090
+ARKitScenes_test Validation_48018368_389569.276_00002150
+ARKitScenes_test Validation_48018368_389589.268_00003350
+ARKitScenes_test Validation_48018372_389499.672_00000577
+ARKitScenes_test Validation_48018379_390028.141_00001958
+ARKitScenes_test Validation_48018559_3343.849_00000157
+ARKitScenes_test Validation_48018560_3398.743_00000397
+ARKitScenes_test Validation_48018560_3417.752_00001538
+ARKitScenes_test Validation_48018566_3878.430_00001303
+ARKitScenes_test Validation_48018571_3900.055_00000140
+ARKitScenes_test Validation_48018572_3834.032_00002288
+ARKitScenes_test Validation_48018730_1763.469_00005739
+ARKitScenes_test Validation_48018732_1944.579_00002060
+ARKitScenes_test Validation_48018732_1949.577_00002360
+ARKitScenes_test Validation_48018732_1965.571_00003320
+ARKitScenes_test Validation_48018732_1994.575_00005061
+ARKitScenes_test Validation_48458484_111570.316_00000037
+ARKitScenes_test Validation_48458484_111592.307_00001357
+ARKitScenes_test Validation_48458484_111596.305_00001597
+ARKitScenes_test Validation_48458650_7065.603_00000396
+ARKitScenes_test Validation_48458650_7072.616_00000817
+ARKitScenes_test Validation_48458650_7110.617_00003098
+ARKitScenes_test Validation_48458656_7631.585_00000276
+ARKitScenes_test Validation_48458656_7633.584_00000396
+ARKitScenes_test Validation_48458656_7638.582_00000696
+ARKitScenes_test Validation_48458656_7648.595_00001297
+ARKitScenes_test Validation_48458656_7649.594_00001357
+ARKitScenes_test Validation_48458657_7594.684_00000642
+ARKitScenes_test Validation_48458657_7609.694_00001543
+ARKitScenes_test Validation_48458660_8266.963_00001418
+ARKitScenes_test Validation_48458667_8357.659_00000157
+ARKitScenes_test Validation_48458667_8361.657_00000397
+ARKitScenes_test Validation_48458667_8379.649_00001477
+ARKitScenes_test Validation_48458667_8382.648_00001657
+ARKitScenes_test Validation_48458667_8394.660_00002378
+ARKitScenes_test Validation_48458667_8420.649_00003938

external/WildCamera/splits/arkitscenes_val.txt

@@ -0,0 +1,800 @@
+ARKitScenes_test Validation_41069021_370.367_00003945
+ARKitScenes_test Validation_41069021_387.360_00004965
+ARKitScenes_test Validation_41069021_394.358_00005385
+ARKitScenes_test Validation_41069021_406.369_00006106
+ARKitScenes_test Validation_41069021_409.368_00006286
+ARKitScenes_test Validation_41069021_425.362_00007246
+ARKitScenes_test Validation_41069021_426.361_00007306
+ARKitScenes_test Validation_41069021_430.359_00007546
+ARKitScenes_test Validation_41069021_431.359_00007606
+ARKitScenes_test Validation_41069021_444.370_00008387
+ARKitScenes_test Validation_41069021_471.359_00010007
+ARKitScenes_test Validation_41069021_488.369_00011028
+ARKitScenes_test Validation_41069021_492.367_00011268
+ARKitScenes_test Validation_41069025_607.870_00001117
+ARKitScenes_test Validation_41069025_649.869_00003638
+ARKitScenes_test Validation_41069025_701.864_00006759
+ARKitScenes_test Validation_41069025_711.860_00007359
+ARKitScenes_test Validation_41069025_717.858_00007719
+ARKitScenes_test Validation_41069025_730.869_00008500
+ARKitScenes_test Validation_41069025_735.867_00008800
+ARKitScenes_test Validation_41069042_3049.237_00000385
+ARKitScenes_test Validation_41069042_3069.228_00001585
+ARKitScenes_test Validation_41069042_3071.227_00001705
+ARKitScenes_test Validation_41069042_3105.230_00003746
+ARKitScenes_test Validation_41069043_2860.631_00003698
+ARKitScenes_test Validation_41069043_2893.634_00005679
+ARKitScenes_test Validation_41069046_2921.323_00000636
+ARKitScenes_test Validation_41069046_2923.339_00000757
+ARKitScenes_test Validation_41069046_2925.338_00000877
+ARKitScenes_test Validation_41069046_2930.336_00001177
+ARKitScenes_test Validation_41069046_2960.323_00002977
+ARKitScenes_test Validation_41069046_2963.322_00003157
+ARKitScenes_test Validation_41069046_2980.332_00004178
+ARKitScenes_test Validation_41142278_4002.081_00000037
+ARKitScenes_test Validation_41142278_4042.081_00002438
+ARKitScenes_test Validation_41142280_3836.982_00000877
+ARKitScenes_test Validation_42444946_223633.870_00001597
+ARKitScenes_test Validation_42444946_223675.869_00004118
+ARKitScenes_test Validation_42444946_223682.866_00004538
+ARKitScenes_test Validation_42444949_223780.677_00004479
+ARKitScenes_test Validation_42444949_223783.675_00004659
+ARKitScenes_test Validation_42444950_223809.565_00000697
+ARKitScenes_test Validation_42444950_223855.563_00003458
+ARKitScenes_test Validation_42444966_40343.793_00000883
+ARKitScenes_test Validation_42444966_40380.794_00003104
+ARKitScenes_test Validation_42444966_40384.793_00003344
+ARKitScenes_test Validation_42444966_40393.789_00003884
+ARKitScenes_test Validation_42444966_40402.785_00004424
+ARKitScenes_test Validation_42444966_40406.783_00004664
+ARKitScenes_test Validation_42444966_40407.783_00004724
+ARKitScenes_test Validation_42444968_40245.400_00000049
+ARKitScenes_test Validation_42444968_40246.383_00000108
+ARKitScenes_test Validation_42444968_40252.381_00000468
+ARKitScenes_test Validation_42444968_40258.395_00000829
+ARKitScenes_test Validation_42444968_40297.396_00003170
+ARKitScenes_test Validation_42444968_40300.394_00003350
+ARKitScenes_test Validation_42444968_40312.389_00004070
+ARKitScenes_test Validation_42444976_40143.393_00000157
+ARKitScenes_test Validation_42444976_40169.382_00001717
+ARKitScenes_test Validation_42444976_40170.382_00001777
+ARKitScenes_test Validation_42444976_40171.398_00001838
+ARKitScenes_test Validation_42444976_40182.393_00002498
+ARKitScenes_test Validation_42444976_40186.392_00002738
+ARKitScenes_test Validation_42444976_40198.387_00003458
+ARKitScenes_test Validation_42444976_40199.386_00003518
+ARKitScenes_test Validation_42445021_48884.258_00000276
+ARKitScenes_test Validation_42445021_48887.257_00000456
+ARKitScenes_test Validation_42445022_49008.276_00000049
+ARKitScenes_test Validation_42445022_49014.256_00000408
+ARKitScenes_test Validation_42445022_49015.256_00000468
+ARKitScenes_test Validation_42445022_49035.265_00001669
+ARKitScenes_test Validation_42445022_49070.268_00003770
+ARKitScenes_test Validation_42445028_49607.697_00000349
+ARKitScenes_test Validation_42445028_49609.696_00000469
+ARKitScenes_test Validation_42445028_49655.695_00003230
+ARKitScenes_test Validation_42445429_50330.084_00000817
+ARKitScenes_test Validation_42445429_50333.083_00000997
+ARKitScenes_test Validation_42445441_50300.796_00005196
+ARKitScenes_test Validation_42445448_50410.586_00000115
+ARKitScenes_test Validation_42445448_50486.589_00004677
+ARKitScenes_test Validation_42445448_50494.586_00005157
+ARKitScenes_test Validation_42445991_75264.421_00000522
+ARKitScenes_test Validation_42445991_75304.421_00002923
+ARKitScenes_test Validation_42445991_75326.429_00004244
+ARKitScenes_test Validation_42446038_347909.974_00003044
+ARKitScenes_test Validation_42446038_347925.967_00004004
+ARKitScenes_test Validation_42446038_347928.983_00004185
+ARKitScenes_test Validation_42446100_77913.295_00000397
+ARKitScenes_test Validation_42446100_77962.292_00003338
+ARKitScenes_test Validation_42446100_77966.290_00003578
+ARKitScenes_test Validation_42446100_77994.296_00005259
+ARKitScenes_test Validation_42446100_77997.295_00005439
+ARKitScenes_test Validation_42446100_77999.294_00005559
+ARKitScenes_test Validation_42446100_78006.291_00005979
+ARKitScenes_test Validation_42446100_78007.291_00006039
+ARKitScenes_test Validation_42446100_78017.287_00006639
+ARKitScenes_test Validation_42446100_78019.286_00006759
+ARKitScenes_test Validation_42446100_78027.283_00007239
+ARKitScenes_test Validation_42446100_78028.282_00007299
+ARKitScenes_test Validation_42446103_78062.186_00000583
+ARKitScenes_test Validation_42446103_78083.194_00001844
+ARKitScenes_test Validation_42446103_78090.191_00002264
+ARKitScenes_test Validation_42446103_78096.189_00002624
+ARKitScenes_test Validation_42446103_78130.192_00004665
+ARKitScenes_test Validation_42446103_78137.189_00005085
+ARKitScenes_test Validation_42446103_78139.188_00005205
+ARKitScenes_test Validation_42446103_78157.181_00006285
+ARKitScenes_test Validation_42446103_78177.190_00007486
+ARKitScenes_test Validation_42446114_78198.981_00000637
+ARKitScenes_test Validation_42446114_78214.992_00001598
+ARKitScenes_test Validation_42446114_78222.989_00002078
+ARKitScenes_test Validation_42446114_78245.996_00003459
+ARKitScenes_test Validation_42446114_78251.994_00003819
+ARKitScenes_test Validation_42446114_78272.986_00005079
+ARKitScenes_test Validation_42446114_78292.994_00006280
+ARKitScenes_test Validation_42446114_78297.992_00006580
+ARKitScenes_test Validation_42446114_78298.992_00006640
+ARKitScenes_test Validation_42446114_78306.989_00007120
+ARKitScenes_test Validation_42446114_78311.987_00007420
+ARKitScenes_test Validation_42446114_78324.982_00008200
+ARKitScenes_test Validation_42446114_78367.981_00010781
+ARKitScenes_test Validation_42446156_79137.122_00000097
+ARKitScenes_test Validation_42446156_79149.117_00000817
+ARKitScenes_test Validation_42446156_79224.121_00005319
+ARKitScenes_test Validation_42446163_79569.523_00000217
+ARKitScenes_test Validation_42446163_79570.522_00000277
+ARKitScenes_test Validation_42446163_79603.526_00002258
+ARKitScenes_test Validation_42446163_79604.525_00002318
+ARKitScenes_test Validation_42446163_79608.524_00002558
+ARKitScenes_test Validation_42446163_79619.519_00003218
+ARKitScenes_test Validation_42446163_79627.533_00003699
+ARKitScenes_test Validation_42446165_79718.730_00000217
+ARKitScenes_test Validation_42446165_79724.728_00000577
+ARKitScenes_test Validation_42446165_79745.719_00001837
+ARKitScenes_test Validation_42446165_79771.726_00003398
+ARKitScenes_test Validation_42446165_79792.734_00004659
+ARKitScenes_test Validation_42446167_79644.726_00000103
+ARKitScenes_test Validation_42446167_79645.726_00000163
+ARKitScenes_test Validation_42446167_79654.722_00000703
+ARKitScenes_test Validation_42446167_79676.730_00002024
+ARKitScenes_test Validation_42446167_79682.728_00002384
+ARKitScenes_test Validation_42446167_79707.734_00003885
+ARKitScenes_test Validation_42446517_197447.270_00001777
+ARKitScenes_test Validation_42446519_197506.878_00001358
+ARKitScenes_test Validation_42446522_197316.873_00000186
+ARKitScenes_test Validation_42446522_197359.872_00002767
+ARKitScenes_test Validation_42446522_197360.872_00002827
+ARKitScenes_test Validation_42446522_197384.879_00004268
+ARKitScenes_test Validation_42446522_197393.875_00004808
+ARKitScenes_test Validation_42446522_197396.874_00004988
+ARKitScenes_test Validation_42446527_198633.848_00000481
+ARKitScenes_test Validation_42446527_198646.843_00001261
+ARKitScenes_test Validation_42446527_198667.851_00002522
+ARKitScenes_test Validation_42446527_198696.839_00004262
+ARKitScenes_test Validation_42446529_198739.838_00001093
+ARKitScenes_test Validation_42446529_198779.838_00003494
+ARKitScenes_test Validation_42446532_198859.939_00003140
+ARKitScenes_test Validation_42446532_198900.938_00005601
+ARKitScenes_test Validation_42446533_200400.295_00000415
+ARKitScenes_test Validation_42446533_200426.301_00001976
+ARKitScenes_test Validation_42446536_200466.901_00001375
+ARKitScenes_test Validation_42446536_200467.901_00001435
+ARKitScenes_test Validation_42446540_201470.345_00001171
+ARKitScenes_test Validation_42446540_201486.338_00002131
+ARKitScenes_test Validation_42446540_201487.338_00002191
+ARKitScenes_test Validation_42446540_201494.335_00002611
+ARKitScenes_test Validation_42446540_201498.350_00002852
+ARKitScenes_test Validation_42446540_201513.344_00003752
+ARKitScenes_test Validation_42446540_201518.342_00004052
+ARKitScenes_test Validation_42446540_201530.337_00004772
+ARKitScenes_test Validation_42446541_201561.441_00000823
+ARKitScenes_test Validation_42446541_201570.437_00001363
+ARKitScenes_test Validation_42446541_201594.444_00002804
+ARKitScenes_test Validation_42446541_201622.449_00004485
+ARKitScenes_test Validation_42446541_201644.440_00005805
+ARKitScenes_test Validation_42446541_201645.439_00005865
+ARKitScenes_test Validation_42446541_201665.448_00007066
+ARKitScenes_test Validation_42897501_270038.590_00001826
+ARKitScenes_test Validation_42897501_270046.587_00002306
+ARKitScenes_test Validation_42897501_270054.584_00002786
+ARKitScenes_test Validation_42897501_270057.583_00002966
+ARKitScenes_test Validation_42897501_270063.580_00003326
+ARKitScenes_test Validation_42897504_269851.484_00000559
+ARKitScenes_test Validation_42897504_269871.492_00001760
+ARKitScenes_test Validation_42897504_269876.490_00002060
+ARKitScenes_test Validation_42897504_269882.488_00002420
+ARKitScenes_test Validation_42897508_269924.104_00000104
+ARKitScenes_test Validation_42897508_269929.085_00000403
+ARKitScenes_test Validation_42897508_269938.082_00000943
+ARKitScenes_test Validation_42897508_269951.093_00001724
+ARKitScenes_test Validation_42897508_269954.092_00001904
+ARKitScenes_test Validation_42897508_269959.090_00002204
+ARKitScenes_test Validation_42897508_269964.088_00002504
+ARKitScenes_test Validation_42897508_269971.085_00002924
+ARKitScenes_test Validation_42897521_273955.896_00000181
+ARKitScenes_test Validation_42897521_273961.894_00000541
+ARKitScenes_test Validation_42897521_273987.900_00002102
+ARKitScenes_test Validation_42897526_273849.407_00000295
+ARKitScenes_test Validation_42897526_273883.393_00002335
+ARKitScenes_test Validation_42897526_273887.391_00002575
+ARKitScenes_test Validation_42897526_273889.390_00002695
+ARKitScenes_test Validation_42897528_273912.098_00000721
+ARKitScenes_test Validation_42897528_273918.095_00001081
+ARKitScenes_test Validation_42897542_275467.131_00000751
+ARKitScenes_test Validation_42897542_275474.128_00001171
+ARKitScenes_test Validation_42897542_275482.125_00001651
+ARKitScenes_test Validation_42897545_276443.861_00000342
+ARKitScenes_test Validation_42897549_276516.364_00001867
+ARKitScenes_test Validation_42897550_276550.167_00001057
+ARKitScenes_test Validation_42897552_277375.808_00001057
+ARKitScenes_test Validation_42897559_277439.598_00000541
+ARKitScenes_test Validation_42897559_277473.601_00002582
+ARKitScenes_test Validation_42897559_277476.600_00002762
+ARKitScenes_test Validation_42897559_277477.599_00002822
+ARKitScenes_test Validation_42897561_278935.714_00001459
+ARKitScenes_test Validation_42897561_278941.712_00001819
+ARKitScenes_test Validation_42897561_278944.711_00001999
+ARKitScenes_test Validation_42897561_278957.705_00002779
+ARKitScenes_test Validation_42897564_278991.308_00001237
+ARKitScenes_test Validation_42897564_279023.311_00003158
+ARKitScenes_test Validation_42897566_279059.013_00001196
+ARKitScenes_test Validation_42897566_279087.001_00002876
+ARKitScenes_test Validation_42897599_476337.198_00002149
+ARKitScenes_test Validation_42897599_476424.212_00007372
+ARKitScenes_test Validation_42897599_476451.201_00008992
+ARKitScenes_test Validation_42897599_476465.212_00009833
+ARKitScenes_test Validation_42897599_476473.209_00010313
+ARKitScenes_test Validation_42897599_476510.210_00012534
+ARKitScenes_test Validation_42897599_476511.210_00012594
+ARKitScenes_test Validation_42897599_476548.211_00014815
+ARKitScenes_test Validation_42897599_476553.209_00015115
+ARKitScenes_test Validation_42897599_476562.206_00015655
+ARKitScenes_test Validation_42897647_478138.188_00000523
+ARKitScenes_test Validation_42897647_478149.183_00001183
+ARKitScenes_test Validation_42897647_478150.183_00001243
+ARKitScenes_test Validation_42897647_478160.179_00001843
+ARKitScenes_test Validation_42897647_478167.176_00002263
+ARKitScenes_test Validation_42897647_478170.175_00002443
+ARKitScenes_test Validation_42897647_478208.176_00004724
+ARKitScenes_test Validation_42897647_478226.185_00005805
+ARKitScenes_test Validation_42897651_478328.276_00005036
+ARKitScenes_test Validation_42897651_478335.274_00005456
+ARKitScenes_test Validation_42897651_478342.287_00005877
+ARKitScenes_test Validation_42897651_478353.283_00006537
+ARKitScenes_test Validation_42897651_478356.282_00006717
+ARKitScenes_test Validation_42897651_478443.279_00011939
+ARKitScenes_test Validation_42897651_478480.280_00014160
+ARKitScenes_test Validation_42897651_478487.278_00014580
+ARKitScenes_test Validation_42897651_478519.281_00016501
+ARKitScenes_test Validation_42897651_478543.271_00017941
+ARKitScenes_test Validation_42897667_478004.076_00000456
+ARKitScenes_test Validation_42897667_478015.088_00001117
+ARKitScenes_test Validation_42897667_478031.082_00002077
+ARKitScenes_test Validation_42897667_478032.081_00002137
+ARKitScenes_test Validation_42897667_478033.081_00002197
+ARKitScenes_test Validation_42897667_478053.089_00003398
+ARKitScenes_test Validation_42897667_478083.077_00005198
+ARKitScenes_test Validation_42897667_478117.080_00007239
+ARKitScenes_test Validation_42897688_479183.081_00002377
+ARKitScenes_test Validation_42897688_479204.090_00003638
+ARKitScenes_test Validation_42897688_479223.082_00004778
+ARKitScenes_test Validation_42897688_479228.080_00005078
+ARKitScenes_test Validation_42897688_479253.086_00006579
+ARKitScenes_test Validation_42897688_479277.076_00008019
+ARKitScenes_test Validation_42897688_479292.087_00008920
+ARKitScenes_test Validation_42898811_167510.387_00002377
+ARKitScenes_test Validation_42898816_167394.902_00002504
+ARKitScenes_test Validation_42898818_168161.177_00000577
+ARKitScenes_test Validation_42898818_168172.172_00001237
+ARKitScenes_test Validation_42898818_168173.172_00001297
+ARKitScenes_test Validation_42898822_168209.574_00000277
+ARKitScenes_test Validation_42898822_168250.573_00002738
+ARKitScenes_test Validation_42898826_168118.178_00001243
+ARKitScenes_test Validation_42898826_168119.178_00001303
+ARKitScenes_test Validation_42898849_196459.913_00000877
+ARKitScenes_test Validation_42898849_196460.913_00000937
+ARKitScenes_test Validation_42898849_196468.926_00001418
+ARKitScenes_test Validation_42898849_196471.925_00001598
+ARKitScenes_test Validation_42898849_196503.912_00003518
+ARKitScenes_test Validation_42898849_196531.918_00005199
+ARKitScenes_test Validation_42898849_196542.913_00005859
+ARKitScenes_test Validation_42898849_196550.927_00006340
+ARKitScenes_test Validation_42898849_196566.921_00007300
+ARKitScenes_test Validation_42898849_196584.913_00008380
+ARKitScenes_test Validation_42898854_196220.724_00002288
+ARKitScenes_test Validation_42898854_196229.721_00002828
+ARKitScenes_test Validation_42898854_196233.719_00003068
+ARKitScenes_test Validation_42898854_196236.718_00003248
+ARKitScenes_test Validation_42898854_196266.723_00005049
+ARKitScenes_test Validation_42898854_196272.720_00005409
+ARKitScenes_test Validation_42898854_196274.720_00005529
+ARKitScenes_test Validation_42898854_196285.715_00006189
+ARKitScenes_test Validation_42898862_196315.720_00000271
+ARKitScenes_test Validation_42898862_196349.723_00002312
+ARKitScenes_test Validation_42898862_196366.716_00003332
+ARKitScenes_test Validation_42898862_196372.714_00003692
+ARKitScenes_test Validation_42898862_196375.713_00003872
+ARKitScenes_test Validation_42898862_196379.711_00004112
+ARKitScenes_test Validation_42898862_196388.724_00004653
+ARKitScenes_test Validation_42898862_196400.720_00005373
+ARKitScenes_test Validation_42898862_196401.719_00005433
+ARKitScenes_test Validation_42898862_196404.718_00005613
+ARKitScenes_test Validation_42898862_196405.718_00005673
+ARKitScenes_test Validation_42898862_196416.713_00006333
+ARKitScenes_test Validation_42898862_196426.726_00006934
+ARKitScenes_test Validation_42899461_195789.434_00000277
+ARKitScenes_test Validation_42899461_195799.430_00000877
+ARKitScenes_test Validation_42899461_195831.433_00002798
+ARKitScenes_test Validation_42899461_195850.425_00003938
+ARKitScenes_test Validation_42899461_195859.421_00004478
+ARKitScenes_test Validation_42899461_195866.418_00004898
+ARKitScenes_test Validation_42899471_195717.530_00003579
+ARKitScenes_test Validation_42899471_195718.530_00003639
+ARKitScenes_test Validation_42899611_228351.719_00000157
+ARKitScenes_test Validation_42899611_228363.714_00000877
+ARKitScenes_test Validation_42899611_228389.720_00002438
+ARKitScenes_test Validation_42899611_228392.719_00002618
+ARKitScenes_test Validation_42899611_228395.718_00002798
+ARKitScenes_test Validation_42899612_228436.519_00000649
+ARKitScenes_test Validation_42899612_228440.517_00000889
+ARKitScenes_test Validation_42899612_228494.512_00004130
+ARKitScenes_test Validation_42899612_228495.512_00004190
+ARKitScenes_test Validation_42899612_228504.525_00004731
+ARKitScenes_test Validation_42899612_228518.520_00005571
+ARKitScenes_test Validation_42899613_228276.016_00000222
+ARKitScenes_test Validation_42899613_228281.014_00000522
+ARKitScenes_test Validation_42899613_228313.018_00002443
+ARKitScenes_test Validation_42899613_228327.012_00003283
+ARKitScenes_test Validation_42899619_228891.872_00000217
+ARKitScenes_test Validation_42899619_228897.869_00000577
+ARKitScenes_test Validation_42899620_228853.670_00000397
+ARKitScenes_test Validation_42899620_228857.669_00000637
+ARKitScenes_test Validation_44358442_42920.105_00001784
+ARKitScenes_test Validation_44358446_43014.899_00000397
+ARKitScenes_test Validation_44358446_43015.898_00000457
+ARKitScenes_test Validation_44358446_43085.903_00004659
+ARKitScenes_test Validation_44358446_43089.901_00004899
+ARKitScenes_test Validation_44358446_43101.896_00005619
+ARKitScenes_test Validation_44358446_43119.889_00006699
+ARKitScenes_test Validation_44358448_42964.803_00000895
+ARKitScenes_test Validation_44358451_43632.897_00001658
+ARKitScenes_test Validation_44358451_43712.880_00006459
+ARKitScenes_test Validation_44358452_43503.584_00000216
+ARKitScenes_test Validation_44358452_43538.586_00002317
+ARKitScenes_test Validation_44358455_43441.293_00002858
+ARKitScenes_test Validation_44358455_43481.293_00005259
+ARKitScenes_test Validation_45260854_561.091_00000289
+ARKitScenes_test Validation_45260854_568.088_00000709
+ARKitScenes_test Validation_45260854_570.087_00000829
+ARKitScenes_test Validation_45260854_582.082_00001549
+ARKitScenes_test Validation_45260856_640.292_00000877
+ARKitScenes_test Validation_45260856_648.288_00001357
+ARKitScenes_test Validation_45260856_653.286_00001657
+ARKitScenes_test Validation_45260856_698.284_00004358
+ARKitScenes_test Validation_45260857_519.692_00001358
+ARKitScenes_test Validation_45260857_529.687_00001958
+ARKitScenes_test Validation_45260857_534.685_00002258
+ARKitScenes_test Validation_45260857_536.685_00002378
+ARKitScenes_test Validation_45260857_539.683_00002558
+ARKitScenes_test Validation_45260898_769.990_00000409
+ARKitScenes_test Validation_45260898_774.988_00000709
+ARKitScenes_test Validation_45260899_868.784_00001243
+ARKitScenes_test Validation_45260899_885.794_00002264
+ARKitScenes_test Validation_45260899_895.790_00002864
+ARKitScenes_test Validation_45260900_804.493_00000073
+ARKitScenes_test Validation_45260920_2471.417_00000288
+ARKitScenes_test Validation_45260920_2474.416_00000468
+ARKitScenes_test Validation_45260920_2494.425_00001669
+ARKitScenes_test Validation_45260920_2512.417_00002749
+ARKitScenes_test Validation_45260920_2535.425_00004130
+ARKitScenes_test Validation_45260925_2412.823_00001117
+ARKitScenes_test Validation_45260925_2424.819_00001837
+ARKitScenes_test Validation_45260925_2427.818_00002017
+ARKitScenes_test Validation_45260925_2454.824_00003638
+ARKitScenes_test Validation_45260928_2345.217_00000457
+ARKitScenes_test Validation_45260928_2362.227_00001478
+ARKitScenes_test Validation_45260928_2371.223_00002018
+ARKitScenes_test Validation_45261121_3447.063_00001994
+ARKitScenes_test Validation_45261121_3448.063_00002054
+ARKitScenes_test Validation_45261121_3454.060_00002414
+ARKitScenes_test Validation_45261121_3468.071_00003255
+ARKitScenes_test Validation_45261128_3526.164_00002198
+ARKitScenes_test Validation_45261128_3536.159_00002798
+ARKitScenes_test Validation_45261133_4030.272_00001417
+ARKitScenes_test Validation_45261133_4040.268_00002017
+ARKitScenes_test Validation_45261133_4047.265_00002437
+ARKitScenes_test Validation_45261133_4048.265_00002497
+ARKitScenes_test Validation_45261133_4050.264_00002617
+ARKitScenes_test Validation_45261133_4079.268_00004358
+ARKitScenes_test Validation_45261133_4080.268_00004418
+ARKitScenes_test Validation_45261133_4107.273_00006039
+ARKitScenes_test Validation_45261133_4116.270_00006579
+ARKitScenes_test Validation_45261133_4117.269_00006639
+ARKitScenes_test Validation_45261133_4126.266_00007179
+ARKitScenes_test Validation_45261133_4132.263_00007539
+ARKitScenes_test Validation_45261133_4136.261_00007779
+ARKitScenes_test Validation_45261133_4142.259_00008139
+ARKitScenes_test Validation_45261133_4148.256_00008499
+ARKitScenes_test Validation_45261140_3951.272_00000283
+ARKitScenes_test Validation_45261140_3960.268_00000823
+ARKitScenes_test Validation_45261140_3976.261_00001783
+ARKitScenes_test Validation_45261140_3978.260_00001903
+ARKitScenes_test Validation_45261142_3888.464_00000174
+ARKitScenes_test Validation_45261142_3896.461_00000654
+ARKitScenes_test Validation_45261143_4588.703_00000583
+ARKitScenes_test Validation_45261143_4592.701_00000823
+ARKitScenes_test Validation_45261143_4628.703_00002984
+ARKitScenes_test Validation_45261144_4658.007_00000457
+ARKitScenes_test Validation_45261150_4531.310_00000337
+ARKitScenes_test Validation_45261150_4535.308_00000577
+ARKitScenes_test Validation_45261150_4549.302_00001417
+ARKitScenes_test Validation_45261181_2852.026_00001537
+ARKitScenes_test Validation_45261182_2977.726_00003818
+ARKitScenes_test Validation_45261182_2994.736_00004839
+ARKitScenes_test Validation_45261185_3558.482_00000703
+ARKitScenes_test Validation_45261185_3559.481_00000763
+ARKitScenes_test Validation_45261185_3562.480_00000943
+ARKitScenes_test Validation_45261185_3601.481_00003284
+ARKitScenes_test Validation_45261190_3716.886_00001843
+ARKitScenes_test Validation_45261190_3743.892_00003464
+ARKitScenes_test Validation_45261193_3625.189_00000409
+ARKitScenes_test Validation_45261193_3632.186_00000829
+ARKitScenes_test Validation_45261193_3655.193_00002210
+ARKitScenes_test Validation_45261575_77474.508_00000337
+ARKitScenes_test Validation_45261575_77475.507_00000397
+ARKitScenes_test Validation_45261581_77518.506_00000157
+ARKitScenes_test Validation_45261581_77535.516_00001178
+ARKitScenes_test Validation_45261594_78039.207_00000637
+ARKitScenes_test Validation_45261615_55008.692_00000703
+ARKitScenes_test Validation_45261619_55088.693_00001436
+ARKitScenes_test Validation_45261619_55116.682_00003116
+ARKitScenes_test Validation_45261620_54934.288_00000157
+ARKitScenes_test Validation_45261631_56030.404_00000217
+ARKitScenes_test Validation_45261631_56068.389_00002497
+ARKitScenes_test Validation_45261631_56089.397_00003758
+ARKitScenes_test Validation_45261631_56092.396_00003938
+ARKitScenes_test Validation_45261631_56104.391_00004658
+ARKitScenes_test Validation_45261632_55892.192_00000138
+ARKitScenes_test Validation_45261637_55961.498_00000337
+ARKitScenes_test Validation_45261637_55962.497_00000397
+ARKitScenes_test Validation_45261637_55971.494_00000937
+ARKitScenes_test Validation_45662921_21784.929_00002048
+ARKitScenes_test Validation_45662921_21787.928_00002228
+ARKitScenes_test Validation_45662921_21791.926_00002468
+ARKitScenes_test Validation_45662921_21836.924_00005169
+ARKitScenes_test Validation_45662924_21592.925_00002258
+ARKitScenes_test Validation_45662924_21607.919_00003158
+ARKitScenes_test Validation_45662924_21609.918_00003278
+ARKitScenes_test Validation_45662926_21649.319_00000667
+ARKitScenes_test Validation_45662926_21659.331_00001268
+ARKitScenes_test Validation_45662926_21670.326_00001928
+ARKitScenes_test Validation_45662926_21674.325_00002168
+ARKitScenes_test Validation_45662926_21675.324_00002228
+ARKitScenes_test Validation_45662926_21682.322_00002648
+ARKitScenes_test Validation_45662926_21684.321_00002768
+ARKitScenes_test Validation_45662926_21688.319_00003008
+ARKitScenes_test Validation_45662926_21692.317_00003248
+ARKitScenes_test Validation_45662926_21693.317_00003308
+ARKitScenes_test Validation_45662926_21694.317_00003368
+ARKitScenes_test Validation_45662926_21711.326_00004389
+ARKitScenes_test Validation_45662926_21715.324_00004629
+ARKitScenes_test Validation_45662942_22918.660_00002197
+ARKitScenes_test Validation_45662943_23032.263_00000817
+ARKitScenes_test Validation_45662943_23164.258_00008740
+ARKitScenes_test Validation_45662943_23168.256_00008980
+ARKitScenes_test Validation_45662943_23170.255_00009100
+ARKitScenes_test Validation_45662943_23171.255_00009160
+ARKitScenes_test Validation_45662943_23174.254_00009340
+ARKitScenes_test Validation_45662943_23175.253_00009400
+ARKitScenes_test Validation_45662943_23179.268_00009641
+ARKitScenes_test Validation_45662943_23183.267_00009881
+ARKitScenes_test Validation_45662943_23208.256_00011381
+ARKitScenes_test Validation_45662944_22963.758_00001297
+ARKitScenes_test Validation_45662944_22974.770_00001958
+ARKitScenes_test Validation_45662970_26159.531_00003188
+ARKitScenes_test Validation_45662979_26048.725_00001177
+ARKitScenes_test Validation_45662981_27937.116_00000050
+ARKitScenes_test Validation_45662981_27946.096_00000589
+ARKitScenes_test Validation_45662981_27994.094_00003470
+ARKitScenes_test Validation_45662981_28029.097_00005571
+ARKitScenes_test Validation_45662983_27801.886_00000337
+ARKitScenes_test Validation_45662983_27805.885_00000577
+ARKitScenes_test Validation_45662983_27807.884_00000697
+ARKitScenes_test Validation_45662983_27851.883_00003338
+ARKitScenes_test Validation_45662983_27854.882_00003518
+ARKitScenes_test Validation_45662987_27869.193_00000169
+ARKitScenes_test Validation_45662987_27878.190_00000709
+ARKitScenes_test Validation_45662987_27883.188_00001009
+ARKitScenes_test Validation_45662987_27910.194_00002630
+ARKitScenes_test Validation_45662987_27911.193_00002690
+ARKitScenes_test Validation_45663113_55308.661_00000277
+ARKitScenes_test Validation_45663113_55324.671_00001238
+ARKitScenes_test Validation_45663113_55326.671_00001358
+ARKitScenes_test Validation_45663114_55386.862_00000637
+ARKitScenes_test Validation_45663114_55404.855_00001717
+ARKitScenes_test Validation_45663115_55461.865_00001958
+ARKitScenes_test Validation_45663149_63304.709_00000517
+ARKitScenes_test Validation_45663149_63311.706_00000937
+ARKitScenes_test Validation_45663149_63314.705_00001117
+ARKitScenes_test Validation_45663149_63315.705_00001177
+ARKitScenes_test Validation_45663149_63324.701_00001717
+ARKitScenes_test Validation_45663150_63511.952_00000288
+ARKitScenes_test Validation_45663150_63551.953_00002689
+ARKitScenes_test Validation_45663154_63399.880_00000074
+ARKitScenes_test Validation_45663154_63401.862_00000193
+ARKitScenes_test Validation_45663154_63409.859_00000673
+ARKitScenes_test Validation_45663154_63411.858_00000793
+ARKitScenes_test Validation_45663154_63450.860_00003134
+ARKitScenes_test Validation_45663164_65947.828_00001015
+ARKitScenes_test Validation_45663164_65948.828_00001075
+ARKitScenes_test Validation_45663164_65968.820_00002275
+ARKitScenes_test Validation_45663164_65975.817_00002695
+ARKitScenes_test Validation_45663164_65997.825_00004016
+ARKitScenes_test Validation_45663165_65815.014_00000637
+ARKitScenes_test Validation_45663175_65890.618_00001153
+ARKitScenes_test Validation_45663175_65891.617_00001213
+ARKitScenes_test Validation_45663175_65912.625_00002474
+ARKitScenes_test Validation_45663175_65919.623_00002894
+ARKitScenes_test Validation_47115452_13057.568_00000097
+ARKitScenes_test Validation_47115452_13076.576_00001238
+ARKitScenes_test Validation_47115460_13145.781_00000529
+ARKitScenes_test Validation_47115460_13166.772_00001789
+ARKitScenes_test Validation_47115463_13220.467_00000096
+ARKitScenes_test Validation_47115463_13235.477_00000997
+ARKitScenes_test Validation_47115463_13282.474_00003818
+ARKitScenes_test Validation_47115469_14055.292_00002678
+ARKitScenes_test Validation_47115469_14059.290_00002918
+ARKitScenes_test Validation_47115473_14107.787_00002150
+ARKitScenes_test Validation_47115473_14172.776_00006051
+ARKitScenes_test Validation_47115474_13966.678_00000402
+ARKitScenes_test Validation_47115474_13976.691_00001003
+ARKitScenes_test Validation_47204552_3357.092_00000277
+ARKitScenes_test Validation_47204552_3378.100_00001538
+ARKitScenes_test Validation_47204552_3391.095_00002318
+ARKitScenes_test Validation_47204552_3412.086_00003578
+ARKitScenes_test Validation_47204552_3425.097_00004359
+ARKitScenes_test Validation_47204552_3430.095_00004659
+ARKitScenes_test Validation_47204552_3441.091_00005319
+ARKitScenes_test Validation_47204552_3485.089_00007960
+ARKitScenes_test Validation_47204552_3486.089_00008020
+ARKitScenes_test Validation_47204554_3215.201_00000277
+ARKitScenes_test Validation_47204554_3227.196_00000997
+ARKitScenes_test Validation_47204554_3240.191_00001777
+ARKitScenes_test Validation_47204554_3244.189_00002017
+ARKitScenes_test Validation_47204554_3261.199_00003038
+ARKitScenes_test Validation_47204554_3263.198_00003158
+ARKitScenes_test Validation_47204554_3265.197_00003278
+ARKitScenes_test Validation_47204554_3269.195_00003518
+ARKitScenes_test Validation_47204556_3286.405_00000037
+ARKitScenes_test Validation_47204556_3312.394_00001597
+ARKitScenes_test Validation_47204559_3992.536_00000276
+ARKitScenes_test Validation_47204559_4001.549_00000817
+ARKitScenes_test Validation_47204563_4044.448_00000697
+ARKitScenes_test Validation_47204566_4109.038_00002017
+ARKitScenes_test Validation_47204566_4118.051_00002558
+ARKitScenes_test Validation_47204573_5014.617_00003459
+ARKitScenes_test Validation_47204573_5039.606_00004959
+ARKitScenes_test Validation_47204573_5046.620_00005380
+ARKitScenes_test Validation_47204578_4918.223_00001484
+ARKitScenes_test Validation_47204605_2434.303_00001922
+ARKitScenes_test Validation_47204607_2521.802_00000097
+ARKitScenes_test Validation_47204607_2522.802_00000157
+ARKitScenes_test Validation_47204607_2523.801_00000217
+ARKitScenes_test Validation_47204607_2554.806_00002078
+ARKitScenes_test Validation_47204607_2590.791_00004238
+ARKitScenes_test Validation_47204607_2635.790_00006939
+ARKitScenes_test Validation_47204607_2676.791_00009400
+ARKitScenes_test Validation_47204607_2677.790_00009460
+ARKitScenes_test Validation_47204609_2459.993_00000457
+ARKitScenes_test Validation_47204609_2462.992_00000637
+ARKitScenes_test Validation_47331068_131079.065_00000877
+ARKitScenes_test Validation_47331071_131004.361_00000637
+ARKitScenes_test Validation_47331265_90018.298_00000433
+ARKitScenes_test Validation_47331265_90026.295_00000913
+ARKitScenes_test Validation_47331266_89826.492_00000319
+ARKitScenes_test Validation_47331266_89870.491_00002960
+ARKitScenes_test Validation_47331266_89893.499_00004341
+ARKitScenes_test Validation_47331319_179047.025_00000654
+ARKitScenes_test Validation_47331322_179161.329_00002870
+ARKitScenes_test Validation_47331337_183502.425_00001897
+ARKitScenes_test Validation_47331339_183421.825_00001579
+ARKitScenes_test Validation_47331339_183426.823_00001879
+ARKitScenes_test Validation_47331651_22884.238_00002078
+ARKitScenes_test Validation_47331651_22902.231_00003158
+ARKitScenes_test Validation_47331651_22903.230_00003218
+ARKitScenes_test Validation_47331651_22905.230_00003338
+ARKitScenes_test Validation_47331651_22921.223_00004298
+ARKitScenes_test Validation_47331651_22924.239_00004479
+ARKitScenes_test Validation_47331651_22928.237_00004719
+ARKitScenes_test Validation_47331651_22930.236_00004839
+ARKitScenes_test Validation_47331651_22939.232_00005379
+ARKitScenes_test Validation_47331651_22947.229_00005859
+ARKitScenes_test Validation_47331651_22971.236_00007300
+ARKitScenes_test Validation_47331651_22972.236_00007360
+ARKitScenes_test Validation_47331653_22994.327_00000577
+ARKitScenes_test Validation_47331653_23001.324_00000997
+ARKitScenes_test Validation_47331653_23054.335_00004179
+ARKitScenes_test Validation_47331653_23064.331_00004779
+ARKitScenes_test Validation_47331653_23111.329_00007600
+ARKitScenes_test Validation_47331653_23114.328_00007780
+ARKitScenes_test Validation_47331653_23127.322_00008560
+ARKitScenes_test Validation_47331653_23133.336_00008921
+ARKitScenes_test Validation_47331653_23134.336_00008981
+ARKitScenes_test Validation_47331654_22743.829_00000457
+ARKitScenes_test Validation_47331654_22785.828_00002978
+ARKitScenes_test Validation_47331654_22786.828_00003038
+ARKitScenes_test Validation_47331654_22832.826_00005799
+ARKitScenes_test Validation_47331661_23633.580_00002870
+ARKitScenes_test Validation_47331661_23643.593_00003471
+ARKitScenes_test Validation_47331661_23644.592_00003531
+ARKitScenes_test Validation_47331661_23685.592_00005992
+ARKitScenes_test Validation_47331661_23688.591_00006172
+ARKitScenes_test Validation_47331661_23699.587_00006832
+ARKitScenes_test Validation_47331661_23720.578_00008092
+ARKitScenes_test Validation_47331662_23462.083_00002497
+ARKitScenes_test Validation_47331662_23468.081_00002857
+ARKitScenes_test Validation_47331662_23469.080_00002917
+ARKitScenes_test Validation_47331662_23485.091_00003878
+ARKitScenes_test Validation_47331662_23488.089_00004058
+ARKitScenes_test Validation_47331988_170632.558_00002264
+ARKitScenes_test Validation_47331988_170653.550_00003524
+ARKitScenes_test Validation_47331988_170659.548_00003884
+ARKitScenes_test Validation_47331988_170749.561_00009287
+ARKitScenes_test Validation_47331989_170421.860_00000457
+ARKitScenes_test Validation_47331989_170455.863_00002498
+ARKitScenes_test Validation_47331990_170521.953_00002509
+ARKitScenes_test Validation_47331990_170525.952_00002749
+ARKitScenes_test Validation_47331990_170549.959_00004190
+ARKitScenes_test Validation_47331990_170558.955_00004730
+ARKitScenes_test Validation_47332005_172103.731_00002443
+ARKitScenes_test Validation_47332005_172170.737_00006465
+ARKitScenes_test Validation_47332885_7493.862_00000583
+ARKitScenes_test Validation_47332886_7578.261_00002215
+ARKitScenes_test Validation_47332890_7645.367_00002918
+ARKitScenes_test Validation_47332890_7647.366_00003038
+ARKitScenes_test Validation_47332890_7669.357_00004358
+ARKitScenes_test Validation_47332895_9056.792_00000655
+ARKitScenes_test Validation_47332899_9178.193_00003548
+ARKitScenes_test Validation_47332901_11035.593_00001165
+ARKitScenes_test Validation_47332901_11041.590_00001525
+ARKitScenes_test Validation_47332901_11042.590_00001585
+ARKitScenes_test Validation_47332904_11139.400_00003705
+ARKitScenes_test Validation_47332904_11147.397_00004185
+ARKitScenes_test Validation_47332905_10983.897_00002030
+ARKitScenes_test Validation_47332910_12199.324_00000768
+ARKitScenes_test Validation_47332910_12253.336_00004010
+ARKitScenes_test Validation_47332911_12284.823_00001543
+ARKitScenes_test Validation_47332911_12350.829_00005505
+ARKitScenes_test Validation_47332915_13471.971_00000343
+ARKitScenes_test Validation_47332915_13507.973_00002504
+ARKitScenes_test Validation_47332915_13543.975_00004665
+ARKitScenes_test Validation_47332916_13398.568_00000475
+ARKitScenes_test Validation_47332918_13325.864_00000589
+ARKitScenes_test Validation_47332918_13336.876_00001250
+ARKitScenes_test Validation_47332918_13368.863_00003170
+ARKitScenes_test Validation_47333440_53804.226_00000637
+ARKitScenes_test Validation_47333440_53839.228_00002738
+ARKitScenes_test Validation_47333441_53869.716_00001117
+ARKitScenes_test Validation_47333443_53783.118_00002077
+ARKitScenes_test Validation_47333443_53784.117_00002137
+ARKitScenes_test Validation_47333452_54954.122_00000157
+ARKitScenes_test Validation_47333452_54987.208_00002143
+ARKitScenes_test Validation_47333456_55036.122_00001718
+ARKitScenes_test Validation_47333898_81373.971_00003278
+ARKitScenes_test Validation_47333899_81292.071_00003098
+ARKitScenes_test Validation_47333904_81413.372_00000697
+ARKitScenes_test Validation_47333904_81420.369_00001117
+ARKitScenes_test Validation_47333904_81424.367_00001357
+ARKitScenes_test Validation_47333904_81426.367_00001477
+ARKitScenes_test Validation_47333904_81435.363_00002017
+ARKitScenes_test Validation_47333904_81443.376_00002498
+ARKitScenes_test Validation_47333904_81444.376_00002558
+ARKitScenes_test Validation_47333916_82429.566_00003699
+ARKitScenes_test Validation_47333916_82433.564_00003939
+ARKitScenes_test Validation_47333918_82508.450_00003163
+ARKitScenes_test Validation_47333918_82513.465_00003464
+ARKitScenes_test Validation_47333920_82646.261_00006096
+ARKitScenes_test Validation_47333920_82649.260_00006276
+ARKitScenes_test Validation_47333920_82658.256_00006816
+ARKitScenes_test Validation_47333920_82663.254_00007116
+ARKitScenes_test Validation_47333923_83608.499_00000636
+ARKitScenes_test Validation_47333923_83645.501_00002857
+ARKitScenes_test Validation_47333924_83693.915_00002078
+ARKitScenes_test Validation_47333925_83549.606_00000523
+ARKitScenes_test Validation_47333925_83550.606_00000583
+ARKitScenes_test Validation_47333925_83581.610_00002444
+ARKitScenes_test Validation_47333927_84003.213_00000824
+ARKitScenes_test Validation_47333927_84012.209_00001364
+ARKitScenes_test Validation_47333931_83942.704_00001778
+ARKitScenes_test Validation_47333932_84111.202_00002918
+ARKitScenes_test Validation_47333932_84112.202_00002978
+ARKitScenes_test Validation_47333932_84125.196_00003758
+ARKitScenes_test Validation_47333932_84183.206_00007240
+ARKitScenes_test Validation_47333934_85569.766_00001249
+ARKitScenes_test Validation_47333934_85621.762_00004370
+ARKitScenes_test Validation_47333934_85645.769_00005811
+ARKitScenes_test Validation_47333934_85655.765_00006411
+ARKitScenes_test Validation_47333934_85660.763_00006711
+ARKitScenes_test Validation_47333937_85506.376_00001021
+ARKitScenes_test Validation_47333937_85512.373_00001381
+ARKitScenes_test Validation_47333940_85460.977_00003038
+ARKitScenes_test Validation_47333940_85482.968_00004358
+ARKitScenes_test Validation_47334105_92895.748_00000769
+ARKitScenes_test Validation_47334105_92897.747_00000889
+ARKitScenes_test Validation_47334105_92903.744_00001249
+ARKitScenes_test Validation_47334105_92922.753_00002390
+ARKitScenes_test Validation_47334105_92946.744_00003830
+ARKitScenes_test Validation_47334105_92951.758_00004131
+ARKitScenes_test Validation_47334105_92954.757_00004311
+ARKitScenes_test Validation_47334105_92986.744_00006231
+ARKitScenes_test Validation_47334105_92990.759_00006472
+ARKitScenes_test Validation_47334105_93022.746_00008392
+ARKitScenes_test Validation_47334105_93029.743_00008812
+ARKitScenes_test Validation_47334239_111112.020_00000517
+ARKitScenes_test Validation_47334239_111149.022_00002738
+ARKitScenes_test Validation_47334240_111193.421_00002017
+ARKitScenes_test Validation_47334240_111214.429_00003278
+ARKitScenes_test Validation_47334256_112032.695_00002258
+ARKitScenes_test Validation_47334256_112063.700_00004119
+ARKitScenes_test Validation_47334256_112064.699_00004179
+ARKitScenes_test Validation_47334256_112065.699_00004239
+ARKitScenes_test Validation_47429922_136624.256_00000517
+ARKitScenes_test Validation_47429922_136657.242_00002497
+ARKitScenes_test Validation_47429971_16349.760_00004238
+ARKitScenes_test Validation_47430002_17171.758_00000277
+ARKitScenes_test Validation_47430005_17517.360_00000276
+ARKitScenes_test Validation_47430005_17532.371_00001177
+ARKitScenes_test Validation_47430023_18906.937_00002864
+ARKitScenes_test Validation_47430033_19414.387_00000403
+ARKitScenes_test Validation_47430038_20536.784_00000216
+ARKitScenes_test Validation_47430043_20606.288_00001717
+ARKitScenes_test Validation_47430047_21122.842_00001898
+ARKitScenes_test Validation_47895341_96403.324_00001057
+ARKitScenes_test Validation_47895341_96411.321_00001537
+ARKitScenes_test Validation_47895348_96488.523_00001777
+ARKitScenes_test Validation_47895348_96538.520_00004778
+ARKitScenes_test Validation_47895350_96557.812_00000396
+ARKitScenes_test Validation_47895350_96559.828_00000517
+ARKitScenes_test Validation_47895350_96571.823_00001237
+ARKitScenes_test Validation_47895350_96604.826_00003218
+ARKitScenes_test Validation_47895350_96610.824_00003578
+ARKitScenes_test Validation_47895350_96621.819_00004238
+ARKitScenes_test Validation_47895350_96646.826_00005739
+ARKitScenes_test Validation_47895350_96659.821_00006519
+ARKitScenes_test Validation_47895350_96663.819_00006759
+ARKitScenes_test Validation_47895350_96730.825_00010781
+ARKitScenes_test Validation_47895355_98775.628_00001297
+ARKitScenes_test Validation_47895355_98788.639_00002078
+ARKitScenes_test Validation_47895355_98796.636_00002558
+ARKitScenes_test Validation_47895355_98810.630_00003398
+ARKitScenes_test Validation_47895355_98823.642_00004179
+ARKitScenes_test Validation_47895355_98827.640_00004419
+ARKitScenes_test Validation_47895355_98906.624_00009160
+ARKitScenes_test Validation_47895355_98910.639_00009401
+ARKitScenes_test Validation_47895355_98929.632_00010541
+ARKitScenes_test Validation_47895355_98943.626_00011381
+ARKitScenes_test Validation_47895355_98966.633_00012762
+ARKitScenes_test Validation_47895364_100221.941_00003158
+ARKitScenes_test Validation_47895364_100251.946_00004959
+ARKitScenes_test Validation_47895364_100287.931_00007119
+ARKitScenes_test Validation_47895364_100307.940_00008320
+ARKitScenes_test Validation_48018367_389452.575_00000457
+ARKitScenes_test Validation_48018367_389473.583_00001718
+ARKitScenes_test Validation_48018368_389553.283_00001190
+ARKitScenes_test Validation_48018368_389572.275_00002330
+ARKitScenes_test Validation_48018368_389581.271_00002870
+ARKitScenes_test Validation_48018372_389531.675_00002498
+ARKitScenes_test Validation_48018379_390040.136_00002678
+ARKitScenes_test Validation_48018559_3346.848_00000337
+ARKitScenes_test Validation_48018566_3858.438_00000103
+ARKitScenes_test Validation_48018571_3905.036_00000439
+ARKitScenes_test Validation_48018572_3798.046_00000128
+ARKitScenes_test Validation_48018572_3810.041_00000848
+ARKitScenes_test Validation_48018730_1678.470_00000637
+ARKitScenes_test Validation_48018730_1723.469_00003338
+ARKitScenes_test Validation_48018730_1769.467_00006099
+ARKitScenes_test Validation_48018732_1939.564_00001759
+ARKitScenes_test Validation_48018732_1942.563_00001939
+ARKitScenes_test Validation_48018732_1945.579_00002120
+ARKitScenes_test Validation_48018732_1948.577_00002300
+ARKitScenes_test Validation_48018732_1953.575_00002600
+ARKitScenes_test Validation_48018741_3393.825_00000337
+ARKitScenes_test Validation_48458481_111522.301_00001117
+ARKitScenes_test Validation_48458484_111590.308_00001237
+ARKitScenes_test Validation_48458489_111549.307_00000703
+ARKitScenes_test Validation_48458489_111557.304_00001183
+ARKitScenes_test Validation_48458650_7066.602_00000456
+ARKitScenes_test Validation_48458650_7068.601_00000576
+ARKitScenes_test Validation_48458650_7070.617_00000697
+ARKitScenes_test Validation_48458650_7071.617_00000757
+ARKitScenes_test Validation_48458656_7661.589_00002077
+ARKitScenes_test Validation_48458656_7663.589_00002197
+ARKitScenes_test Validation_48458656_7667.587_00002437
+ARKitScenes_test Validation_48458656_7672.585_00002737
+ARKitScenes_test Validation_48458657_7617.691_00002023
+ARKitScenes_test Validation_48458660_8270.961_00001658
+ARKitScenes_test Validation_48458667_8365.655_00000637
+ARKitScenes_test Validation_48458667_8367.654_00000757
+ARKitScenes_test Validation_48458667_8376.651_00001297
+ARKitScenes_test Validation_48458667_8395.660_00002438

external/WildCamera/splits/biwirgbdid_test.txt

@@ -0,0 +1,800 @@
+BIWIRGBDID Testing_Still_000_000a_000018-a_111628807_rgb
+BIWIRGBDID Testing_Still_000_000a_000019-a_111628891_rgb
+BIWIRGBDID Testing_Still_000_000a_000124-a_111639723_rgb
+BIWIRGBDID Testing_Still_000_000a_000157-a_111643139_rgb
+BIWIRGBDID Testing_Still_000_000a_000179-a_111645307_rgb
+BIWIRGBDID Testing_Still_000_000a_000183-a_111645807_rgb
+BIWIRGBDID Testing_Still_000_000a_000195-a_111647059_rgb
+BIWIRGBDID Testing_Still_000_000a_000200-a_111647559_rgb
+BIWIRGBDID Testing_Still_001_001a_000022-a_106257171_rgb
+BIWIRGBDID Testing_Still_001_001a_000039-a_106258923_rgb
+BIWIRGBDID Testing_Still_001_001a_000056-a_106260671_rgb
+BIWIRGBDID Testing_Still_001_001a_000090-a_106264423_rgb
+BIWIRGBDID Testing_Still_001_001a_000099-a_106265423_rgb
+BIWIRGBDID Testing_Still_001_001a_000117-a_106267255_rgb
+BIWIRGBDID Testing_Still_001_001a_000145-a_106270255_rgb
+BIWIRGBDID Testing_Still_001_001a_000157-a_106271503_rgb
+BIWIRGBDID Testing_Still_002_002a_000016-a_1232924843_rgb
+BIWIRGBDID Testing_Still_002_002a_000025-a_1232925843_rgb
+BIWIRGBDID Testing_Still_002_002a_000035-a_1232926927_rgb
+BIWIRGBDID Testing_Still_002_002a_000069-a_1232930595_rgb
+BIWIRGBDID Testing_Still_002_002a_000088-a_1232932679_rgb
+BIWIRGBDID Testing_Still_002_002a_000089-a_1232932759_rgb
+BIWIRGBDID Testing_Still_002_002a_000092-a_1232933095_rgb
+BIWIRGBDID Testing_Still_002_002a_000094-a_1232933259_rgb
+BIWIRGBDID Testing_Still_002_002a_000123-a_1232936595_rgb
+BIWIRGBDID Testing_Still_002_002a_000130-a_1232937342_rgb
+BIWIRGBDID Testing_Still_002_002a_000141-a_1232938510_rgb
+BIWIRGBDID Testing_Still_002_002a_000143-a_1232938759_rgb
+BIWIRGBDID Testing_Still_002_002a_000146-a_1232939010_rgb
+BIWIRGBDID Testing_Still_003_003a_000006-a_621308413_rgb
+BIWIRGBDID Testing_Still_003_003a_000007-a_621308581_rgb
+BIWIRGBDID Testing_Still_003_003a_000033-a_621311497_rgb
+BIWIRGBDID Testing_Still_003_003a_000050-a_621313413_rgb
+BIWIRGBDID Testing_Still_003_003a_000110-a_621320413_rgb
+BIWIRGBDID Testing_Still_003_003a_000141-a_621324749_rgb
+BIWIRGBDID Testing_Still_006_006a_000000-a_1224024579_rgb
+BIWIRGBDID Testing_Still_006_006a_000002-a_1224024747_rgb
+BIWIRGBDID Testing_Still_006_006a_000034-a_1224028080_rgb
+BIWIRGBDID Testing_Still_006_006a_000055-a_1224030247_rgb
+BIWIRGBDID Testing_Still_006_006a_000070-a_1224031831_rgb
+BIWIRGBDID Testing_Still_006_006a_000089-a_1224033747_rgb
+BIWIRGBDID Testing_Still_006_006a_000092-a_1224034079_rgb
+BIWIRGBDID Testing_Still_006_006a_000098-a_1224034663_rgb
+BIWIRGBDID Testing_Still_006_006a_000106-a_1224035495_rgb
+BIWIRGBDID Testing_Still_006_006a_000122-a_1224037163_rgb
+BIWIRGBDID Testing_Still_006_006a_000124-a_1224037331_rgb
+BIWIRGBDID Testing_Still_006_006a_000139-a_1224038911_rgb
+BIWIRGBDID Testing_Still_006_006a_000151-a_1224040163_rgb
+BIWIRGBDID Testing_Still_008_008a_000014-a_190303117_rgb
+BIWIRGBDID Testing_Still_008_008a_000029-a_190304618_rgb
+BIWIRGBDID Testing_Still_008_008a_000073-a_190309201_rgb
+BIWIRGBDID Testing_Still_008_008a_000092-a_190311285_rgb
+BIWIRGBDID Testing_Still_008_008a_000116-a_190313701_rgb
+BIWIRGBDID Testing_Still_008_008a_000125-a_190314617_rgb
+BIWIRGBDID Testing_Still_010_010a_000005-a_171989565_rgb
+BIWIRGBDID Testing_Still_010_010a_000019-a_171990981_rgb
+BIWIRGBDID Testing_Still_010_010a_000021-a_171991229_rgb
+BIWIRGBDID Testing_Still_010_010a_000054-a_171994564_rgb
+BIWIRGBDID Testing_Still_010_010a_000063-a_171995649_rgb
+BIWIRGBDID Testing_Still_010_010a_000072-a_171996480_rgb
+BIWIRGBDID Testing_Still_010_010a_000085-a_171997897_rgb
+BIWIRGBDID Testing_Still_010_010a_000087-a_171998064_rgb
+BIWIRGBDID Testing_Still_010_010a_000098-a_171999229_rgb
+BIWIRGBDID Testing_Still_010_010a_000107-a_172000148_rgb
+BIWIRGBDID Testing_Still_010_010a_000119-a_172001396_rgb
+BIWIRGBDID Testing_Still_011_011a_000023-a_200194778_rgb
+BIWIRGBDID Testing_Still_011_011a_000088-a_200201941_rgb
+BIWIRGBDID Testing_Still_011_011a_000101-a_200203442_rgb
+BIWIRGBDID Testing_Still_011_011a_000104-a_200203778_rgb
+BIWIRGBDID Testing_Still_011_011a_000116-a_200205277_rgb
+BIWIRGBDID Testing_Still_016_016a_000000-a_188165678_rgb
+BIWIRGBDID Testing_Still_016_016a_000026-a_188168426_rgb
+BIWIRGBDID Testing_Still_016_016a_000043-a_188170258_rgb
+BIWIRGBDID Testing_Still_016_016a_000052-a_188171178_rgb
+BIWIRGBDID Testing_Still_016_016a_000114-a_188177758_rgb
+BIWIRGBDID Testing_Still_017_017a_000004-a_191551441_rgb
+BIWIRGBDID Testing_Still_017_017a_000050-a_191556773_rgb
+BIWIRGBDID Testing_Still_017_017a_000055-a_191557272_rgb
+BIWIRGBDID Testing_Still_017_017a_000059-a_191557688_rgb
+BIWIRGBDID Testing_Still_017_017a_000073-a_191559189_rgb
+BIWIRGBDID Testing_Still_017_017a_000099-a_191562440_rgb
+BIWIRGBDID Testing_Still_017_017a_000102-a_191562688_rgb
+BIWIRGBDID Testing_Still_017_017a_000103-a_191562772_rgb
+BIWIRGBDID Testing_Still_017_017a_000122-a_191564772_rgb
+BIWIRGBDID Testing_Still_019_019a_000024-a_107178865_rgb
+BIWIRGBDID Testing_Still_019_019a_000081-a_107184780_rgb
+BIWIRGBDID Testing_Still_019_019a_000086-a_107185364_rgb
+BIWIRGBDID Testing_Still_021_021a_000028-a_109006730_rgb
+BIWIRGBDID Testing_Still_021_021a_000081-a_109012398_rgb
+BIWIRGBDID Testing_Still_021_021a_000084-a_109012646_rgb
+BIWIRGBDID Testing_Still_021_021a_000100-a_109014314_rgb
+BIWIRGBDID Testing_Still_021_021a_000117-a_109016062_rgb
+BIWIRGBDID Testing_Still_021_021a_000137-a_109018146_rgb
+BIWIRGBDID Testing_Still_022_022a_000052-a_1214872830_rgb
+BIWIRGBDID Testing_Still_022_022a_000053-a_1214872914_rgb
+BIWIRGBDID Testing_Still_022_022a_000072-a_1214875162_rgb
+BIWIRGBDID Testing_Still_023_023a_000003-a_197683355_rgb
+BIWIRGBDID Testing_Still_023_023a_000012-a_197684603_rgb
+BIWIRGBDID Testing_Still_023_023a_000024-a_197686103_rgb
+BIWIRGBDID Testing_Still_023_023a_000027-a_197686523_rgb
+BIWIRGBDID Testing_Still_023_023a_000096-a_197695603_rgb
+BIWIRGBDID Testing_Still_023_023a_000128-a_197699687_rgb
+BIWIRGBDID Testing_Still_023_023a_000138-a_197700939_rgb
+BIWIRGBDID Testing_Still_024_024a_000027-a_197310296_rgb
+BIWIRGBDID Testing_Still_024_024a_000033-a_197311045_rgb
+BIWIRGBDID Testing_Still_024_024a_000046-a_197312628_rgb
+BIWIRGBDID Testing_Still_024_024a_000054-a_197313712_rgb
+BIWIRGBDID Testing_Still_024_024a_000076-a_197316628_rgb
+BIWIRGBDID Testing_Still_024_024a_000093-a_197319128_rgb
+BIWIRGBDID Testing_Still_026_026a_000001-a_110999274_rgb
+BIWIRGBDID Testing_Still_026_026a_000003-a_110999522_rgb
+BIWIRGBDID Testing_Still_026_026a_000017-a_111001106_rgb
+BIWIRGBDID Testing_Still_026_026a_000027-a_111002106_rgb
+BIWIRGBDID Testing_Still_026_026a_000029-a_111002354_rgb
+BIWIRGBDID Testing_Still_026_026a_000072-a_111007106_rgb
+BIWIRGBDID Testing_Still_026_026a_000077-a_111007606_rgb
+BIWIRGBDID Testing_Still_026_026a_000110-a_111011022_rgb
+BIWIRGBDID Testing_Still_026_026a_000112-a_111011270_rgb
+BIWIRGBDID Testing_Still_027_027a_000012-a_111337418_rgb
+BIWIRGBDID Testing_Still_027_027a_000018-a_111338086_rgb
+BIWIRGBDID Testing_Still_027_027a_000031-a_111339750_rgb
+BIWIRGBDID Testing_Still_027_027a_000033-a_111339918_rgb
+BIWIRGBDID Testing_Still_027_027a_000044-a_111341169_rgb
+BIWIRGBDID Testing_Still_027_027a_000045-a_111341333_rgb
+BIWIRGBDID Testing_Still_027_027a_000119-a_111349249_rgb
+BIWIRGBDID Testing_Still_027_027a_000134-a_111350917_rgb
+BIWIRGBDID Testing_Still_027_027a_000142-a_111351749_rgb
+BIWIRGBDID Testing_Still_030_030a_000012-a_1233788639_rgb
+BIWIRGBDID Testing_Still_030_030a_000043-a_1233791891_rgb
+BIWIRGBDID Testing_Still_030_030a_000072-a_1233795471_rgb
+BIWIRGBDID Testing_Still_030_030a_000091-a_1233797723_rgb
+BIWIRGBDID Testing_Still_030_030a_000096-a_1233798307_rgb
+BIWIRGBDID Testing_Still_030_030a_000107-a_1233799471_rgb
+BIWIRGBDID Testing_Still_030_030a_000120-a_1233800971_rgb
+BIWIRGBDID Testing_Still_030_030a_000127-a_1233801807_rgb
+BIWIRGBDID Testing_Still_031_031a_000004-a_186779771_rgb
+BIWIRGBDID Testing_Still_031_031a_000014-a_186780855_rgb
+BIWIRGBDID Testing_Still_031_031a_000036-a_186783439_rgb
+BIWIRGBDID Testing_Still_031_031a_000050-a_186784855_rgb
+BIWIRGBDID Testing_Still_031_031a_000086-a_186788523_rgb
+BIWIRGBDID Testing_Still_031_031a_000098-a_186789771_rgb
+BIWIRGBDID Testing_Still_031_031a_000102-a_186790186_rgb
+BIWIRGBDID Testing_Still_031_031a_000120-a_186791938_rgb
+BIWIRGBDID Testing_Still_032_032a_000032-a_111072184_rgb
+BIWIRGBDID Testing_Still_032_032a_000049-a_111074016_rgb
+BIWIRGBDID Testing_Still_032_032a_000112-a_111080852_rgb
+BIWIRGBDID Testing_Still_032_032a_000122-a_111081932_rgb
+BIWIRGBDID Testing_Still_036_036a_000011-a_107768409_rgb
+BIWIRGBDID Testing_Still_036_036a_000016-a_107768826_rgb
+BIWIRGBDID Testing_Still_036_036a_000024-a_107769661_rgb
+BIWIRGBDID Testing_Still_036_036a_000071-a_107774662_rgb
+BIWIRGBDID Testing_Still_036_036a_000077-a_107775325_rgb
+BIWIRGBDID Testing_Still_036_036a_000087-a_107776409_rgb
+BIWIRGBDID Testing_Still_037_037a_000040-a_191434279_rgb
+BIWIRGBDID Testing_Still_037_037a_000044-a_191434696_rgb
+BIWIRGBDID Testing_Still_037_037a_000074-a_191438032_rgb
+BIWIRGBDID Testing_Still_037_037a_000091-a_191439695_rgb
+BIWIRGBDID Testing_Still_037_037a_000109-a_191441696_rgb
+BIWIRGBDID Testing_Still_037_037a_000111-a_191442031_rgb
+BIWIRGBDID Testing_Still_037_037a_000123-a_191443363_rgb
+BIWIRGBDID Testing_Still_039_039a_000006-a_1219302217_rgb
+BIWIRGBDID Testing_Still_039_039a_000015-a_1219303217_rgb
+BIWIRGBDID Testing_Still_039_039a_000044-a_1219306217_rgb
+BIWIRGBDID Testing_Still_039_039a_000058-a_1219307717_rgb
+BIWIRGBDID Testing_Still_039_039a_000090-a_1219310969_rgb
+BIWIRGBDID Testing_Still_039_039a_000097-a_1219311885_rgb
+BIWIRGBDID Testing_Still_039_039a_000122-a_1219314717_rgb
+BIWIRGBDID Testing_Still_039_039a_000144-a_1219317049_rgb
+BIWIRGBDID Testing_Still_040_040a_000040-a_1231702678_rgb
+BIWIRGBDID Testing_Still_040_040a_000046-a_1231703346_rgb
+BIWIRGBDID Testing_Still_040_040a_000073-a_1231706514_rgb
+BIWIRGBDID Testing_Still_040_040a_000102-a_1231710014_rgb
+BIWIRGBDID Testing_Still_040_040a_000121-a_1231712093_rgb
+BIWIRGBDID Testing_Still_040_040a_000122-a_1231712177_rgb
+BIWIRGBDID Testing_Still_040_040a_000136-a_1231713846_rgb
+BIWIRGBDID Testing_Still_044_044a_000002-a_1214165465_rgb
+BIWIRGBDID Testing_Still_044_044a_000046-a_1214170130_rgb
+BIWIRGBDID Testing_Still_044_044a_000059-a_1214171381_rgb
+BIWIRGBDID Testing_Still_044_044a_000070-a_1214172549_rgb
+BIWIRGBDID Testing_Still_044_044a_000089-a_1214174465_rgb
+BIWIRGBDID Testing_Still_044_044a_000103-a_1214175881_rgb
+BIWIRGBDID Testing_Still_046_046a_000006-a_111209841_rgb
+BIWIRGBDID Testing_Still_046_046a_000021-a_111211425_rgb
+BIWIRGBDID Testing_Still_046_046a_000040-a_111213425_rgb
+BIWIRGBDID Testing_Still_046_046a_000071-a_111216841_rgb
+BIWIRGBDID Testing_Still_046_046a_000078-a_111217509_rgb
+BIWIRGBDID Testing_Still_046_046a_000079-a_111217676_rgb
+BIWIRGBDID Testing_Still_047_047a_000067-a_1214094887_rgb
+BIWIRGBDID Testing_Still_047_047a_000077-a_1214095887_rgb
+BIWIRGBDID Testing_Still_047_047a_000090-a_1214097135_rgb
+BIWIRGBDID Testing_Still_047_047a_000120-a_1214100468_rgb
+BIWIRGBDID Testing_Still_049_049a_000000-a_201357193_rgb
+BIWIRGBDID Testing_Still_049_049a_000020-a_201359362_rgb
+BIWIRGBDID Testing_Still_049_049a_000026-a_201360029_rgb
+BIWIRGBDID Testing_Still_049_049a_000028-a_201360193_rgb
+BIWIRGBDID Testing_Still_049_049a_000069-a_201364613_rgb
+BIWIRGBDID Testing_Still_049_049a_000073-a_201365029_rgb
+BIWIRGBDID Testing_Still_049_049a_000083-a_201366113_rgb
+BIWIRGBDID Testing_Still_049_049a_000088-a_201366613_rgb
+BIWIRGBDID Testing_Walking_000_000b_000008-a_111676306_rgb
+BIWIRGBDID Testing_Walking_000_000b_000032-a_111678306_rgb
+BIWIRGBDID Testing_Walking_000_000b_000043-a_111679306_rgb
+BIWIRGBDID Testing_Walking_000_000b_000064-a_111681390_rgb
+BIWIRGBDID Testing_Walking_000_000b_000066-a_111681638_rgb
+BIWIRGBDID Testing_Walking_000_000b_000085-a_111683806_rgb
+BIWIRGBDID Testing_Walking_000_000b_000110-a_111686054_rgb
+BIWIRGBDID Testing_Walking_000_000b_000139-a_111688470_rgb
+BIWIRGBDID Testing_Walking_000_000b_000158-a_111690054_rgb
+BIWIRGBDID Testing_Walking_000_000b_000159-a_111690138_rgb
+BIWIRGBDID Testing_Walking_000_000b_000182-a_111692390_rgb
+BIWIRGBDID Testing_Walking_000_000b_000192-a_111693390_rgb
+BIWIRGBDID Testing_Walking_000_000b_000234-a_111697222_rgb
+BIWIRGBDID Testing_Walking_000_000b_000258-a_111699221_rgb
+BIWIRGBDID Testing_Walking_000_000b_000261-a_111699469_rgb
+BIWIRGBDID Testing_Walking_000_000b_000265-a_111699886_rgb
+BIWIRGBDID Testing_Walking_000_000b_000290-a_111702469_rgb
+BIWIRGBDID Testing_Walking_000_000b_000291-a_111702553_rgb
+BIWIRGBDID Testing_Walking_000_000b_000349-a_111708305_rgb
+BIWIRGBDID Testing_Walking_000_000b_000355-a_111708805_rgb
+BIWIRGBDID Testing_Walking_000_000b_000370-a_111710137_rgb
+BIWIRGBDID Testing_Walking_000_000b_000372-a_111710305_rgb
+BIWIRGBDID Testing_Walking_000_000b_000406-a_111713721_rgb
+BIWIRGBDID Testing_Walking_000_000b_000410-a_111714137_rgb
+BIWIRGBDID Testing_Walking_000_000b_000416-a_111714637_rgb
+BIWIRGBDID Testing_Walking_000_000b_000420-a_111714969_rgb
+BIWIRGBDID Testing_Walking_000_000b_000439-a_111716637_rgb
+BIWIRGBDID Testing_Walking_001_001b_000002-a_106302670_rgb
+BIWIRGBDID Testing_Walking_001_001b_000004-a_106302835_rgb
+BIWIRGBDID Testing_Walking_001_001b_000011-a_106303418_rgb
+BIWIRGBDID Testing_Walking_001_001b_000015-a_106303834_rgb
+BIWIRGBDID Testing_Walking_001_001b_000030-a_106305254_rgb
+BIWIRGBDID Testing_Walking_001_001b_000046-a_106306754_rgb
+BIWIRGBDID Testing_Walking_001_001b_000083-a_106310586_rgb
+BIWIRGBDID Testing_Walking_001_001b_000158-a_106317918_rgb
+BIWIRGBDID Testing_Walking_001_001b_000177-a_106319586_rgb
+BIWIRGBDID Testing_Walking_001_001b_000181-a_106319918_rgb
+BIWIRGBDID Testing_Walking_001_001b_000205-a_106322170_rgb
+BIWIRGBDID Testing_Walking_001_001b_000249-a_106327250_rgb
+BIWIRGBDID Testing_Walking_001_001b_000289-a_106331834_rgb
+BIWIRGBDID Testing_Walking_001_001b_000303-a_106333334_rgb
+BIWIRGBDID Testing_Walking_001_001b_000329-a_106336502_rgb
+BIWIRGBDID Testing_Walking_001_001b_000357-a_106339586_rgb
+BIWIRGBDID Testing_Walking_001_001b_000360-a_106339917_rgb
+BIWIRGBDID Testing_Walking_001_001b_000371-a_106341165_rgb
+BIWIRGBDID Testing_Walking_002_002b_000004-a_1233001421_rgb
+BIWIRGBDID Testing_Walking_002_002b_000018-a_1233002673_rgb
+BIWIRGBDID Testing_Walking_002_002b_000024-a_1233003257_rgb
+BIWIRGBDID Testing_Walking_002_002b_000032-a_1233004005_rgb
+BIWIRGBDID Testing_Walking_002_002b_000059-a_1233006589_rgb
+BIWIRGBDID Testing_Walking_002_002b_000069-a_1233007673_rgb
+BIWIRGBDID Testing_Walking_002_002b_000130-a_1233014089_rgb
+BIWIRGBDID Testing_Walking_002_002b_000159-a_1233017257_rgb
+BIWIRGBDID Testing_Walking_002_002b_000169-a_1233018337_rgb
+BIWIRGBDID Testing_Walking_002_002b_000170-a_1233018421_rgb
+BIWIRGBDID Testing_Walking_002_002b_000188-a_1233020337_rgb
+BIWIRGBDID Testing_Walking_002_002b_000220-a_1233024004_rgb
+BIWIRGBDID Testing_Walking_002_002b_000222-a_1233024172_rgb
+BIWIRGBDID Testing_Walking_002_002b_000232-a_1233025336_rgb
+BIWIRGBDID Testing_Walking_002_002b_000287-a_1233031336_rgb
+BIWIRGBDID Testing_Walking_002_002b_000303-a_1233033088_rgb
+BIWIRGBDID Testing_Walking_002_002b_000308-a_1233033504_rgb
+BIWIRGBDID Testing_Walking_002_002b_000318-a_1233034420_rgb
+BIWIRGBDID Testing_Walking_002_002b_000338-a_1233036588_rgb
+BIWIRGBDID Testing_Walking_002_002b_000340-a_1233036836_rgb
+BIWIRGBDID Testing_Walking_002_002b_000355-a_1233038504_rgb
+BIWIRGBDID Testing_Walking_003_003b_000025-a_621819949_rgb
+BIWIRGBDID Testing_Walking_003_003b_000054-a_621823117_rgb
+BIWIRGBDID Testing_Walking_003_003b_000112-a_621829533_rgb
+BIWIRGBDID Testing_Walking_003_003b_000113-a_621829617_rgb
+BIWIRGBDID Testing_Walking_003_003b_000173-a_621836365_rgb
+BIWIRGBDID Testing_Walking_003_003b_000179-a_621836949_rgb
+BIWIRGBDID Testing_Walking_003_003b_000189-a_621837781_rgb
+BIWIRGBDID Testing_Walking_003_003b_000191-a_621837949_rgb
+BIWIRGBDID Testing_Walking_003_003b_000225-a_621842201_rgb
+BIWIRGBDID Testing_Walking_003_003b_000274-a_621847616_rgb
+BIWIRGBDID Testing_Walking_003_003b_000275-a_621847701_rgb
+BIWIRGBDID Testing_Walking_003_003b_000278-a_621847948_rgb
+BIWIRGBDID Testing_Walking_003_003b_000306-a_621851116_rgb
+BIWIRGBDID Testing_Walking_003_003b_000323-a_621852948_rgb
+BIWIRGBDID Testing_Walking_003_003b_000335-a_621854032_rgb
+BIWIRGBDID Testing_Walking_006_006b_000047-a_1224090658_rgb
+BIWIRGBDID Testing_Walking_006_006b_000048-a_1224090742_rgb
+BIWIRGBDID Testing_Walking_006_006b_000053-a_1224091325_rgb
+BIWIRGBDID Testing_Walking_006_006b_000080-a_1224093993_rgb
+BIWIRGBDID Testing_Walking_006_006b_000106-a_1224096741_rgb
+BIWIRGBDID Testing_Walking_006_006b_000112-a_1224097325_rgb
+BIWIRGBDID Testing_Walking_006_006b_000118-a_1224097825_rgb
+BIWIRGBDID Testing_Walking_006_006b_000119-a_1224097909_rgb
+BIWIRGBDID Testing_Walking_006_006b_000127-a_1224098657_rgb
+BIWIRGBDID Testing_Walking_006_006b_000158-a_1224101325_rgb
+BIWIRGBDID Testing_Walking_006_006b_000168-a_1224102241_rgb
+BIWIRGBDID Testing_Walking_006_006b_000205-a_1224106073_rgb
+BIWIRGBDID Testing_Walking_006_006b_000236-a_1224108825_rgb
+BIWIRGBDID Testing_Walking_006_006b_000257-a_1224110573_rgb
+BIWIRGBDID Testing_Walking_006_006b_000264-a_1224111157_rgb
+BIWIRGBDID Testing_Walking_006_006b_000289-a_1224113825_rgb
+BIWIRGBDID Testing_Walking_006_006b_000396-a_1224124073_rgb
+BIWIRGBDID Testing_Walking_008_008b_000001-a_190329700_rgb
+BIWIRGBDID Testing_Walking_008_008b_000030-a_190332200_rgb
+BIWIRGBDID Testing_Walking_008_008b_000065-a_190336032_rgb
+BIWIRGBDID Testing_Walking_008_008b_000087-a_190338532_rgb
+BIWIRGBDID Testing_Walking_008_008b_000090-a_190338865_rgb
+BIWIRGBDID Testing_Walking_008_008b_000093-a_190339117_rgb
+BIWIRGBDID Testing_Walking_008_008b_000103-a_190339948_rgb
+BIWIRGBDID Testing_Walking_008_008b_000124-a_190341700_rgb
+BIWIRGBDID Testing_Walking_008_008b_000170-a_190346116_rgb
+BIWIRGBDID Testing_Walking_008_008b_000218-a_190351280_rgb
+BIWIRGBDID Testing_Walking_008_008b_000231-a_190352364_rgb
+BIWIRGBDID Testing_Walking_008_008b_000257-a_190354780_rgb
+BIWIRGBDID Testing_Walking_008_008b_000268-a_190355700_rgb
+BIWIRGBDID Testing_Walking_008_008b_000307-a_190359696_rgb
+BIWIRGBDID Testing_Walking_008_008b_000309-a_190359864_rgb
+BIWIRGBDID Testing_Walking_008_008b_000317-a_190360531_rgb
+BIWIRGBDID Testing_Walking_008_008b_000329-a_190361615_rgb
+BIWIRGBDID Testing_Walking_008_008b_000363-a_190364948_rgb
+BIWIRGBDID Testing_Walking_010_010b_000011-a_172014564_rgb
+BIWIRGBDID Testing_Walking_010_010b_000027-a_172015896_rgb
+BIWIRGBDID Testing_Walking_010_010b_000030-a_172016144_rgb
+BIWIRGBDID Testing_Walking_010_010b_000077-a_172020812_rgb
+BIWIRGBDID Testing_Walking_010_010b_000142-a_172026812_rgb
+BIWIRGBDID Testing_Walking_010_010b_000167-a_172029395_rgb
+BIWIRGBDID Testing_Walking_010_010b_000176-a_172030396_rgb
+BIWIRGBDID Testing_Walking_010_010b_000187-a_172031560_rgb
+BIWIRGBDID Testing_Walking_010_010b_000212-a_172033980_rgb
+BIWIRGBDID Testing_Walking_010_010b_000237-a_172036060_rgb
+BIWIRGBDID Testing_Walking_010_010b_000255-a_172037727_rgb
+BIWIRGBDID Testing_Walking_010_010b_000282-a_172040395_rgb
+BIWIRGBDID Testing_Walking_010_010b_000321-a_172044395_rgb
+BIWIRGBDID Testing_Walking_010_010b_000324-a_172044643_rgb
+BIWIRGBDID Testing_Walking_010_010b_000330-a_172045311_rgb
+BIWIRGBDID Testing_Walking_010_010b_000351-a_172047143_rgb
+BIWIRGBDID Testing_Walking_010_010b_000352-a_172047227_rgb
+BIWIRGBDID Testing_Walking_010_010b_000380-a_172049643_rgb
+BIWIRGBDID Testing_Walking_010_010b_000382-a_172049811_rgb
+BIWIRGBDID Testing_Walking_011_011b_000025-a_200221193_rgb
+BIWIRGBDID Testing_Walking_011_011b_000033-a_200222025_rgb
+BIWIRGBDID Testing_Walking_011_011b_000044-a_200223193_rgb
+BIWIRGBDID Testing_Walking_011_011b_000049-a_200223693_rgb
+BIWIRGBDID Testing_Walking_011_011b_000083-a_200227525_rgb
+BIWIRGBDID Testing_Walking_011_011b_000086-a_200227857_rgb
+BIWIRGBDID Testing_Walking_011_011b_000106-a_200230193_rgb
+BIWIRGBDID Testing_Walking_011_011b_000125-a_200232025_rgb
+BIWIRGBDID Testing_Walking_011_011b_000142-a_200233609_rgb
+BIWIRGBDID Testing_Walking_011_011b_000175-a_200237109_rgb
+BIWIRGBDID Testing_Walking_011_011b_000203-a_200240357_rgb
+BIWIRGBDID Testing_Walking_011_011b_000204-a_200240441_rgb
+BIWIRGBDID Testing_Walking_011_011b_000259-a_200246188_rgb
+BIWIRGBDID Testing_Walking_011_011b_000266-a_200246857_rgb
+BIWIRGBDID Testing_Walking_011_011b_000293-a_200249524_rgb
+BIWIRGBDID Testing_Walking_011_011b_000301-a_200250440_rgb
+BIWIRGBDID Testing_Walking_011_011b_000309-a_200251441_rgb
+BIWIRGBDID Testing_Walking_011_011b_000321-a_200252772_rgb
+BIWIRGBDID Testing_Walking_011_011b_000367-a_200257440_rgb
+BIWIRGBDID Testing_Walking_011_011b_000393-a_200259772_rgb
+BIWIRGBDID Testing_Walking_011_011b_000398-a_200260272_rgb
+BIWIRGBDID Testing_Walking_011_011b_000430-a_200263772_rgb
+BIWIRGBDID Testing_Walking_016_016b_000003-a_188187593_rgb
+BIWIRGBDID Testing_Walking_016_016b_000004-a_188187673_rgb
+BIWIRGBDID Testing_Walking_016_016b_000016-a_188188841_rgb
+BIWIRGBDID Testing_Walking_016_016b_000040-a_188191173_rgb
+BIWIRGBDID Testing_Walking_016_016b_000064-a_188193841_rgb
+BIWIRGBDID Testing_Walking_016_016b_000082-a_188195673_rgb
+BIWIRGBDID Testing_Walking_016_016b_000087-a_188196093_rgb
+BIWIRGBDID Testing_Walking_016_016b_000108-a_188198509_rgb
+BIWIRGBDID Testing_Walking_016_016b_000111-a_188198841_rgb
+BIWIRGBDID Testing_Walking_016_016b_000141-a_188202009_rgb
+BIWIRGBDID Testing_Walking_016_016b_000142-a_188202173_rgb
+BIWIRGBDID Testing_Walking_016_016b_000161-a_188204173_rgb
+BIWIRGBDID Testing_Walking_016_016b_000202-a_188208341_rgb
+BIWIRGBDID Testing_Walking_016_016b_000206-a_188208841_rgb
+BIWIRGBDID Testing_Walking_016_016b_000211-a_188209425_rgb
+BIWIRGBDID Testing_Walking_016_016b_000216-a_188209841_rgb
+BIWIRGBDID Testing_Walking_016_016b_000235-a_188211757_rgb
+BIWIRGBDID Testing_Walking_016_016b_000238-a_188212173_rgb
+BIWIRGBDID Testing_Walking_016_016b_000253-a_188213757_rgb
+BIWIRGBDID Testing_Walking_016_016b_000268-a_188215341_rgb
+BIWIRGBDID Testing_Walking_016_016b_000287-a_188217508_rgb
+BIWIRGBDID Testing_Walking_016_016b_000298-a_188218672_rgb
+BIWIRGBDID Testing_Walking_016_016b_000308-a_188219841_rgb
+BIWIRGBDID Testing_Walking_016_016b_000310-a_188220004_rgb
+BIWIRGBDID Testing_Walking_016_016b_000313-a_188220341_rgb
+BIWIRGBDID Testing_Walking_016_016b_000318-a_188220925_rgb
+BIWIRGBDID Testing_Walking_016_016b_000347-a_188224005_rgb
+BIWIRGBDID Testing_Walking_017_017b_000008-a_191574104_rgb
+BIWIRGBDID Testing_Walking_017_017b_000011-a_191574356_rgb
+BIWIRGBDID Testing_Walking_017_017b_000039-a_191577604_rgb
+BIWIRGBDID Testing_Walking_017_017b_000090-a_191583104_rgb
+BIWIRGBDID Testing_Walking_017_017b_000093-a_191583436_rgb
+BIWIRGBDID Testing_Walking_017_017b_000095-a_191583937_rgb
+BIWIRGBDID Testing_Walking_017_017b_000100-a_191584436_rgb
+BIWIRGBDID Testing_Walking_017_017b_000119-a_191586272_rgb
+BIWIRGBDID Testing_Walking_017_017b_000179-a_191592103_rgb
+BIWIRGBDID Testing_Walking_017_017b_000181-a_191592272_rgb
+BIWIRGBDID Testing_Walking_017_017b_000201-a_191594436_rgb
+BIWIRGBDID Testing_Walking_017_017b_000227-a_191597355_rgb
+BIWIRGBDID Testing_Walking_017_017b_000241-a_191598851_rgb
+BIWIRGBDID Testing_Walking_017_017b_000242-a_191598935_rgb
+BIWIRGBDID Testing_Walking_017_017b_000252-a_191599935_rgb
+BIWIRGBDID Testing_Walking_017_017b_000263-a_191600935_rgb
+BIWIRGBDID Testing_Walking_017_017b_000275-a_191602187_rgb
+BIWIRGBDID Testing_Walking_017_017b_000291-a_191603852_rgb
+BIWIRGBDID Testing_Walking_017_017b_000306-a_191605435_rgb
+BIWIRGBDID Testing_Walking_017_017b_000313-a_191606103_rgb
+BIWIRGBDID Testing_Walking_017_017b_000317-a_191606436_rgb
+BIWIRGBDID Testing_Walking_017_017b_000385-a_191613687_rgb
+BIWIRGBDID Testing_Walking_017_017b_000422-a_191617351_rgb
+BIWIRGBDID Testing_Walking_017_017b_000425-a_191617603_rgb
+BIWIRGBDID Testing_Walking_017_017b_000462-a_191622103_rgb
+BIWIRGBDID Testing_Walking_017_017b_000472-a_191623103_rgb
+BIWIRGBDID Testing_Walking_017_017b_000496-a_191625603_rgb
+BIWIRGBDID Testing_Walking_019_019b_000023-a_107227611_rgb
+BIWIRGBDID Testing_Walking_019_019b_000038-a_107228863_rgb
+BIWIRGBDID Testing_Walking_019_019b_000046-a_107229611_rgb
+BIWIRGBDID Testing_Walking_019_019b_000047-a_107229695_rgb
+BIWIRGBDID Testing_Walking_019_019b_000103-a_107235443_rgb
+BIWIRGBDID Testing_Walking_019_019b_000128-a_107238027_rgb
+BIWIRGBDID Testing_Walking_019_019b_000150-a_107240027_rgb
+BIWIRGBDID Testing_Walking_019_019b_000183-a_107243027_rgb
+BIWIRGBDID Testing_Walking_019_019b_000188-a_107243527_rgb
+BIWIRGBDID Testing_Walking_019_019b_000210-a_107245695_rgb
+BIWIRGBDID Testing_Walking_019_019b_000218-a_107246527_rgb
+BIWIRGBDID Testing_Walking_019_019b_000254-a_107250359_rgb
+BIWIRGBDID Testing_Walking_019_019b_000256-a_107250526_rgb
+BIWIRGBDID Testing_Walking_019_019b_000269-a_107251694_rgb
+BIWIRGBDID Testing_Walking_019_019b_000285-a_107253194_rgb
+BIWIRGBDID Testing_Walking_019_019b_000310-a_107255358_rgb
+BIWIRGBDID Testing_Walking_019_019b_000311-a_107255442_rgb
+BIWIRGBDID Testing_Walking_019_019b_000313-a_107255610_rgb
+BIWIRGBDID Testing_Walking_019_019b_000336-a_107258026_rgb
+BIWIRGBDID Testing_Walking_019_019b_000347-a_107259194_rgb
+BIWIRGBDID Testing_Walking_019_019b_000373-a_107261942_rgb
+BIWIRGBDID Testing_Walking_019_019b_000410-a_107265526_rgb
+BIWIRGBDID Testing_Walking_019_019b_000416-a_107266026_rgb
+BIWIRGBDID Testing_Walking_019_019b_000433-a_107267526_rgb
+BIWIRGBDID Testing_Walking_021_021b_000075-a_109053893_rgb
+BIWIRGBDID Testing_Walking_021_021b_000089-a_109055313_rgb
+BIWIRGBDID Testing_Walking_021_021b_000095-a_109055978_rgb
+BIWIRGBDID Testing_Walking_021_021b_000105-a_109056977_rgb
+BIWIRGBDID Testing_Walking_021_021b_000111-a_109057561_rgb
+BIWIRGBDID Testing_Walking_021_021b_000144-a_109060813_rgb
+BIWIRGBDID Testing_Walking_021_021b_000176-a_109063645_rgb
+BIWIRGBDID Testing_Walking_021_021b_000235-a_109069309_rgb
+BIWIRGBDID Testing_Walking_021_021b_000265-a_109072561_rgb
+BIWIRGBDID Testing_Walking_021_021b_000305-a_109076060_rgb
+BIWIRGBDID Testing_Walking_021_021b_000328-a_109078145_rgb
+BIWIRGBDID Testing_Walking_021_021b_000356-a_109080976_rgb
+BIWIRGBDID Testing_Walking_021_021b_000370-a_109082476_rgb
+BIWIRGBDID Testing_Walking_021_021b_000392-a_109084724_rgb
+BIWIRGBDID Testing_Walking_021_021b_000420-a_109087392_rgb
+BIWIRGBDID Testing_Walking_021_021b_000440-a_109089060_rgb
+BIWIRGBDID Testing_Walking_021_021b_000493-a_109093476_rgb
+BIWIRGBDID Testing_Walking_022_022b_000032-a_1214892493_rgb
+BIWIRGBDID Testing_Walking_022_022b_000043-a_1214893409_rgb
+BIWIRGBDID Testing_Walking_022_022b_000052-a_1214894161_rgb
+BIWIRGBDID Testing_Walking_022_022b_000054-a_1214894329_rgb
+BIWIRGBDID Testing_Walking_022_022b_000058-a_1214894661_rgb
+BIWIRGBDID Testing_Walking_022_022b_000087-a_1214897409_rgb
+BIWIRGBDID Testing_Walking_022_022b_000088-a_1214897493_rgb
+BIWIRGBDID Testing_Walking_022_022b_000107-a_1214899409_rgb
+BIWIRGBDID Testing_Walking_022_022b_000126-a_1214901329_rgb
+BIWIRGBDID Testing_Walking_022_022b_000147-a_1214903161_rgb
+BIWIRGBDID Testing_Walking_022_022b_000183-a_1214906493_rgb
+BIWIRGBDID Testing_Walking_022_022b_000185-a_1214906661_rgb
+BIWIRGBDID Testing_Walking_022_022b_000200-a_1214908161_rgb
+BIWIRGBDID Testing_Walking_022_022b_000201-a_1214908245_rgb
+BIWIRGBDID Testing_Walking_022_022b_000206-a_1214908745_rgb
+BIWIRGBDID Testing_Walking_022_022b_000256-a_1214913825_rgb
+BIWIRGBDID Testing_Walking_022_022b_000279-a_1214915909_rgb
+BIWIRGBDID Testing_Walking_022_022b_000288-a_1214916909_rgb
+BIWIRGBDID Testing_Walking_022_022b_000320-a_1214920077_rgb
+BIWIRGBDID Testing_Walking_022_022b_000344-a_1214922660_rgb
+BIWIRGBDID Testing_Walking_022_022b_000360-a_1214924741_rgb
+BIWIRGBDID Testing_Walking_022_022b_000368-a_1214925492_rgb
+BIWIRGBDID Testing_Walking_022_022b_000375-a_1214926076_rgb
+BIWIRGBDID Testing_Walking_022_022b_000379-a_1214926408_rgb
+BIWIRGBDID Testing_Walking_022_022b_000404-a_1214928909_rgb
+BIWIRGBDID Testing_Walking_022_022b_000405-a_1214928992_rgb
+BIWIRGBDID Testing_Walking_022_022b_000437-a_1214931825_rgb
+BIWIRGBDID Testing_Walking_022_022b_000452-a_1214933324_rgb
+BIWIRGBDID Testing_Walking_022_022b_000459-a_1214934076_rgb
+BIWIRGBDID Testing_Walking_023_023b_000009-a_197707271_rgb
+BIWIRGBDID Testing_Walking_023_023b_000020-a_197708439_rgb
+BIWIRGBDID Testing_Walking_023_023b_000029-a_197709270_rgb
+BIWIRGBDID Testing_Walking_023_023b_000051-a_197711186_rgb
+BIWIRGBDID Testing_Walking_023_023b_000063-a_197712438_rgb
+BIWIRGBDID Testing_Walking_023_023b_000077-a_197714271_rgb
+BIWIRGBDID Testing_Walking_023_023b_000085-a_197715354_rgb
+BIWIRGBDID Testing_Walking_023_023b_000099-a_197717186_rgb
+BIWIRGBDID Testing_Walking_023_023b_000112-a_197718854_rgb
+BIWIRGBDID Testing_Walking_023_023b_000118-a_197719518_rgb
+BIWIRGBDID Testing_Walking_023_023b_000119-a_197719602_rgb
+BIWIRGBDID Testing_Walking_023_023b_000124-a_197720186_rgb
+BIWIRGBDID Testing_Walking_023_023b_000130-a_197720686_rgb
+BIWIRGBDID Testing_Walking_023_023b_000155-a_197722935_rgb
+BIWIRGBDID Testing_Walking_023_023b_000181-a_197725602_rgb
+BIWIRGBDID Testing_Walking_023_023b_000197-a_197727855_rgb
+BIWIRGBDID Testing_Walking_023_023b_000211-a_197729770_rgb
+BIWIRGBDID Testing_Walking_023_023b_000222-a_197731018_rgb
+BIWIRGBDID Testing_Walking_023_023b_000233-a_197732186_rgb
+BIWIRGBDID Testing_Walking_023_023b_000253-a_197733850_rgb
+BIWIRGBDID Testing_Walking_023_023b_000261-a_197734602_rgb
+BIWIRGBDID Testing_Walking_023_023b_000266-a_197735018_rgb
+BIWIRGBDID Testing_Walking_023_023b_000276-a_197735934_rgb
+BIWIRGBDID Testing_Walking_023_023b_000279-a_197736185_rgb
+BIWIRGBDID Testing_Walking_023_023b_000285-a_197736686_rgb
+BIWIRGBDID Testing_Walking_023_023b_000307-a_197738850_rgb
+BIWIRGBDID Testing_Walking_023_023b_000310-a_197739186_rgb
+BIWIRGBDID Testing_Walking_023_023b_000328-a_197741518_rgb
+BIWIRGBDID Testing_Walking_023_023b_000356-a_197745433_rgb
+BIWIRGBDID Testing_Walking_023_023b_000371-a_197747017_rgb
+BIWIRGBDID Testing_Walking_023_023b_000379-a_197747685_rgb
+BIWIRGBDID Testing_Walking_023_023b_000407-a_197750265_rgb
+BIWIRGBDID Testing_Walking_023_023b_000416-a_197751018_rgb
+BIWIRGBDID Testing_Walking_023_023b_000424-a_197751765_rgb
+BIWIRGBDID Testing_Walking_023_023b_000438-a_197753517_rgb
+BIWIRGBDID Testing_Walking_024_024b_000028-a_197337876_rgb
+BIWIRGBDID Testing_Walking_024_024b_000035-a_197338544_rgb
+BIWIRGBDID Testing_Walking_024_024b_000058-a_197341708_rgb
+BIWIRGBDID Testing_Walking_024_024b_000061-a_197342128_rgb
+BIWIRGBDID Testing_Walking_024_024b_000065-a_197342627_rgb
+BIWIRGBDID Testing_Walking_024_024b_000074-a_197343628_rgb
+BIWIRGBDID Testing_Walking_024_024b_000090-a_197345628_rgb
+BIWIRGBDID Testing_Walking_024_024b_000132-a_197349628_rgb
+BIWIRGBDID Testing_Walking_024_024b_000184-a_197356127_rgb
+BIWIRGBDID Testing_Walking_024_024b_000210-a_197358459_rgb
+BIWIRGBDID Testing_Walking_024_024b_000239-a_197361544_rgb
+BIWIRGBDID Testing_Walking_024_024b_000259-a_197364043_rgb
+BIWIRGBDID Testing_Walking_024_024b_000304-a_197369043_rgb
+BIWIRGBDID Testing_Walking_024_024b_000355-a_197374707_rgb
+BIWIRGBDID Testing_Walking_026_026b_000007-a_111022853_rgb
+BIWIRGBDID Testing_Walking_026_026b_000025-a_111024354_rgb
+BIWIRGBDID Testing_Walking_026_026b_000038-a_111025770_rgb
+BIWIRGBDID Testing_Walking_026_026b_000061-a_111028185_rgb
+BIWIRGBDID Testing_Walking_026_026b_000062-a_111028269_rgb
+BIWIRGBDID Testing_Walking_026_026b_000067-a_111028769_rgb
+BIWIRGBDID Testing_Walking_026_026b_000072-a_111029353_rgb
+BIWIRGBDID Testing_Walking_026_026b_000083-a_111030521_rgb
+BIWIRGBDID Testing_Walking_026_026b_000097-a_111031769_rgb
+BIWIRGBDID Testing_Walking_026_026b_000102-a_111032186_rgb
+BIWIRGBDID Testing_Walking_026_026b_000108-a_111032854_rgb
+BIWIRGBDID Testing_Walking_026_026b_000114-a_111033354_rgb
+BIWIRGBDID Testing_Walking_026_026b_000136-a_111035605_rgb
+BIWIRGBDID Testing_Walking_026_026b_000160-a_111038185_rgb
+BIWIRGBDID Testing_Walking_026_026b_000162-a_111038353_rgb
+BIWIRGBDID Testing_Walking_026_026b_000179-a_111040105_rgb
+BIWIRGBDID Testing_Walking_026_026b_000213-a_111043769_rgb
+BIWIRGBDID Testing_Walking_026_026b_000215-a_111044021_rgb
+BIWIRGBDID Testing_Walking_026_026b_000221-a_111044521_rgb
+BIWIRGBDID Testing_Walking_026_026b_000232-a_111045602_rgb
+BIWIRGBDID Testing_Walking_026_026b_000247-a_111047185_rgb
+BIWIRGBDID Testing_Walking_026_026b_000249-a_111047353_rgb
+BIWIRGBDID Testing_Walking_026_026b_000265-a_111049021_rgb
+BIWIRGBDID Testing_Walking_026_026b_000275-a_111050101_rgb
+BIWIRGBDID Testing_Walking_026_026b_000333-a_111055601_rgb
+BIWIRGBDID Testing_Walking_027_027b_000001-a_111418663_rgb
+BIWIRGBDID Testing_Walking_027_027b_000017-a_111419995_rgb
+BIWIRGBDID Testing_Walking_027_027b_000028-a_111420911_rgb
+BIWIRGBDID Testing_Walking_027_027b_000049-a_111422912_rgb
+BIWIRGBDID Testing_Walking_027_027b_000062-a_111424247_rgb
+BIWIRGBDID Testing_Walking_027_027b_000072-a_111425327_rgb
+BIWIRGBDID Testing_Walking_027_027b_000080-a_111426163_rgb
+BIWIRGBDID Testing_Walking_027_027b_000088-a_111426995_rgb
+BIWIRGBDID Testing_Walking_027_027b_000098-a_111428079_rgb
+BIWIRGBDID Testing_Walking_027_027b_000132-a_111431163_rgb
+BIWIRGBDID Testing_Walking_027_027b_000198-a_111436827_rgb
+BIWIRGBDID Testing_Walking_027_027b_000203-a_111437412_rgb
+BIWIRGBDID Testing_Walking_027_027b_000205-a_111437579_rgb
+BIWIRGBDID Testing_Walking_027_027b_000207-a_111437827_rgb
+BIWIRGBDID Testing_Walking_027_027b_000218-a_111438911_rgb
+BIWIRGBDID Testing_Walking_027_027b_000240-a_111441411_rgb
+BIWIRGBDID Testing_Walking_027_027b_000313-a_111448663_rgb
+BIWIRGBDID Testing_Walking_027_027b_000323-a_111449663_rgb
+BIWIRGBDID Testing_Walking_027_027b_000338-a_111451243_rgb
+BIWIRGBDID Testing_Walking_027_027b_000350-a_111452495_rgb
+BIWIRGBDID Testing_Walking_027_027b_000373-a_111454911_rgb
+BIWIRGBDID Testing_Walking_027_027b_000380-a_111455495_rgb
+BIWIRGBDID Testing_Walking_027_027b_000382-a_111455659_rgb
+BIWIRGBDID Testing_Walking_027_027b_000405-a_111457743_rgb
+BIWIRGBDID Testing_Walking_027_027b_000412-a_111458495_rgb
+BIWIRGBDID Testing_Walking_030_030b_000015-a_1233809555_rgb
+BIWIRGBDID Testing_Walking_030_030b_000022-a_1233810139_rgb
+BIWIRGBDID Testing_Walking_030_030b_000068-a_1233815139_rgb
+BIWIRGBDID Testing_Walking_030_030b_000075-a_1233815970_rgb
+BIWIRGBDID Testing_Walking_030_030b_000077-a_1233816139_rgb
+BIWIRGBDID Testing_Walking_030_030b_000079-a_1233816307_rgb
+BIWIRGBDID Testing_Walking_030_030b_000102-a_1233818638_rgb
+BIWIRGBDID Testing_Walking_030_030b_000129-a_1233820886_rgb
+BIWIRGBDID Testing_Walking_030_030b_000156-a_1233823886_rgb
+BIWIRGBDID Testing_Walking_030_030b_000168-a_1233825054_rgb
+BIWIRGBDID Testing_Walking_030_030b_000182-a_1233826638_rgb
+BIWIRGBDID Testing_Walking_030_030b_000197-a_1233828222_rgb
+BIWIRGBDID Testing_Walking_030_030b_000216-a_1233830138_rgb
+BIWIRGBDID Testing_Walking_030_030b_000219-a_1233830386_rgb
+BIWIRGBDID Testing_Walking_030_030b_000223-a_1233830722_rgb
+BIWIRGBDID Testing_Walking_030_030b_000226-a_1233830970_rgb
+BIWIRGBDID Testing_Walking_030_030b_000234-a_1233831722_rgb
+BIWIRGBDID Testing_Walking_030_030b_000248-a_1233832886_rgb
+BIWIRGBDID Testing_Walking_030_030b_000299-a_1233838054_rgb
+BIWIRGBDID Testing_Walking_030_030b_000334-a_1233841722_rgb
+BIWIRGBDID Testing_Walking_030_030b_000344-a_1233842554_rgb
+BIWIRGBDID Testing_Walking_030_030b_000350-a_1233843218_rgb
+BIWIRGBDID Testing_Walking_030_030b_000351-a_1233843386_rgb
+BIWIRGBDID Testing_Walking_030_030b_000357-a_1233844302_rgb
+BIWIRGBDID Testing_Walking_030_030b_000367-a_1233845302_rgb
+BIWIRGBDID Testing_Walking_030_030b_000398-a_1233848638_rgb
+BIWIRGBDID Testing_Walking_031_031b_000001-a_186803438_rgb
+BIWIRGBDID Testing_Walking_031_031b_000005-a_186803770_rgb
+BIWIRGBDID Testing_Walking_031_031b_000054-a_186808770_rgb
+BIWIRGBDID Testing_Walking_031_031b_000069-a_186810354_rgb
+BIWIRGBDID Testing_Walking_031_031b_000079-a_186811438_rgb
+BIWIRGBDID Testing_Walking_031_031b_000125-a_186816438_rgb
+BIWIRGBDID Testing_Walking_031_031b_000132-a_186817102_rgb
+BIWIRGBDID Testing_Walking_031_031b_000165-a_186820434_rgb
+BIWIRGBDID Testing_Walking_031_031b_000176-a_186821518_rgb
+BIWIRGBDID Testing_Walking_031_031b_000197-a_186823770_rgb
+BIWIRGBDID Testing_Walking_031_031b_000215-a_186825601_rgb
+BIWIRGBDID Testing_Walking_031_031b_000221-a_186826102_rgb
+BIWIRGBDID Testing_Walking_031_031b_000245-a_186828602_rgb
+BIWIRGBDID Testing_Walking_031_031b_000259-a_186829934_rgb
+BIWIRGBDID Testing_Walking_031_031b_000269-a_186831018_rgb
+BIWIRGBDID Testing_Walking_031_031b_000287-a_186832933_rgb
+BIWIRGBDID Testing_Walking_031_031b_000341-a_186838350_rgb
+BIWIRGBDID Testing_Walking_031_031b_000353-a_186839350_rgb
+BIWIRGBDID Testing_Walking_031_031b_000361-a_186840101_rgb
+BIWIRGBDID Testing_Walking_031_031b_000368-a_186840685_rgb
+BIWIRGBDID Testing_Walking_031_031b_000371-a_186841017_rgb
+BIWIRGBDID Testing_Walking_031_031b_000380-a_186841933_rgb
+BIWIRGBDID Testing_Walking_031_031b_000400-a_186844101_rgb
+BIWIRGBDID Testing_Walking_031_031b_000402-a_186844349_rgb
+BIWIRGBDID Testing_Walking_031_031b_000403-a_186844433_rgb
+BIWIRGBDID Testing_Walking_032_032b_000022-a_111090932_rgb
+BIWIRGBDID Testing_Walking_032_032b_000034-a_111092016_rgb
+BIWIRGBDID Testing_Walking_032_032b_000038-a_111092516_rgb
+BIWIRGBDID Testing_Walking_032_032b_000044-a_111093100_rgb
+BIWIRGBDID Testing_Walking_032_032b_000053-a_111094100_rgb
+BIWIRGBDID Testing_Walking_032_032b_000127-a_111101515_rgb
+BIWIRGBDID Testing_Walking_032_032b_000128-a_111101599_rgb
+BIWIRGBDID Testing_Walking_032_032b_000154-a_111104015_rgb
+BIWIRGBDID Testing_Walking_032_032b_000160-a_111104684_rgb
+BIWIRGBDID Testing_Walking_032_032b_000184-a_111107100_rgb
+BIWIRGBDID Testing_Walking_032_032b_000187-a_111107515_rgb
+BIWIRGBDID Testing_Walking_032_032b_000254-a_111114099_rgb
+BIWIRGBDID Testing_Walking_032_032b_000302-a_111118431_rgb
+BIWIRGBDID Testing_Walking_032_032b_000308-a_111119015_rgb
+BIWIRGBDID Testing_Walking_032_032b_000313-a_111119599_rgb
+BIWIRGBDID Testing_Walking_032_032b_000324-a_111120763_rgb
+BIWIRGBDID Testing_Walking_032_032b_000332-a_111121683_rgb
+BIWIRGBDID Testing_Walking_032_032b_000335-a_111122015_rgb
+BIWIRGBDID Testing_Walking_032_032b_000351-a_111123683_rgb
+BIWIRGBDID Testing_Walking_032_032b_000363-a_111124763_rgb
+BIWIRGBDID Testing_Walking_032_032b_000385-a_111126847_rgb
+BIWIRGBDID Testing_Walking_032_032b_000404-a_111128763_rgb
+BIWIRGBDID Testing_Walking_036_036b_000040-a_107787409_rgb
+BIWIRGBDID Testing_Walking_036_036b_000049-a_107788409_rgb
+BIWIRGBDID Testing_Walking_036_036b_000121-a_107795493_rgb
+BIWIRGBDID Testing_Walking_036_036b_000150-a_107798077_rgb
+BIWIRGBDID Testing_Walking_036_036b_000152-a_107798241_rgb
+BIWIRGBDID Testing_Walking_036_036b_000176-a_107800661_rgb
+BIWIRGBDID Testing_Walking_036_036b_000181-a_107801241_rgb
+BIWIRGBDID Testing_Walking_036_036b_000196-a_107802825_rgb
+BIWIRGBDID Testing_Walking_036_036b_000210-a_107804241_rgb
+BIWIRGBDID Testing_Walking_036_036b_000213-a_107804577_rgb
+BIWIRGBDID Testing_Walking_036_036b_000215-a_107804824_rgb
+BIWIRGBDID Testing_Walking_036_036b_000220-a_107805325_rgb
+BIWIRGBDID Testing_Walking_036_036b_000226-a_107805908_rgb
+BIWIRGBDID Testing_Walking_036_036b_000253-a_107808324_rgb
+BIWIRGBDID Testing_Walking_036_036b_000277-a_107810657_rgb
+BIWIRGBDID Testing_Walking_036_036b_000292-a_107812240_rgb
+BIWIRGBDID Testing_Walking_036_036b_000303-a_107813324_rgb
+BIWIRGBDID Testing_Walking_036_036b_000344-a_107817741_rgb
+BIWIRGBDID Testing_Walking_036_036b_000373-a_107820408_rgb
+BIWIRGBDID Testing_Walking_036_036b_000387-a_107821656_rgb
+BIWIRGBDID Testing_Walking_037_037b_000029-a_191452363_rgb
+BIWIRGBDID Testing_Walking_037_037b_000054-a_191455364_rgb
+BIWIRGBDID Testing_Walking_037_037b_000058-a_191455779_rgb
+BIWIRGBDID Testing_Walking_037_037b_000075-a_191457527_rgb
+BIWIRGBDID Testing_Walking_037_037b_000127-a_191463363_rgb
+BIWIRGBDID Testing_Walking_037_037b_000146-a_191465279_rgb
+BIWIRGBDID Testing_Walking_037_037b_000166-a_191467527_rgb
+BIWIRGBDID Testing_Walking_037_037b_000169-a_191467863_rgb
+BIWIRGBDID Testing_Walking_037_037b_000179-a_191469027_rgb
+BIWIRGBDID Testing_Walking_037_037b_000188-a_191469947_rgb
+BIWIRGBDID Testing_Walking_037_037b_000215-a_191473110_rgb
+BIWIRGBDID Testing_Walking_037_037b_000227-a_191474362_rgb
+BIWIRGBDID Testing_Walking_037_037b_000251-a_191476694_rgb
+BIWIRGBDID Testing_Walking_037_037b_000254-a_191476942_rgb
+BIWIRGBDID Testing_Walking_037_037b_000259-a_191477362_rgb
+BIWIRGBDID Testing_Walking_037_037b_000270-a_191478694_rgb
+BIWIRGBDID Testing_Walking_037_037b_000277-a_191479363_rgb
+BIWIRGBDID Testing_Walking_037_037b_000291-a_191480695_rgb
+BIWIRGBDID Testing_Walking_037_037b_000299-a_191481694_rgb
+BIWIRGBDID Testing_Walking_037_037b_000308-a_191482778_rgb
+BIWIRGBDID Testing_Walking_037_037b_000322-a_191484194_rgb
+BIWIRGBDID Testing_Walking_037_037b_000323-a_191484362_rgb
+BIWIRGBDID Testing_Walking_037_037b_000345-a_191486610_rgb
+BIWIRGBDID Testing_Walking_039_039b_000002-a_1219323133_rgb
+BIWIRGBDID Testing_Walking_039_039b_000017-a_1219324469_rgb
+BIWIRGBDID Testing_Walking_039_039b_000033-a_1219326048_rgb
+BIWIRGBDID Testing_Walking_039_039b_000075-a_1219330465_rgb
+BIWIRGBDID Testing_Walking_039_039b_000083-a_1219331300_rgb
+BIWIRGBDID Testing_Walking_039_039b_000109-a_1219333632_rgb
+BIWIRGBDID Testing_Walking_039_039b_000123-a_1219334800_rgb
+BIWIRGBDID Testing_Walking_039_039b_000126-a_1219335048_rgb
+BIWIRGBDID Testing_Walking_039_039b_000136-a_1219335884_rgb
+BIWIRGBDID Testing_Walking_039_039b_000150-a_1219337300_rgb
+BIWIRGBDID Testing_Walking_039_039b_000158-a_1219338132_rgb
+BIWIRGBDID Testing_Walking_039_039b_000234-a_1219345216_rgb
+BIWIRGBDID Testing_Walking_039_039b_000253-a_1219346964_rgb
+BIWIRGBDID Testing_Walking_039_039b_000259-a_1219347632_rgb
+BIWIRGBDID Testing_Walking_039_039b_000261-a_1219347880_rgb
+BIWIRGBDID Testing_Walking_039_039b_000274-a_1219349300_rgb
+BIWIRGBDID Testing_Walking_039_039b_000286-a_1219350548_rgb
+BIWIRGBDID Testing_Walking_039_039b_000294-a_1219351380_rgb
+BIWIRGBDID Testing_Walking_039_039b_000295-a_1219351464_rgb
+BIWIRGBDID Testing_Walking_039_039b_000302-a_1219352216_rgb
+BIWIRGBDID Testing_Walking_039_039b_000304-a_1219352380_rgb
+BIWIRGBDID Testing_Walking_039_039b_000305-a_1219352464_rgb
+BIWIRGBDID Testing_Walking_039_039b_000327-a_1219354300_rgb
+BIWIRGBDID Testing_Walking_039_039b_000336-a_1219355048_rgb
+BIWIRGBDID Testing_Walking_039_039b_000375-a_1219358632_rgb
+BIWIRGBDID Testing_Walking_040_040b_000034-a_1231749844_rgb
+BIWIRGBDID Testing_Walking_040_040b_000047-a_1231751260_rgb
+BIWIRGBDID Testing_Walking_040_040b_000063-a_1231752924_rgb
+BIWIRGBDID Testing_Walking_040_040b_000074-a_1231754176_rgb
+BIWIRGBDID Testing_Walking_040_040b_000087-a_1231755508_rgb
+BIWIRGBDID Testing_Walking_040_040b_000121-a_1231759260_rgb
+BIWIRGBDID Testing_Walking_040_040b_000127-a_1231759840_rgb
+BIWIRGBDID Testing_Walking_040_040b_000129-a_1231760092_rgb
+BIWIRGBDID Testing_Walking_040_040b_000138-a_1231761260_rgb
+BIWIRGBDID Testing_Walking_040_040b_000148-a_1231762340_rgb
+BIWIRGBDID Testing_Walking_040_040b_000184-a_1231766260_rgb
+BIWIRGBDID Testing_Walking_040_040b_000250-a_1231773424_rgb
+BIWIRGBDID Testing_Walking_040_040b_000308-a_1231779840_rgb
+BIWIRGBDID Testing_Walking_040_040b_000384-a_1231787923_rgb
+BIWIRGBDID Testing_Walking_044_044b_000036-a_1214190213_rgb
+BIWIRGBDID Testing_Walking_044_044b_000105-a_1214196713_rgb
+BIWIRGBDID Testing_Walking_044_044b_000108-a_1214197045_rgb
+BIWIRGBDID Testing_Walking_044_044b_000134-a_1214199797_rgb
+BIWIRGBDID Testing_Walking_044_044b_000152-a_1214201381_rgb
+BIWIRGBDID Testing_Walking_044_044b_000161-a_1214202213_rgb
+BIWIRGBDID Testing_Walking_044_044b_000262-a_1214211712_rgb
+BIWIRGBDID Testing_Walking_044_044b_000266-a_1214212129_rgb
+BIWIRGBDID Testing_Walking_044_044b_000285-a_1214214128_rgb
+BIWIRGBDID Testing_Walking_044_044b_000309-a_1214216544_rgb
+BIWIRGBDID Testing_Walking_044_044b_000348-a_1214220128_rgb
+BIWIRGBDID Testing_Walking_044_044b_000354-a_1214220712_rgb
+BIWIRGBDID Testing_Walking_046_046b_000002-a_111236092_rgb
+BIWIRGBDID Testing_Walking_046_046b_000023-a_111238008_rgb
+BIWIRGBDID Testing_Walking_046_046b_000032-a_111238840_rgb
+BIWIRGBDID Testing_Walking_046_046b_000057-a_111241172_rgb
+BIWIRGBDID Testing_Walking_046_046b_000080-a_111243672_rgb
+BIWIRGBDID Testing_Walking_046_046b_000103-a_111246256_rgb
+BIWIRGBDID Testing_Walking_046_046b_000120-a_111247756_rgb
+BIWIRGBDID Testing_Walking_046_046b_000128-a_111248508_rgb
+BIWIRGBDID Testing_Walking_046_046b_000168-a_111252508_rgb
+BIWIRGBDID Testing_Walking_046_046b_000171-a_111252840_rgb
+BIWIRGBDID Testing_Walking_046_046b_000242-a_111259588_rgb
+BIWIRGBDID Testing_Walking_046_046b_000281-a_111263672_rgb
+BIWIRGBDID Testing_Walking_046_046b_000323-a_111267587_rgb
+BIWIRGBDID Testing_Walking_046_046b_000335-a_111268755_rgb
+BIWIRGBDID Testing_Walking_046_046b_000342-a_111269507_rgb
+BIWIRGBDID Testing_Walking_046_046b_000344-a_111269756_rgb
+BIWIRGBDID Testing_Walking_047_047b_000014-a_1214112719_rgb
+BIWIRGBDID Testing_Walking_047_047b_000024-a_1214113551_rgb
+BIWIRGBDID Testing_Walking_047_047b_000035-a_1214114635_rgb
+BIWIRGBDID Testing_Walking_047_047b_000070-a_1214118467_rgb
+BIWIRGBDID Testing_Walking_047_047b_000083-a_1214119719_rgb
+BIWIRGBDID Testing_Walking_047_047b_000094-a_1214120719_rgb
+BIWIRGBDID Testing_Walking_047_047b_000105-a_1214122135_rgb
+BIWIRGBDID Testing_Walking_047_047b_000128-a_1214124635_rgb
+BIWIRGBDID Testing_Walking_047_047b_000144-a_1214126551_rgb
+BIWIRGBDID Testing_Walking_047_047b_000146-a_1214126718_rgb
+BIWIRGBDID Testing_Walking_047_047b_000166-a_1214128634_rgb
+BIWIRGBDID Testing_Walking_047_047b_000186-a_1214130303_rgb
+BIWIRGBDID Testing_Walking_047_047b_000197-a_1214131298_rgb
+BIWIRGBDID Testing_Walking_047_047b_000207-a_1214132218_rgb
+BIWIRGBDID Testing_Walking_047_047b_000209-a_1214132382_rgb
+BIWIRGBDID Testing_Walking_047_047b_000213-a_1214132718_rgb
+BIWIRGBDID Testing_Walking_047_047b_000228-a_1214134299_rgb
+BIWIRGBDID Testing_Walking_047_047b_000261-a_1214138134_rgb
+BIWIRGBDID Testing_Walking_047_047b_000303-a_1214142218_rgb
+BIWIRGBDID Testing_Walking_047_047b_000308-a_1214142882_rgb
+BIWIRGBDID Testing_Walking_047_047b_000314-a_1214143466_rgb
+BIWIRGBDID Testing_Walking_047_047b_000336-a_1214145718_rgb
+BIWIRGBDID Testing_Walking_049_049b_000002-a_201380445_rgb
+BIWIRGBDID Testing_Walking_049_049b_000132-a_201394025_rgb
+BIWIRGBDID Testing_Walking_049_049b_000138-a_201394693_rgb
+BIWIRGBDID Testing_Walking_049_049b_000145-a_201395360_rgb
+BIWIRGBDID Testing_Walking_049_049b_000166-a_201397609_rgb
+BIWIRGBDID Testing_Walking_049_049b_000257-a_201407193_rgb
+BIWIRGBDID Testing_Walking_049_049b_000272-a_201408776_rgb
+BIWIRGBDID Testing_Walking_049_049b_000287-a_201410440_rgb
+BIWIRGBDID Testing_Walking_049_049b_000295-a_201411276_rgb
+BIWIRGBDID Testing_Walking_049_049b_000312-a_201413192_rgb
+BIWIRGBDID Testing_Walking_049_049b_000316-a_201413608_rgb
+BIWIRGBDID Testing_Walking_049_049b_000335-a_201415608_rgb
+BIWIRGBDID Testing_Walking_049_049b_000366-a_201418940_rgb
+BIWIRGBDID Testing_Walking_049_049b_000395-a_201422108_rgb
+BIWIRGBDID Testing_Walking_049_049b_000409-a_201423524_rgb
+BIWIRGBDID Testing_Walking_049_049b_000429-a_201425692_rgb

external/WildCamera/splits/cad120_test.txt

@@ -0,0 +1,800 @@
+CAD120_Subject1_rgbd_images_arranging_objects_sequence 1.jpg
+CAD120_Subject1_rgbd_images_arranging_objects_sequence 11.jpg
+CAD120_Subject1_rgbd_images_arranging_objects_sequence 61.jpg
+CAD120_Subject1_rgbd_images_arranging_objects_sequence 71.jpg
+CAD120_Subject1_rgbd_images_arranging_objects_sequence 121.jpg
+CAD120_Subject1_rgbd_images_arranging_objects_sequence 131.jpg
+CAD120_Subject1_rgbd_images_arranging_objects_sequence 141.jpg
+CAD120_Subject1_rgbd_images_arranging_objects_sequence 151.jpg
+CAD120_Subject1_rgbd_images_arranging_objects_sequence 161.jpg
+CAD120_Subject1_rgbd_images_arranging_objects_sequence 171.jpg
+CAD120_Subject1_rgbd_images_cleaning_objects_sequence 1.jpg
+CAD120_Subject1_rgbd_images_cleaning_objects_sequence 41.jpg
+CAD120_Subject1_rgbd_images_cleaning_objects_sequence 61.jpg
+CAD120_Subject1_rgbd_images_cleaning_objects_sequence 71.jpg
+CAD120_Subject1_rgbd_images_cleaning_objects_sequence 81.jpg
+CAD120_Subject1_rgbd_images_cleaning_objects_sequence 101.jpg
+CAD120_Subject1_rgbd_images_cleaning_objects_sequence 111.jpg
+CAD120_Subject1_rgbd_images_cleaning_objects_sequence 121.jpg
+CAD120_Subject1_rgbd_images_cleaning_objects_sequence 131.jpg
+CAD120_Subject1_rgbd_images_cleaning_objects_sequence 141.jpg
+CAD120_Subject1_rgbd_images_cleaning_objects_sequence 151.jpg
+CAD120_Subject1_rgbd_images_cleaning_objects_sequence 161.jpg
+CAD120_Subject1_rgbd_images_cleaning_objects_sequence 171.jpg
+CAD120_Subject1_rgbd_images_cleaning_objects_sequence 181.jpg
+CAD120_Subject1_rgbd_images_cleaning_objects_sequence 201.jpg
+CAD120_Subject1_rgbd_images_cleaning_objects_sequence 221.jpg
+CAD120_Subject1_rgbd_images_cleaning_objects_sequence 241.jpg
+CAD120_Subject1_rgbd_images_cleaning_objects_sequence 291.jpg
+CAD120_Subject1_rgbd_images_cleaning_objects_sequence 321.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 1.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 71.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 81.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 101.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 141.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 161.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 171.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 201.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 211.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 221.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 231.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 241.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 281.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 291.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 311.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 331.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 341.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 361.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 381.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 391.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 401.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 411.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 421.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 431.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 441.jpg
+CAD120_Subject1_rgbd_images_having_meal_sequence 471.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 1.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 11.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 41.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 51.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 81.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 91.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 101.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 111.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 131.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 151.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 161.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 171.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 211.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 221.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 231.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 261.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 281.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 301.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 321.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 351.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 371.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 381.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 401.jpg
+CAD120_Subject1_rgbd_images_making_cereal_sequence 421.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 1.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 11.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 21.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 31.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 41.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 91.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 101.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 111.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 121.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 131.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 141.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 191.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 201.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 221.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 231.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 241.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 261.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 281.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 291.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 301.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 321.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 341.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 351.jpg
+CAD120_Subject1_rgbd_images_microwaving_food_sequence 381.jpg
+CAD120_Subject1_rgbd_images_picking_objects_sequence 1.jpg
+CAD120_Subject1_rgbd_images_picking_objects_sequence 31.jpg
+CAD120_Subject1_rgbd_images_picking_objects_sequence 41.jpg
+CAD120_Subject1_rgbd_images_picking_objects_sequence 71.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 1.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 11.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 21.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 31.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 51.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 61.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 71.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 91.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 101.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 121.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 131.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 141.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 161.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 171.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 211.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 221.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 231.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 241.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 251.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 271.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 281.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 301.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 321.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 341.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 351.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 361.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 371.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 381.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 401.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 411.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 421.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 441.jpg
+CAD120_Subject1_rgbd_images_stacking_objects_sequence 461.jpg
+CAD120_Subject1_rgbd_images_taking_food_sequence 11.jpg
+CAD120_Subject1_rgbd_images_taking_food_sequence 21.jpg
+CAD120_Subject1_rgbd_images_taking_food_sequence 31.jpg
+CAD120_Subject1_rgbd_images_taking_food_sequence 41.jpg
+CAD120_Subject1_rgbd_images_taking_food_sequence 71.jpg
+CAD120_Subject1_rgbd_images_taking_food_sequence 81.jpg
+CAD120_Subject1_rgbd_images_taking_food_sequence 91.jpg
+CAD120_Subject1_rgbd_images_taking_food_sequence 111.jpg
+CAD120_Subject1_rgbd_images_taking_food_sequence 131.jpg
+CAD120_Subject1_rgbd_images_taking_medicine_sequence 21.jpg
+CAD120_Subject1_rgbd_images_taking_medicine_sequence 31.jpg
+CAD120_Subject1_rgbd_images_taking_medicine_sequence 41.jpg
+CAD120_Subject1_rgbd_images_taking_medicine_sequence 51.jpg
+CAD120_Subject1_rgbd_images_taking_medicine_sequence 71.jpg
+CAD120_Subject1_rgbd_images_taking_medicine_sequence 81.jpg
+CAD120_Subject1_rgbd_images_taking_medicine_sequence 91.jpg
+CAD120_Subject1_rgbd_images_taking_medicine_sequence 101.jpg
+CAD120_Subject1_rgbd_images_taking_medicine_sequence 111.jpg
+CAD120_Subject1_rgbd_images_taking_medicine_sequence 121.jpg
+CAD120_Subject1_rgbd_images_taking_medicine_sequence 131.jpg
+CAD120_Subject1_rgbd_images_taking_medicine_sequence 141.jpg
+CAD120_Subject1_rgbd_images_taking_medicine_sequence 151.jpg
+CAD120_Subject1_rgbd_images_taking_medicine_sequence 171.jpg
+CAD120_Subject1_rgbd_images_taking_medicine_sequence 201.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 1.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 11.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 51.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 61.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 71.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 81.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 111.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 141.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 151.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 161.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 181.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 201.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 221.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 231.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 241.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 261.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 291.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 311.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 351.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 361.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 371.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 391.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 401.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 461.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 471.jpg
+CAD120_Subject1_rgbd_images_unstacking_objects_sequence 501.jpg
+CAD120_Subject3_rgbd_images_arranging_objects_sequence 1.jpg
+CAD120_Subject3_rgbd_images_arranging_objects_sequence 11.jpg
+CAD120_Subject3_rgbd_images_arranging_objects_sequence 21.jpg
+CAD120_Subject3_rgbd_images_arranging_objects_sequence 31.jpg
+CAD120_Subject3_rgbd_images_arranging_objects_sequence 41.jpg
+CAD120_Subject3_rgbd_images_arranging_objects_sequence 51.jpg
+CAD120_Subject3_rgbd_images_arranging_objects_sequence 61.jpg
+CAD120_Subject3_rgbd_images_arranging_objects_sequence 71.jpg
+CAD120_Subject3_rgbd_images_arranging_objects_sequence 81.jpg
+CAD120_Subject3_rgbd_images_arranging_objects_sequence 101.jpg
+CAD120_Subject3_rgbd_images_arranging_objects_sequence 111.jpg
+CAD120_Subject3_rgbd_images_arranging_objects_sequence 131.jpg
+CAD120_Subject3_rgbd_images_arranging_objects_sequence 141.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 1.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 21.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 31.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 41.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 61.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 71.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 101.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 141.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 161.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 181.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 191.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 211.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 221.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 241.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 251.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 261.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 271.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 281.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 291.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 311.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 331.jpg
+CAD120_Subject3_rgbd_images_cleaning_objects_sequence 341.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 1.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 11.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 21.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 51.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 61.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 91.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 101.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 111.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 121.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 131.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 151.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 201.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 221.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 241.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 261.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 271.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 301.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 321.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 341.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 371.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 381.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 411.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 421.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 441.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 461.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 471.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 481.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 491.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 501.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 521.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 531.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 551.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 611.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 621.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 651.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 661.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 671.jpg
+CAD120_Subject3_rgbd_images_having_meal_sequence 691.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 41.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 51.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 61.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 71.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 111.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 141.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 151.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 161.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 171.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 211.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 231.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 241.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 291.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 301.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 321.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 341.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 351.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 361.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 371.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 411.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 421.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 431.jpg
+CAD120_Subject3_rgbd_images_making_cereal_sequence 441.jpg
+CAD120_Subject3_rgbd_images_microwaving_food_sequence 1.jpg
+CAD120_Subject3_rgbd_images_microwaving_food_sequence 11.jpg
+CAD120_Subject3_rgbd_images_microwaving_food_sequence 41.jpg
+CAD120_Subject3_rgbd_images_microwaving_food_sequence 51.jpg
+CAD120_Subject3_rgbd_images_microwaving_food_sequence 91.jpg
+CAD120_Subject3_rgbd_images_microwaving_food_sequence 101.jpg
+CAD120_Subject3_rgbd_images_microwaving_food_sequence 121.jpg
+CAD120_Subject3_rgbd_images_microwaving_food_sequence 141.jpg
+CAD120_Subject3_rgbd_images_microwaving_food_sequence 151.jpg
+CAD120_Subject3_rgbd_images_microwaving_food_sequence 161.jpg
+CAD120_Subject3_rgbd_images_microwaving_food_sequence 191.jpg
+CAD120_Subject3_rgbd_images_microwaving_food_sequence 211.jpg
+CAD120_Subject3_rgbd_images_microwaving_food_sequence 221.jpg
+CAD120_Subject3_rgbd_images_microwaving_food_sequence 231.jpg
+CAD120_Subject3_rgbd_images_microwaving_food_sequence 241.jpg
+CAD120_Subject3_rgbd_images_microwaving_food_sequence 251.jpg
+CAD120_Subject3_rgbd_images_microwaving_food_sequence 301.jpg
+CAD120_Subject3_rgbd_images_microwaving_food_sequence 311.jpg
+CAD120_Subject3_rgbd_images_microwaving_food_sequence 331.jpg
+CAD120_Subject3_rgbd_images_picking_objects_sequence 1.jpg
+CAD120_Subject3_rgbd_images_picking_objects_sequence 11.jpg
+CAD120_Subject3_rgbd_images_picking_objects_sequence 71.jpg
+CAD120_Subject3_rgbd_images_picking_objects_sequence 81.jpg
+CAD120_Subject3_rgbd_images_picking_objects_sequence 101.jpg
+CAD120_Subject3_rgbd_images_picking_objects_sequence 111.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 1.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 11.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 41.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 51.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 61.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 71.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 81.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 91.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 101.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 111.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 161.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 171.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 181.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 191.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 201.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 221.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 231.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 241.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 251.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 291.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 321.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 331.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 371.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 381.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 391.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 401.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 411.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 421.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 431.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 471.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 481.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 491.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 501.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 521.jpg
+CAD120_Subject3_rgbd_images_stacking_objects_sequence 551.jpg
+CAD120_Subject3_rgbd_images_taking_food_sequence 21.jpg
+CAD120_Subject3_rgbd_images_taking_food_sequence 31.jpg
+CAD120_Subject3_rgbd_images_taking_food_sequence 51.jpg
+CAD120_Subject3_rgbd_images_taking_food_sequence 81.jpg
+CAD120_Subject3_rgbd_images_taking_food_sequence 101.jpg
+CAD120_Subject3_rgbd_images_taking_food_sequence 111.jpg
+CAD120_Subject3_rgbd_images_taking_food_sequence 141.jpg
+CAD120_Subject3_rgbd_images_taking_food_sequence 161.jpg
+CAD120_Subject3_rgbd_images_taking_food_sequence 181.jpg
+CAD120_Subject3_rgbd_images_taking_food_sequence 201.jpg
+CAD120_Subject3_rgbd_images_taking_food_sequence 211.jpg
+CAD120_Subject3_rgbd_images_taking_food_sequence 231.jpg
+CAD120_Subject3_rgbd_images_taking_food_sequence 241.jpg
+CAD120_Subject3_rgbd_images_taking_food_sequence 251.jpg
+CAD120_Subject3_rgbd_images_taking_food_sequence 271.jpg
+CAD120_Subject3_rgbd_images_taking_food_sequence 291.jpg
+CAD120_Subject3_rgbd_images_taking_medicine_sequence 1.jpg
+CAD120_Subject3_rgbd_images_taking_medicine_sequence 11.jpg
+CAD120_Subject3_rgbd_images_taking_medicine_sequence 21.jpg
+CAD120_Subject3_rgbd_images_taking_medicine_sequence 31.jpg
+CAD120_Subject3_rgbd_images_taking_medicine_sequence 61.jpg
+CAD120_Subject3_rgbd_images_taking_medicine_sequence 71.jpg
+CAD120_Subject3_rgbd_images_taking_medicine_sequence 101.jpg
+CAD120_Subject3_rgbd_images_taking_medicine_sequence 111.jpg
+CAD120_Subject3_rgbd_images_taking_medicine_sequence 131.jpg
+CAD120_Subject3_rgbd_images_taking_medicine_sequence 151.jpg
+CAD120_Subject3_rgbd_images_taking_medicine_sequence 211.jpg
+CAD120_Subject3_rgbd_images_taking_medicine_sequence 231.jpg
+CAD120_Subject3_rgbd_images_taking_medicine_sequence 261.jpg
+CAD120_Subject3_rgbd_images_taking_medicine_sequence 301.jpg
+CAD120_Subject3_rgbd_images_taking_medicine_sequence 311.jpg
+CAD120_Subject3_rgbd_images_taking_medicine_sequence 321.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 11.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 21.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 31.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 41.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 61.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 71.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 81.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 101.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 111.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 131.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 141.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 151.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 171.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 191.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 221.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 231.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 251.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 261.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 281.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 301.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 321.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 341.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 351.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 451.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 471.jpg
+CAD120_Subject3_rgbd_images_unstacking_objects_sequence 501.jpg
+CAD120_Subject4_rgbd_images_arranging_objects_sequence 1.jpg
+CAD120_Subject4_rgbd_images_arranging_objects_sequence 11.jpg
+CAD120_Subject4_rgbd_images_arranging_objects_sequence 21.jpg
+CAD120_Subject4_rgbd_images_arranging_objects_sequence 31.jpg
+CAD120_Subject4_rgbd_images_arranging_objects_sequence 71.jpg
+CAD120_Subject4_rgbd_images_arranging_objects_sequence 91.jpg
+CAD120_Subject4_rgbd_images_arranging_objects_sequence 101.jpg
+CAD120_Subject4_rgbd_images_arranging_objects_sequence 111.jpg
+CAD120_Subject4_rgbd_images_arranging_objects_sequence 121.jpg
+CAD120_Subject4_rgbd_images_arranging_objects_sequence 131.jpg
+CAD120_Subject4_rgbd_images_arranging_objects_sequence 141.jpg
+CAD120_Subject4_rgbd_images_arranging_objects_sequence 161.jpg
+CAD120_Subject4_rgbd_images_arranging_objects_sequence 171.jpg
+CAD120_Subject4_rgbd_images_arranging_objects_sequence 181.jpg
+CAD120_Subject4_rgbd_images_arranging_objects_sequence 201.jpg
+CAD120_Subject4_rgbd_images_arranging_objects_sequence 211.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 11.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 21.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 31.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 51.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 71.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 81.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 141.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 171.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 191.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 201.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 211.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 221.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 241.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 251.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 261.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 271.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 291.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 301.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 331.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 341.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 351.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 371.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 381.jpg
+CAD120_Subject4_rgbd_images_cleaning_objects_sequence 401.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 1.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 21.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 41.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 71.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 101.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 121.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 141.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 151.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 161.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 171.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 181.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 201.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 221.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 231.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 241.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 251.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 271.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 311.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 331.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 341.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 351.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 361.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 371.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 401.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 411.jpg
+CAD120_Subject4_rgbd_images_having_meal_sequence 461.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 1.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 31.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 61.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 71.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 81.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 91.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 111.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 121.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 151.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 191.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 211.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 221.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 231.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 241.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 251.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 271.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 281.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 291.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 301.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 321.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 341.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 351.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 371.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 381.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 391.jpg
+CAD120_Subject4_rgbd_images_making_cereal_sequence 401.jpg
+CAD120_Subject4_rgbd_images_microwaving_food_sequence 11.jpg
+CAD120_Subject4_rgbd_images_microwaving_food_sequence 21.jpg
+CAD120_Subject4_rgbd_images_microwaving_food_sequence 61.jpg
+CAD120_Subject4_rgbd_images_picking_objects_sequence 11.jpg
+CAD120_Subject4_rgbd_images_picking_objects_sequence 21.jpg
+CAD120_Subject4_rgbd_images_picking_objects_sequence 31.jpg
+CAD120_Subject4_rgbd_images_picking_objects_sequence 61.jpg
+CAD120_Subject4_rgbd_images_picking_objects_sequence 71.jpg
+CAD120_Subject4_rgbd_images_picking_objects_sequence 91.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 1.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 11.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 21.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 31.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 61.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 71.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 111.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 151.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 161.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 171.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 181.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 191.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 211.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 221.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 231.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 241.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 251.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 271.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 291.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 311.jpg
+CAD120_Subject4_rgbd_images_stacking_objects_sequence 321.jpg
+CAD120_Subject4_rgbd_images_taking_food_sequence 1.jpg
+CAD120_Subject4_rgbd_images_taking_food_sequence 11.jpg
+CAD120_Subject4_rgbd_images_taking_food_sequence 21.jpg
+CAD120_Subject4_rgbd_images_taking_food_sequence 41.jpg
+CAD120_Subject4_rgbd_images_taking_food_sequence 71.jpg
+CAD120_Subject4_rgbd_images_taking_food_sequence 91.jpg
+CAD120_Subject4_rgbd_images_taking_food_sequence 101.jpg
+CAD120_Subject4_rgbd_images_taking_food_sequence 141.jpg
+CAD120_Subject4_rgbd_images_taking_food_sequence 151.jpg
+CAD120_Subject4_rgbd_images_taking_food_sequence 161.jpg
+CAD120_Subject4_rgbd_images_taking_food_sequence 171.jpg
+CAD120_Subject4_rgbd_images_taking_food_sequence 181.jpg
+CAD120_Subject4_rgbd_images_taking_food_sequence 201.jpg
+CAD120_Subject4_rgbd_images_taking_food_sequence 241.jpg
+CAD120_Subject4_rgbd_images_taking_food_sequence 261.jpg
+CAD120_Subject4_rgbd_images_taking_food_sequence 281.jpg
+CAD120_Subject4_rgbd_images_taking_food_sequence 311.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 31.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 51.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 61.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 71.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 81.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 91.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 121.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 141.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 151.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 171.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 181.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 191.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 221.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 231.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 241.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 261.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 271.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 281.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 291.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 301.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 321.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 331.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 341.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 371.jpg
+CAD120_Subject4_rgbd_images_taking_medicine_sequence 381.jpg
+CAD120_Subject4_rgbd_images_unstacking_objects_sequence 1.jpg
+CAD120_Subject4_rgbd_images_unstacking_objects_sequence 31.jpg
+CAD120_Subject4_rgbd_images_unstacking_objects_sequence 51.jpg
+CAD120_Subject4_rgbd_images_unstacking_objects_sequence 61.jpg
+CAD120_Subject4_rgbd_images_unstacking_objects_sequence 71.jpg
+CAD120_Subject4_rgbd_images_unstacking_objects_sequence 81.jpg
+CAD120_Subject4_rgbd_images_unstacking_objects_sequence 91.jpg
+CAD120_Subject4_rgbd_images_unstacking_objects_sequence 111.jpg
+CAD120_Subject4_rgbd_images_unstacking_objects_sequence 131.jpg
+CAD120_Subject4_rgbd_images_unstacking_objects_sequence 141.jpg
+CAD120_Subject4_rgbd_images_unstacking_objects_sequence 151.jpg
+CAD120_Subject4_rgbd_images_unstacking_objects_sequence 161.jpg
+CAD120_Subject4_rgbd_images_unstacking_objects_sequence 171.jpg
+CAD120_Subject4_rgbd_images_unstacking_objects_sequence 191.jpg
+CAD120_Subject4_rgbd_images_unstacking_objects_sequence 201.jpg
+CAD120_Subject4_rgbd_images_unstacking_objects_sequence 221.jpg
+CAD120_Subject4_rgbd_images_unstacking_objects_sequence 241.jpg
+CAD120_Subject4_rgbd_images_unstacking_objects_sequence 251.jpg
+CAD120_Subject4_rgbd_images_unstacking_objects_sequence 261.jpg
+CAD120_Subject4_rgbd_images_unstacking_objects_sequence 271.jpg
+CAD120_Subject5_rgbd_images_arranging_objects_sequence 11.jpg
+CAD120_Subject5_rgbd_images_arranging_objects_sequence 21.jpg
+CAD120_Subject5_rgbd_images_arranging_objects_sequence 31.jpg
+CAD120_Subject5_rgbd_images_arranging_objects_sequence 41.jpg
+CAD120_Subject5_rgbd_images_arranging_objects_sequence 71.jpg
+CAD120_Subject5_rgbd_images_arranging_objects_sequence 81.jpg
+CAD120_Subject5_rgbd_images_cleaning_objects_sequence 21.jpg
+CAD120_Subject5_rgbd_images_cleaning_objects_sequence 31.jpg
+CAD120_Subject5_rgbd_images_cleaning_objects_sequence 51.jpg
+CAD120_Subject5_rgbd_images_cleaning_objects_sequence 71.jpg
+CAD120_Subject5_rgbd_images_cleaning_objects_sequence 81.jpg
+CAD120_Subject5_rgbd_images_cleaning_objects_sequence 101.jpg
+CAD120_Subject5_rgbd_images_cleaning_objects_sequence 111.jpg
+CAD120_Subject5_rgbd_images_cleaning_objects_sequence 121.jpg
+CAD120_Subject5_rgbd_images_cleaning_objects_sequence 131.jpg
+CAD120_Subject5_rgbd_images_cleaning_objects_sequence 141.jpg
+CAD120_Subject5_rgbd_images_cleaning_objects_sequence 151.jpg
+CAD120_Subject5_rgbd_images_cleaning_objects_sequence 171.jpg
+CAD120_Subject5_rgbd_images_cleaning_objects_sequence 201.jpg
+CAD120_Subject5_rgbd_images_cleaning_objects_sequence 211.jpg
+CAD120_Subject5_rgbd_images_cleaning_objects_sequence 221.jpg
+CAD120_Subject5_rgbd_images_cleaning_objects_sequence 231.jpg
+CAD120_Subject5_rgbd_images_cleaning_objects_sequence 251.jpg
+CAD120_Subject5_rgbd_images_cleaning_objects_sequence 271.jpg
+CAD120_Subject5_rgbd_images_cleaning_objects_sequence 281.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 1.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 11.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 21.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 31.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 41.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 61.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 101.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 111.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 151.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 201.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 221.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 251.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 271.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 281.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 351.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 361.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 371.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 381.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 421.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 431.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 441.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 451.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 461.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 471.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 481.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 531.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 541.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 551.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 561.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 581.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 621.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 641.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 651.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 671.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 681.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 691.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 701.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 711.jpg
+CAD120_Subject5_rgbd_images_having_meal_sequence 721.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 11.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 31.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 41.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 71.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 91.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 101.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 121.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 161.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 171.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 181.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 191.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 221.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 241.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 271.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 281.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 301.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 331.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 341.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 351.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 361.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 371.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 381.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 391.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 411.jpg
+CAD120_Subject5_rgbd_images_making_cereal_sequence 441.jpg
+CAD120_Subject5_rgbd_images_microwaving_food_sequence 1.jpg
+CAD120_Subject5_rgbd_images_microwaving_food_sequence 11.jpg
+CAD120_Subject5_rgbd_images_microwaving_food_sequence 21.jpg
+CAD120_Subject5_rgbd_images_microwaving_food_sequence 31.jpg
+CAD120_Subject5_rgbd_images_microwaving_food_sequence 41.jpg
+CAD120_Subject5_rgbd_images_microwaving_food_sequence 61.jpg
+CAD120_Subject5_rgbd_images_microwaving_food_sequence 81.jpg
+CAD120_Subject5_rgbd_images_microwaving_food_sequence 91.jpg
+CAD120_Subject5_rgbd_images_microwaving_food_sequence 101.jpg
+CAD120_Subject5_rgbd_images_microwaving_food_sequence 111.jpg
+CAD120_Subject5_rgbd_images_microwaving_food_sequence 121.jpg
+CAD120_Subject5_rgbd_images_microwaving_food_sequence 131.jpg
+CAD120_Subject5_rgbd_images_microwaving_food_sequence 161.jpg
+CAD120_Subject5_rgbd_images_microwaving_food_sequence 171.jpg
+CAD120_Subject5_rgbd_images_microwaving_food_sequence 181.jpg
+CAD120_Subject5_rgbd_images_microwaving_food_sequence 191.jpg
+CAD120_Subject5_rgbd_images_microwaving_food_sequence 231.jpg
+CAD120_Subject5_rgbd_images_microwaving_food_sequence 241.jpg
+CAD120_Subject5_rgbd_images_microwaving_food_sequence 271.jpg
+CAD120_Subject5_rgbd_images_picking_objects_sequence 1.jpg
+CAD120_Subject5_rgbd_images_picking_objects_sequence 11.jpg
+CAD120_Subject5_rgbd_images_picking_objects_sequence 21.jpg
+CAD120_Subject5_rgbd_images_picking_objects_sequence 51.jpg
+CAD120_Subject5_rgbd_images_picking_objects_sequence 81.jpg
+CAD120_Subject5_rgbd_images_picking_objects_sequence 121.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 1.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 11.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 41.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 51.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 61.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 81.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 91.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 101.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 111.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 141.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 161.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 191.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 281.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 291.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 301.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 311.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 331.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 351.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 361.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 371.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 381.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 391.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 401.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 421.jpg
+CAD120_Subject5_rgbd_images_stacking_objects_sequence 431.jpg
+CAD120_Subject5_rgbd_images_taking_food_sequence 11.jpg
+CAD120_Subject5_rgbd_images_taking_food_sequence 51.jpg
+CAD120_Subject5_rgbd_images_taking_food_sequence 71.jpg
+CAD120_Subject5_rgbd_images_taking_food_sequence 81.jpg
+CAD120_Subject5_rgbd_images_taking_food_sequence 101.jpg
+CAD120_Subject5_rgbd_images_taking_food_sequence 111.jpg
+CAD120_Subject5_rgbd_images_taking_food_sequence 121.jpg
+CAD120_Subject5_rgbd_images_taking_food_sequence 131.jpg
+CAD120_Subject5_rgbd_images_taking_food_sequence 141.jpg
+CAD120_Subject5_rgbd_images_taking_food_sequence 171.jpg
+CAD120_Subject5_rgbd_images_taking_food_sequence 191.jpg
+CAD120_Subject5_rgbd_images_taking_food_sequence 211.jpg
+CAD120_Subject5_rgbd_images_taking_food_sequence 221.jpg
+CAD120_Subject5_rgbd_images_taking_food_sequence 231.jpg
+CAD120_Subject5_rgbd_images_taking_food_sequence 241.jpg
+CAD120_Subject5_rgbd_images_taking_food_sequence 261.jpg
+CAD120_Subject5_rgbd_images_taking_food_sequence 311.jpg
+CAD120_Subject5_rgbd_images_taking_food_sequence 321.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 1.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 41.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 51.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 61.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 81.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 91.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 101.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 111.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 121.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 131.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 151.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 161.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 171.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 181.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 211.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 231.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 241.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 251.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 271.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 281.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 311.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 331.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 341.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 351.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 361.jpg
+CAD120_Subject5_rgbd_images_taking_medicine_sequence 391.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 11.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 51.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 61.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 71.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 151.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 161.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 171.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 181.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 191.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 201.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 211.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 241.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 261.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 271.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 281.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 321.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 331.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 371.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 381.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 401.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 411.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 421.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 431.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 441.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 461.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 481.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 491.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 511.jpg
+CAD120_Subject5_rgbd_images_unstacking_objects_sequence 521.jpg

external/WildCamera/splits/cityscapes_test.txt

@@ -0,0 +1,800 @@
+berlin berlin_000000_000019
+berlin berlin_000001_000019
+berlin berlin_000002_000019
+berlin berlin_000004_000019
+berlin berlin_000005_000019
+berlin berlin_000009_000019
+berlin berlin_000013_000019
+berlin berlin_000014_000019
+berlin berlin_000016_000019
+berlin berlin_000018_000019
+berlin berlin_000019_000019
+berlin berlin_000020_000019
+berlin berlin_000021_000019
+berlin berlin_000022_000019
+berlin berlin_000023_000019
+berlin berlin_000026_000019
+berlin berlin_000027_000019
+berlin berlin_000029_000019
+berlin berlin_000033_000019
+berlin berlin_000036_000019
+berlin berlin_000037_000019
+berlin berlin_000038_000019
+berlin berlin_000039_000019
+berlin berlin_000040_000019
+berlin berlin_000041_000019
+berlin berlin_000042_000019
+berlin berlin_000044_000019
+berlin berlin_000046_000019
+berlin berlin_000051_000019
+berlin berlin_000052_000019
+berlin berlin_000053_000019
+berlin berlin_000056_000019
+berlin berlin_000058_000019
+berlin berlin_000063_000019
+berlin berlin_000066_000019
+berlin berlin_000068_000019
+berlin berlin_000069_000019
+berlin berlin_000072_000019
+berlin berlin_000073_000019
+berlin berlin_000074_000019
+berlin berlin_000079_000019
+berlin berlin_000080_000019
+berlin berlin_000081_000019
+berlin berlin_000082_000019
+berlin berlin_000083_000019
+berlin berlin_000085_000019
+berlin berlin_000086_000019
+berlin berlin_000087_000019
+berlin berlin_000088_000019
+berlin berlin_000089_000019
+berlin berlin_000090_000019
+berlin berlin_000091_000019
+berlin berlin_000092_000019
+berlin berlin_000093_000019
+berlin berlin_000094_000019
+berlin berlin_000096_000019
+berlin berlin_000097_000019
+berlin berlin_000098_000019
+berlin berlin_000099_000019
+berlin berlin_000102_000019
+berlin berlin_000106_000019
+berlin berlin_000108_000019
+berlin berlin_000109_000019
+berlin berlin_000114_000019
+berlin berlin_000116_000019
+berlin berlin_000117_000019
+berlin berlin_000122_000019
+berlin berlin_000123_000019
+berlin berlin_000126_000019
+berlin berlin_000128_000019
+berlin berlin_000131_000019
+berlin berlin_000135_000019
+berlin berlin_000137_000019
+berlin berlin_000138_000019
+berlin berlin_000141_000019
+berlin berlin_000144_000019
+berlin berlin_000145_000019
+berlin berlin_000146_000019
+berlin berlin_000147_000019
+berlin berlin_000148_000019
+berlin berlin_000149_000019
+berlin berlin_000153_000019
+berlin berlin_000155_000019
+berlin berlin_000156_000019
+berlin berlin_000157_000019
+berlin berlin_000158_000019
+berlin berlin_000162_000019
+berlin berlin_000163_000019
+berlin berlin_000164_000019
+berlin berlin_000169_000019
+berlin berlin_000171_000019
+berlin berlin_000172_000019
+berlin berlin_000178_000019
+berlin berlin_000181_000019
+berlin berlin_000182_000019
+berlin berlin_000184_000019
+berlin berlin_000185_000019
+berlin berlin_000186_000019
+berlin berlin_000187_000019
+berlin berlin_000188_000019
+berlin berlin_000192_000019
+berlin berlin_000195_000019
+berlin berlin_000196_000019
+berlin berlin_000198_000019
+berlin berlin_000203_000019
+berlin berlin_000206_000019
+berlin berlin_000211_000019
+berlin berlin_000212_000019
+berlin berlin_000215_000019
+berlin berlin_000217_000019
+berlin berlin_000222_000019
+berlin berlin_000224_000019
+berlin berlin_000226_000019
+berlin berlin_000227_000019
+berlin berlin_000229_000019
+berlin berlin_000230_000019
+berlin berlin_000233_000019
+berlin berlin_000235_000019
+berlin berlin_000236_000019
+berlin berlin_000238_000019
+berlin berlin_000239_000019
+berlin berlin_000241_000019
+berlin berlin_000244_000019
+berlin berlin_000247_000019
+berlin berlin_000248_000019
+berlin berlin_000249_000019
+berlin berlin_000255_000019
+berlin berlin_000258_000019
+berlin berlin_000262_000019
+berlin berlin_000270_000019
+berlin berlin_000271_000019
+berlin berlin_000272_000019
+berlin berlin_000275_000019
+berlin berlin_000277_000019
+berlin berlin_000278_000019
+berlin berlin_000279_000019
+berlin berlin_000280_000019
+berlin berlin_000283_000019
+berlin berlin_000286_000019
+berlin berlin_000287_000019
+berlin berlin_000292_000019
+berlin berlin_000294_000019
+berlin berlin_000299_000019
+berlin berlin_000302_000019
+berlin berlin_000305_000019
+berlin berlin_000306_000019
+berlin berlin_000311_000019
+berlin berlin_000312_000019
+berlin berlin_000318_000019
+berlin berlin_000319_000019
+berlin berlin_000326_000019
+berlin berlin_000327_000019
+berlin berlin_000328_000019
+berlin berlin_000329_000019
+berlin berlin_000331_000019
+berlin berlin_000332_000019
+berlin berlin_000333_000019
+berlin berlin_000335_000019
+berlin berlin_000338_000019
+berlin berlin_000339_000019
+berlin berlin_000340_000019
+berlin berlin_000341_000019
+berlin berlin_000343_000019
+berlin berlin_000344_000019
+berlin berlin_000346_000019
+berlin berlin_000347_000019
+berlin berlin_000348_000019
+berlin berlin_000349_000019
+berlin berlin_000350_000019
+berlin berlin_000353_000019
+berlin berlin_000354_000019
+berlin berlin_000355_000019
+berlin berlin_000356_000019
+berlin berlin_000361_000019
+berlin berlin_000363_000019
+berlin berlin_000365_000019
+berlin berlin_000366_000019
+berlin berlin_000368_000019
+berlin berlin_000371_000019
+berlin berlin_000372_000019
+berlin berlin_000374_000019
+berlin berlin_000375_000019
+berlin berlin_000376_000019
+berlin berlin_000377_000019
+berlin berlin_000380_000019
+berlin berlin_000381_000019
+berlin berlin_000382_000019
+berlin berlin_000385_000019
+berlin berlin_000387_000019
+berlin berlin_000389_000019
+berlin berlin_000390_000019
+berlin berlin_000396_000019
+berlin berlin_000397_000019
+berlin berlin_000400_000019
+berlin berlin_000401_000019
+berlin berlin_000403_000019
+berlin berlin_000404_000019
+berlin berlin_000407_000019
+berlin berlin_000409_000019
+berlin berlin_000410_000019
+berlin berlin_000412_000019
+berlin berlin_000415_000019
+berlin berlin_000416_000019
+berlin berlin_000417_000019
+berlin berlin_000418_000019
+berlin berlin_000421_000019
+berlin berlin_000422_000019
+berlin berlin_000424_000019
+berlin berlin_000425_000019
+berlin berlin_000427_000019
+berlin berlin_000429_000019
+berlin berlin_000430_000019
+berlin berlin_000431_000019
+berlin berlin_000432_000019
+berlin berlin_000435_000019
+berlin berlin_000436_000019
+berlin berlin_000437_000019
+berlin berlin_000440_000019
+berlin berlin_000444_000019
+berlin berlin_000445_000019
+berlin berlin_000447_000019
+berlin berlin_000451_000019
+berlin berlin_000453_000019
+berlin berlin_000454_000019
+berlin berlin_000456_000019
+berlin berlin_000458_000019
+berlin berlin_000461_000019
+berlin berlin_000465_000019
+berlin berlin_000466_000019
+berlin berlin_000468_000019
+berlin berlin_000469_000019
+berlin berlin_000471_000019
+berlin berlin_000472_000019
+berlin berlin_000473_000019
+berlin berlin_000479_000019
+berlin berlin_000482_000019
+berlin berlin_000484_000019
+berlin berlin_000485_000019
+berlin berlin_000486_000019
+berlin berlin_000490_000019
+berlin berlin_000491_000019
+berlin berlin_000492_000019
+berlin berlin_000493_000019
+berlin berlin_000498_000019
+berlin berlin_000502_000019
+berlin berlin_000503_000019
+berlin berlin_000504_000019
+berlin berlin_000505_000019
+berlin berlin_000507_000019
+berlin berlin_000510_000019
+berlin berlin_000511_000019
+berlin berlin_000512_000019
+berlin berlin_000514_000019
+berlin berlin_000515_000019
+berlin berlin_000516_000019
+berlin berlin_000518_000019
+berlin berlin_000519_000019
+berlin berlin_000521_000019
+berlin berlin_000522_000019
+berlin berlin_000523_000019
+berlin berlin_000524_000019
+berlin berlin_000525_000019
+berlin berlin_000527_000019
+berlin berlin_000529_000019
+berlin berlin_000530_000019
+berlin berlin_000531_000019
+berlin berlin_000532_000019
+berlin berlin_000536_000019
+berlin berlin_000539_000019
+berlin berlin_000541_000019
+bielefeld bielefeld_000000_001187
+bielefeld bielefeld_000000_001505
+bielefeld bielefeld_000000_002308
+bielefeld bielefeld_000000_003406
+bielefeld bielefeld_000000_003546
+bielefeld bielefeld_000000_003731
+bielefeld bielefeld_000000_005068
+bielefeld bielefeld_000000_005584
+bielefeld bielefeld_000000_006239
+bielefeld bielefeld_000000_006802
+bielefeld bielefeld_000000_007030
+bielefeld bielefeld_000000_008279
+bielefeld bielefeld_000000_008581
+bielefeld bielefeld_000000_008800
+bielefeld bielefeld_000000_009728
+bielefeld bielefeld_000000_009928
+bielefeld bielefeld_000000_011367
+bielefeld bielefeld_000000_011831
+bielefeld bielefeld_000000_012080
+bielefeld bielefeld_000000_012788
+bielefeld bielefeld_000000_013570
+bielefeld bielefeld_000000_013814
+bielefeld bielefeld_000000_015301
+bielefeld bielefeld_000000_015867
+bielefeld bielefeld_000000_016019
+bielefeld bielefeld_000000_017051
+bielefeld bielefeld_000000_017774
+bielefeld bielefeld_000000_018102
+bielefeld bielefeld_000000_018644
+bielefeld bielefeld_000000_019416
+bielefeld bielefeld_000000_020757
+bielefeld bielefeld_000000_020900
+bielefeld bielefeld_000000_021341
+bielefeld bielefeld_000000_021381
+bielefeld bielefeld_000000_022261
+bielefeld bielefeld_000000_022835
+bielefeld bielefeld_000000_025061
+bielefeld bielefeld_000000_025748
+bielefeld bielefeld_000000_026053
+bielefeld bielefeld_000000_026550
+bielefeld bielefeld_000000_026660
+bielefeld bielefeld_000000_026823
+bielefeld bielefeld_000000_027221
+bielefeld bielefeld_000000_027586
+bielefeld bielefeld_000000_027928
+bielefeld bielefeld_000000_028148
+bielefeld bielefeld_000000_028550
+bielefeld bielefeld_000000_030038
+bielefeld bielefeld_000000_030958
+bielefeld bielefeld_000000_031244
+bielefeld bielefeld_000000_032388
+bielefeld bielefeld_000000_033770
+bielefeld bielefeld_000000_035537
+bielefeld bielefeld_000000_035879
+bielefeld bielefeld_000000_036362
+bielefeld bielefeld_000000_036732
+bielefeld bielefeld_000000_037016
+bielefeld bielefeld_000000_037422
+bielefeld bielefeld_000000_038924
+bielefeld bielefeld_000000_039221
+bielefeld bielefeld_000000_040035
+bielefeld bielefeld_000000_040472
+bielefeld bielefeld_000000_041014
+bielefeld bielefeld_000000_041142
+bielefeld bielefeld_000000_041444
+bielefeld bielefeld_000000_042403
+bielefeld bielefeld_000000_042571
+bielefeld bielefeld_000000_042717
+bielefeld bielefeld_000000_043100
+bielefeld bielefeld_000000_043389
+bielefeld bielefeld_000000_043610
+bielefeld bielefeld_000000_044085
+bielefeld bielefeld_000000_045117
+bielefeld bielefeld_000000_045232
+bielefeld bielefeld_000000_046023
+bielefeld bielefeld_000000_046212
+bielefeld bielefeld_000000_046495
+bielefeld bielefeld_000000_047918
+bielefeld bielefeld_000000_048227
+bielefeld bielefeld_000000_048518
+bielefeld bielefeld_000000_049446
+bielefeld bielefeld_000000_050586
+bielefeld bielefeld_000000_051894
+bielefeld bielefeld_000000_052155
+bielefeld bielefeld_000000_053384
+bielefeld bielefeld_000000_053583
+bielefeld bielefeld_000000_055145
+bielefeld bielefeld_000000_056175
+bielefeld bielefeld_000000_056226
+bielefeld bielefeld_000000_056603
+bielefeld bielefeld_000000_056866
+bielefeld bielefeld_000000_058374
+bielefeld bielefeld_000000_058934
+bielefeld bielefeld_000000_059303
+bielefeld bielefeld_000000_059766
+bielefeld bielefeld_000000_059842
+bielefeld bielefeld_000000_060786
+bielefeld bielefeld_000000_061094
+bielefeld bielefeld_000000_062121
+bielefeld bielefeld_000000_063623
+bielefeld bielefeld_000000_063939
+bielefeld bielefeld_000000_064271
+bielefeld bielefeld_000000_064805
+bielefeld bielefeld_000000_064910
+bielefeld bielefeld_000000_066195
+bielefeld bielefeld_000000_066405
+bielefeld bielefeld_000000_066495
+bonn bonn_000001_000019
+bonn bonn_000002_000019
+bonn bonn_000005_000019
+bonn bonn_000006_000019
+bonn bonn_000010_000019
+bonn bonn_000013_000019
+bonn bonn_000016_000019
+bonn bonn_000020_000019
+bonn bonn_000021_000019
+bonn bonn_000022_000019
+bonn bonn_000026_000019
+bonn bonn_000027_000019
+bonn bonn_000028_000019
+bonn bonn_000029_000019
+bonn bonn_000031_000019
+bonn bonn_000033_000019
+bonn bonn_000034_000019
+bonn bonn_000037_000019
+bonn bonn_000038_000019
+bonn bonn_000039_000019
+bonn bonn_000040_000019
+bonn bonn_000041_000019
+bonn bonn_000042_000019
+bonn bonn_000043_000019
+bonn bonn_000044_000019
+leverkusen leverkusen_000003_000019
+leverkusen leverkusen_000005_000019
+leverkusen leverkusen_000006_000019
+leverkusen leverkusen_000009_000019
+leverkusen leverkusen_000010_000019
+leverkusen leverkusen_000011_000019
+leverkusen leverkusen_000012_000019
+leverkusen leverkusen_000017_000019
+leverkusen leverkusen_000018_000019
+leverkusen leverkusen_000020_000019
+leverkusen leverkusen_000021_000019
+leverkusen leverkusen_000022_000019
+leverkusen leverkusen_000023_000019
+leverkusen leverkusen_000027_000019
+leverkusen leverkusen_000029_000019
+leverkusen leverkusen_000030_000019
+leverkusen leverkusen_000031_000019
+leverkusen leverkusen_000032_000019
+leverkusen leverkusen_000034_000019
+leverkusen leverkusen_000035_000019
+leverkusen leverkusen_000036_000019
+leverkusen leverkusen_000040_000019
+leverkusen leverkusen_000041_000019
+leverkusen leverkusen_000042_000019
+leverkusen leverkusen_000044_000019
+leverkusen leverkusen_000045_000019
+leverkusen leverkusen_000048_000019
+leverkusen leverkusen_000049_000019
+leverkusen leverkusen_000050_000019
+leverkusen leverkusen_000051_000019
+leverkusen leverkusen_000052_000019
+leverkusen leverkusen_000054_000019
+leverkusen leverkusen_000056_000019
+mainz mainz_000000_000093
+mainz mainz_000000_000293
+mainz mainz_000000_001003
+mainz mainz_000000_001068
+mainz mainz_000000_001265
+mainz mainz_000000_001410
+mainz mainz_000000_001857
+mainz mainz_000000_003250
+mainz mainz_000000_007415
+mainz mainz_000000_008165
+mainz mainz_000000_008645
+mainz mainz_000000_008871
+mainz mainz_000000_009985
+mainz mainz_000000_010550
+mainz mainz_000000_011339
+mainz mainz_000000_011879
+mainz mainz_000000_011965
+mainz mainz_000000_012392
+mainz mainz_000000_013095
+mainz mainz_000000_013437
+mainz mainz_000000_013960
+mainz mainz_000000_014193
+mainz mainz_000000_014742
+mainz mainz_000000_015052
+mainz mainz_000000_015170
+mainz mainz_000000_015760
+mainz mainz_000000_017927
+mainz mainz_000000_018249
+mainz mainz_000000_018883
+mainz mainz_000000_019043
+mainz mainz_000000_019227
+mainz mainz_000000_019847
+mainz mainz_000000_020415
+mainz mainz_000000_021457
+mainz mainz_000000_021524
+mainz mainz_000000_021735
+mainz mainz_000000_022417
+mainz mainz_000001_000120
+mainz mainz_000001_000428
+mainz mainz_000001_001509
+mainz mainz_000001_002884
+mainz mainz_000001_003012
+mainz mainz_000001_003624
+mainz mainz_000001_004132
+mainz mainz_000001_004219
+mainz mainz_000001_004823
+mainz mainz_000001_005016
+mainz mainz_000001_005163
+mainz mainz_000001_005665
+mainz mainz_000001_005815
+mainz mainz_000001_005911
+mainz mainz_000001_006194
+mainz mainz_000001_007595
+mainz mainz_000001_007956
+mainz mainz_000001_008056
+mainz mainz_000001_008264
+mainz mainz_000001_008540
+mainz mainz_000001_008638
+mainz mainz_000001_009328
+mainz mainz_000001_009867
+mainz mainz_000001_009996
+mainz mainz_000001_010853
+mainz mainz_000001_011736
+mainz mainz_000001_012541
+mainz mainz_000001_014073
+mainz mainz_000001_014469
+mainz mainz_000001_015117
+mainz mainz_000001_015508
+mainz mainz_000001_015724
+mainz mainz_000001_018145
+mainz mainz_000001_019061
+mainz mainz_000001_019593
+mainz mainz_000001_020068
+mainz mainz_000001_020484
+mainz mainz_000001_020829
+mainz mainz_000001_022125
+mainz mainz_000001_022630
+mainz mainz_000001_023604
+mainz mainz_000001_024489
+mainz mainz_000001_024718
+mainz mainz_000001_025623
+mainz mainz_000001_026837
+mainz mainz_000001_027053
+mainz mainz_000001_027377
+mainz mainz_000001_027751
+mainz mainz_000001_028326
+mainz mainz_000001_028566
+mainz mainz_000001_029755
+mainz mainz_000001_029950
+mainz mainz_000001_030417
+mainz mainz_000001_031697
+mainz mainz_000001_031946
+mainz mainz_000001_032294
+mainz mainz_000001_032401
+mainz mainz_000001_032691
+mainz mainz_000001_032767
+mainz mainz_000001_032911
+mainz mainz_000001_033096
+mainz mainz_000001_033603
+mainz mainz_000001_034209
+mainz mainz_000001_034681
+mainz mainz_000001_035293
+mainz mainz_000001_035963
+mainz mainz_000001_036240
+mainz mainz_000001_036412
+mainz mainz_000001_037905
+mainz mainz_000001_038026
+mainz mainz_000001_038191
+mainz mainz_000001_038768
+mainz mainz_000001_039075
+mainz mainz_000001_039470
+mainz mainz_000001_040367
+mainz mainz_000001_041172
+mainz mainz_000001_041647
+mainz mainz_000001_041887
+mainz mainz_000001_042121
+mainz mainz_000001_042851
+mainz mainz_000001_043656
+mainz mainz_000001_044366
+mainz mainz_000001_045385
+mainz mainz_000001_045651
+mainz mainz_000001_045782
+mainz mainz_000001_046381
+mainz mainz_000001_047546
+mainz mainz_000001_047611
+mainz mainz_000001_047888
+mainz mainz_000001_048725
+mainz mainz_000002_000061
+mainz mainz_000002_000912
+mainz mainz_000003_001465
+mainz mainz_000003_001899
+mainz mainz_000003_003558
+mainz mainz_000003_003711
+mainz mainz_000003_004144
+mainz mainz_000003_004228
+mainz mainz_000003_004774
+mainz mainz_000003_005088
+mainz mainz_000003_006863
+mainz mainz_000003_007144
+mainz mainz_000003_008690
+mainz mainz_000003_008876
+mainz mainz_000003_009819
+mainz mainz_000003_010772
+mainz mainz_000003_010924
+mainz mainz_000003_011949
+mainz mainz_000003_012341
+mainz mainz_000003_012995
+mainz mainz_000003_014083
+mainz mainz_000003_014457
+mainz mainz_000003_014537
+mainz mainz_000003_014959
+mainz mainz_000003_015411
+mainz mainz_000003_015649
+mainz mainz_000003_015917
+mainz mainz_000003_016360
+mainz mainz_000003_016542
+mainz mainz_000003_017171
+munich munich_000000_000019
+munich munich_000002_000019
+munich munich_000003_000019
+munich munich_000005_000019
+munich munich_000006_000019
+munich munich_000009_000019
+munich munich_000011_000019
+munich munich_000012_000019
+munich munich_000016_000019
+munich munich_000017_000019
+munich munich_000019_000019
+munich munich_000025_000019
+munich munich_000026_000019
+munich munich_000028_000019
+munich munich_000030_000019
+munich munich_000032_000019
+munich munich_000038_000019
+munich munich_000040_000019
+munich munich_000042_000019
+munich munich_000046_000019
+munich munich_000047_000019
+munich munich_000050_000019
+munich munich_000051_000019
+munich munich_000052_000019
+munich munich_000054_000019
+munich munich_000055_000019
+munich munich_000056_000019
+munich munich_000057_000019
+munich munich_000058_000019
+munich munich_000062_000019
+munich munich_000063_000019
+munich munich_000065_000019
+munich munich_000066_000019
+munich munich_000067_000019
+munich munich_000068_000019
+munich munich_000070_000019
+munich munich_000072_000019
+munich munich_000075_000019
+munich munich_000077_000019
+munich munich_000079_000019
+munich munich_000081_000019
+munich munich_000082_000019
+munich munich_000083_000019
+munich munich_000084_000019
+munich munich_000085_000019
+munich munich_000088_000019
+munich munich_000090_000019
+munich munich_000091_000019
+munich munich_000093_000019
+munich munich_000096_000019
+munich munich_000097_000019
+munich munich_000098_000019
+munich munich_000100_000019
+munich munich_000101_000019
+munich munich_000103_000019
+munich munich_000109_000019
+munich munich_000110_000019
+munich munich_000111_000019
+munich munich_000113_000019
+munich munich_000116_000019
+munich munich_000118_000019
+munich munich_000120_000019
+munich munich_000121_000019
+munich munich_000125_000019
+munich munich_000126_000019
+munich munich_000128_000019
+munich munich_000131_000019
+munich munich_000132_000019
+munich munich_000134_000019
+munich munich_000135_000019
+munich munich_000137_000019
+munich munich_000138_000019
+munich munich_000139_000019
+munich munich_000140_000019
+munich munich_000141_000019
+munich munich_000142_000019
+munich munich_000143_000019
+munich munich_000144_000019
+munich munich_000145_000019
+munich munich_000150_000019
+munich munich_000154_000019
+munich munich_000155_000019
+munich munich_000156_000019
+munich munich_000157_000019
+munich munich_000161_000019
+munich munich_000164_000019
+munich munich_000166_000019
+munich munich_000168_000019
+munich munich_000170_000019
+munich munich_000173_000019
+munich munich_000174_000019
+munich munich_000175_000019
+munich munich_000176_000019
+munich munich_000178_000019
+munich munich_000179_000019
+munich munich_000180_000019
+munich munich_000183_000019
+munich munich_000186_000019
+munich munich_000187_000019
+munich munich_000189_000019
+munich munich_000193_000019
+munich munich_000195_000019
+munich munich_000197_000019
+munich munich_000199_000019
+munich munich_000200_000019
+munich munich_000203_000019
+munich munich_000204_000019
+munich munich_000206_000019
+munich munich_000207_000019
+munich munich_000209_000019
+munich munich_000210_000019
+munich munich_000212_000019
+munich munich_000215_000019
+munich munich_000216_000019
+munich munich_000217_000019
+munich munich_000219_000019
+munich munich_000220_000019
+munich munich_000221_000019
+munich munich_000223_000019
+munich munich_000224_000019
+munich munich_000225_000019
+munich munich_000227_000019
+munich munich_000230_000019
+munich munich_000231_000019
+munich munich_000234_000019
+munich munich_000235_000019
+munich munich_000237_000019
+munich munich_000238_000019
+munich munich_000241_000019
+munich munich_000245_000019
+munich munich_000246_000019
+munich munich_000247_000019
+munich munich_000251_000019
+munich munich_000255_000019
+munich munich_000256_000019
+munich munich_000257_000019
+munich munich_000258_000019
+munich munich_000260_000019
+munich munich_000261_000019
+munich munich_000264_000019
+munich munich_000265_000019
+munich munich_000266_000019
+munich munich_000270_000019
+munich munich_000271_000019
+munich munich_000272_000019
+munich munich_000273_000019
+munich munich_000275_000019
+munich munich_000276_000019
+munich munich_000280_000019
+munich munich_000281_000019
+munich munich_000282_000019
+munich munich_000283_000019
+munich munich_000285_000019
+munich munich_000286_000019
+munich munich_000287_000019
+munich munich_000288_000019
+munich munich_000289_000019
+munich munich_000290_000019
+munich munich_000295_000019
+munich munich_000297_000019
+munich munich_000298_000019
+munich munich_000300_000019
+munich munich_000303_000019
+munich munich_000305_000019
+munich munich_000307_000019
+munich munich_000309_000019
+munich munich_000312_000019
+munich munich_000314_000019
+munich munich_000318_000019
+munich munich_000320_000019
+munich munich_000322_000019
+munich munich_000326_000019
+munich munich_000328_000019
+munich munich_000329_000019
+munich munich_000331_000019
+munich munich_000334_000019
+munich munich_000335_000019
+munich munich_000336_000019
+munich munich_000338_000019
+munich munich_000339_000019
+munich munich_000343_000019
+munich munich_000347_000019
+munich munich_000348_000019
+munich munich_000350_000019
+munich munich_000351_000019
+munich munich_000352_000019
+munich munich_000354_000019
+munich munich_000355_000019
+munich munich_000356_000019
+munich munich_000357_000019
+munich munich_000358_000019
+munich munich_000359_000019
+munich munich_000361_000019
+munich munich_000362_000019
+munich munich_000366_000019
+munich munich_000370_000019
+munich munich_000373_000019
+munich munich_000375_000019
+munich munich_000386_000019
+munich munich_000387_000019
+munich munich_000388_000019
+munich munich_000389_000019
+munich munich_000391_000019
+munich munich_000392_000019
+munich munich_000393_000019
+munich munich_000394_000019
+munich munich_000395_000019
+munich munich_000397_000019