ScanNet/VKITTI2/KITTI/nuScenes 数据集坐标变换的简单记录

已于 2023-10-16 23:55:08 修改
阅读量985 收藏 14
点赞数 7
文章标签： 人工智能 python 深度学习
于 2023-07-19 00:40:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45696231/article/details/131799130
版权

最近在和坐标变换斗争，不同数据集的位姿给的也是千奇百怪，我列写了我用到的三个数据集以及相应的变换方式，以便自己日后查找。(最终检验是否正确以累计点云为准)

文中用到的所有代码，以及四个数据集我都打包上传到了：
链接：https://pan.baidu.com/s/1LARmVn1kMHNl-1CXSyB8HA 提取码：2023

欢迎下载~🙂

文章目录

一、ScanNet

这个ScanNet数据我是从NICE-SLAM的链接下载的: https://github.com/cvg/nice-slam

ScanNet的数据集格式:

└─frames
    ├─color
    ├─depth
    ├─intrinsic
    └─pose/0.txt

在这里插入图片描述

坐标系介绍: (下面的都是这个坐标系)

在这里插入图片描述

1.1 完整的坐标变换代码

代码tf_scannet.py:

# ⭐tf_scannet.py
import numpy as np
import cv2
from scipy.spatial.transform import Rotation as R

# hyperparameters ----------------------------------
ci, cj, fi, fj = 242.6836, 318.9054, 578.729797, 577.59

SCENE_DIR = 'D:/DESKTOP/0716/Demo/frames/'
# --------------------------------------------------

def get_rgbd(idx):
    rgb = cv2.cvtColor(cv2.imread(SCENE_DIR + '/color/' + str(idx) + '.jpg'), cv2.COLOR_RGB2BGR)
    depth = cv2.imread(SCENE_DIR + '/depth/' + str(idx) + '.png', cv2.IMREAD_UNCHANGED) / 1000.0
    return rgb, depth


def get_transform(idx):
    transform = np.loadtxt(SCENE_DIR + '/pose/{}.txt'.format(idx))
    return transform

def transform(x, source, target, idx=0):

    if source == "depth" and target == "cam":
        ci, cj, fi, fj = 242.6836, 318.9054, 578.729797, 577.59

        # x.shape = (H, W)
        i, j = np.nonzero(x)
        k = x[i, j]

        '''
        cam_kitti_y|   cam_kitti_z
                   |  /
                   | /
                   |/
                   ----------- cam_kitti_x
        '''
        cam_kitti_x = (j - cj)/fj * k
        cam_kitti_y = -(i - ci)/fi * k
        cam_kitti_z = k

        '''       1
             2    |   
              \   |  
               \  | 
                \ |
                  --------- 0
        '''
        pc_cam = np.stack([cam_kitti_x, cam_kitti_y, cam_kitti_z]).T
        y = pc_cam

    # need idx
    elif source == "cam" and target == "world":
        # x.shape = (N, 3)
        transpose = get_transform(idx)
        transpose[:3, 1] *= -1
        transpose[:3, 2] *= -1   
        pc_world = np.matmul(transpose[:3, :3], pc_cam.T).T + transpose[:3, -1]
        y = pc_world


    elif source == "depth" and target == "world":
        y = transform(x, 'depth', 'cam')
        y = transform(y, 'cam', 'world', idx)

    return y

累计点云:

import numpy as np
import cv2
import open3d as o3d

from tf_scannet import get_rgbd, transform, get_transform

def get_single_pc_cam(idx):
    rgb, depth = get_rgbd(idx)
    rgb = cv2.resize(rgb, (640, 480))
    pc_cam = transform(depth, "depth", "cam")
    pc_cam[:, 2] *= -1
    colors = rgb[depth>0, :]
    pc_cam_o3d = o3d.geometry.PointCloud()
    pc_cam_o3d.points = o3d.utility.Vector3dVector(pc_cam)
    pc_cam_o3d.colors = o3d.utility.Vector3dVector(colors/255.0)
    return pc_cam_o3d


def pc_cam_to_world(pc_cam, idx):
    pc_world = transform(pc_cam, "cam", "world", idx)
    return pc_world    



pc_accumulate = o3d.geometry.PointCloud()

for idx in range(0, 500, 10):
    pc_current = get_single_pc_cam(idx)
    pc_current_points = np.asarray(pc_current.points)
    pc_current.points = o3d.utility.Vector3dVector(pc_cam_to_world(pc_current_points, idx))
    pc_accumulate += pc_current


o3d.visualization.draw_geometries([pc_accumulate])

1.2 效果

在这里插入图片描述

二、VKITTI2

2.1 读数据

VKITTI2的原始数据是这样的：

在这里插入图片描述

我把它转写成0.txt那种，然后做位姿变换。

2.2 完整的坐标变换代码

这个很诡异，他的平移矩阵要除10才可以，很抽象。

代码(tf_vkitti2.py):

# tf_vkitti2.py
import numpy as np
import cv2
from scipy.spatial.transform import Rotation as R

# hyperparameters ----------------------------------
ci, cj, fi, fj = 187, 620.5, 725.0087, 725.0087
SCENE_ID = 1
SCENE_DIR = 'D:/DESKTOP/0701/TrackData/VKITTI2_Scene'
ISEG_DIR = 'D:/DESKTOP/0701/TrackData/VKITTI2_Scene' + str(SCENE_ID).zfill(2) + '/iseg/'
# --------------------------------------------------

def get_rgbd(idx):
    rgb = cv2.cvtColor(cv2.imread(SCENE_DIR + str(SCENE_ID).zfill(2) + '/rgb/rgb_' + str(idx).zfill(5) + '.jpg'), cv2.COLOR_RGB2BGR)
    depth = cv2.imread(SCENE_DIR + str(SCENE_ID).zfill(2) + '/depth/depth_' + str(idx).zfill(5) + '.png', cv2.IMREAD_UNCHANGED) / 1000.0
    return rgb, depth

def get_iseg(idx):
    return cv2.imread(ISEG_DIR+'instancegt_'+ str(idx).zfill(5) + '.png')

def inverse_pose(pose):
        """
        pose: 4x4,
        """
        inv_pose = np.eye(4)
        rvec = pose[:3,:3]
        tvec = pose[:3,3].reshape(3,1)
        inv_rvec = rvec.T # r^T
        t = - np.dot(inv_rvec, tvec) # -r^T * t
        inv_pose[:3, :3] = inv_rvec
        inv_pose[:3, [3]] = t
        return inv_pose

def rmat_to_quad(mat):
    r = R.from_matrix(mat)
    quat = r.as_quat()
    return quat

def get_transform(idx):
    transform = np.loadtxt('D:/DESKTOP/0701/TrackData/VKITTI2_Scene' + str(SCENE_ID).zfill(2) + '/pose/{}.txt'.format(idx))
    transform = inverse_pose(transform)
    transform[:3, -1] /= 10
    return transform

def transform(x, source, target, idx=0):

    if source == "depth" and target == "cam":
        # x.shape = (H, W)
        i, j = np.nonzero(x)
        k = x[i, j]

        '''
        cam_kitti_y|   cam_kitti_z
                   |  /
                   | /
                   |/
                   ----------- cam_kitti_x
        '''
        cam_kitti_x = (j - cj)/fj * k
        cam_kitti_y = -(i - ci)/fi * k
        cam_kitti_z = k

        '''       1
             2    |   
              \   |  
               \  | 
                \ |
                  --------- 0
        '''
        pc_cam = np.stack([cam_kitti_x, cam_kitti_y, cam_kitti_z]).T
        y = pc_cam

    # need idx
    elif source == "cam" and target == "world":
        # x.shape = (N, 3)
        velo_points = np.ones((x.shape[0], 4))
        velo_points[:,:3] = x
        velo_points = velo_points.T
        T_w_velo = get_transform(idx)

        y = np.dot(T_w_velo, velo_points).T[:, :3]
        y[:, 0] = -y[:, 0]


    elif source == "depth" and target == "world":
        y = transform(x, 'depth', 'cam')
        y = transform(y, 'cam', 'world', idx)

    return y

累计点云:

from tf_vkitti2 import *
import open3d as o3d




pcd_total = o3d.geometry.PointCloud()

for idx in range(0, 82, 2):
    rgb, depth = get_rgbd(idx)
    depth[depth>20] = 0
    i,j = np.nonzero(depth)
    pc = transform(depth, 'depth', 'world', idx)
    colors = rgb[i,j,:]
    # 创建Open3D的点云对象
    pcd = o3d.geometry.PointCloud()
    pcd.points = o3d.utility.Vector3dVector(pc)
    pcd.colors = o3d.utility.Vector3dVector(colors/255.0)
    pcd_total += pcd


# 可视化点云
o3d.visualization.draw_geometries([pcd_total])

2.3 效果

在这里插入图片描述

三、KITTI

3.1 读数据

KITTI本身没有那种txt的位姿，我是借助pykitti库读取的位姿，下载好数据集后，读取位姿的代码如下：

import pykitti
import matplotlib.pyplot as plt
import numpy as np

basedir = 'E:/DATASETS/KITTI/2011_09_26_drive_0018/'
date = '2011_09_26'
drive = '0018'


dataset = pykitti.raw(basedir, date, drive, frames=range(47, 85, 1))


def get_pose(idx):

    oxts = dataset.oxts
    velos = dataset.velo
    oxt = dataset.oxts[idx] 
    T_w_imu = oxt.T_w_imu # 这个就是绝对坐标系的RT矩阵
    T_velo_imu = dataset.calib.T_velo_imu
    # 这个就是从imu坐标系到世界坐标系下的变换,如果想知道车此时的位置，就可以用 T_w_imu.dot(np.array(0,0,0,1)) 来得到. 这一点在求车辆的轨迹的时候就会用到.
    T_w_velo = np.matmul(T_w_imu, np.linalg.inv(T_velo_imu))

    return T_w_velo


# 存pose
for i in range(38):
     np.savetxt('D:/DESKTOP/0714/2011_09_26_drive_0018_nice-slam/pose/{}.txt'.format(i), get_pose(i))

3.2 完整的坐标变换代码

然后也能拿到一个位姿，之后我将点云投影成稀疏深度（或者借助CompletionFormer直接拿到稠密深度），然后根据RGBD+pose做点云累计，代码如下：

import numpy as np
import cv2
from scipy.spatial.transform import Rotation as R

# hyperparameters ----------------------------------
ci, cj, fi, fj = 187, 620.5, 725.0087, 725.0087

SCENE_DIR = 'D:/DESKTOP/DATASETS/KITTI_2011_09_26_drive_0001/'
# --------------------------------------------------

def get_rgbd(idx):
    rgb = cv2.cvtColor(cv2.imread(SCENE_DIR + '/color/' + str(idx) + '.png'), cv2.COLOR_RGB2BGR)
    depth = cv2.imread(SCENE_DIR + '/depth/' + str(idx) + '.png', cv2.IMREAD_UNCHANGED) / 1000.0
    return rgb, depth


def get_transform(idx):
    transform = np.loadtxt(SCENE_DIR + '/pose/{}.txt'.format(idx))
    return transform

def transform(x, source, target, idx=0):

    if source == "depth" and target == "cam":
        ci, cj, fi, fj = 187, 620.5, 725.0087, 725.0087

        # x.shape = (H, W)
        i, j = np.nonzero(x)
        k = x[i, j]

        '''
        cam_kitti_y|   cam_kitti_z
                   |  /
                   | /
                   |/
                   ----------- cam_kitti_x
        '''
        cam_kitti_x = (j - cj)/fj * k
        cam_kitti_y = -(i - ci)/fi * k
        cam_kitti_z = k

        '''       1
             2    |   
              \   |  
               \  | 
                \ |
                  --------- 0
        '''
        pc_cam = np.stack([cam_kitti_x, cam_kitti_y, cam_kitti_z]).T
        y = pc_cam

    # need idx
    elif source == "cam" and target == "world":
        # x.shape = (N, 3)
        pc_cam = x
        transpose = get_transform(idx)
        pc_cam = np.concatenate([pc_cam, np.ones((pc_cam.shape[0], 1))], axis=-1)

        pc_world = np.matmul(transpose, pc_cam.T).T[:, :3]
        y = pc_world


    elif source == "depth" and target == "world":
        y = transform(x, 'depth', 'cam')
        y = transform(y, 'cam', 'world', idx)

    return y

累计点云如下：

import sys
sys.path.append('D:/DESKTOP/0627/')
from tf_kitti import *
import cv2
import open3d as o3d
import cv2

def get_rgb_world_pc(idx):
    rgb, depth = get_rgbd(idx)
    depth[:150,:] = 0
    depth[:300,400:850] = 0

    rgb = rgb[depth > 0] / 255.0

    pc_world = transform(depth, 'depth', 'world', idx)

    pc_o3d = o3d.geometry.PointCloud(o3d.utility.Vector3dVector(pc_world))
    pc_o3d.colors = o3d.utility.Vector3dVector(rgb)

    return pc_o3d


pc_rgb_o3d = get_rgb_world_pc(6)
for i in range(6, 95, 1):
    pc_rgb_o3d += get_rgb_world_pc(i)


o3d.visualization.draw_geometries([pc_rgb_o3d])

3.3 效果

在这里插入图片描述

四、nuScenes

4.1 从nuScenes读数据的代码

这一段是我扒开可视化然后魔改的，作用是把 (RGB, 稀疏雷达版深度图，各种外参内参) 保存下来，直接用就行。

下面这些我放到百度网盘的read_nuScenes.ipynb文件里了。

%matplotlib inline
from nuscenes.nuscenes import NuScenes
from nuscenes.utils.data_classes import LidarPointCloud, RadarPointCloud, Box
import os.path as osp
from PIL import Image
import numpy as np
from pyquaternion import Quaternion
from nuscenes.utils.geometry_utils import view_points, box_in_image, BoxVisibility, transform_matrix
import copy

nusc = NuScenes(version='v1.0-trainval', dataroot='/data/wuke/zips/trainval', verbose=True) 

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
def token_to_ipt(my_sample, global_pc=None):

    sample_record = nusc.get('sample', my_sample['token'])
    camera_channel = 'CAM_FRONT'
    pointsensor_channel = 'LIDAR_TOP'

    calibs = {}

    pointsensor_token = sample_record['data'][pointsensor_channel]
    camera_token = sample_record['data'][camera_channel]
    cam = nusc.get('sample_data', camera_token)
    pointsensor = nusc.get('sample_data', pointsensor_token)
    pose = nusc.get('ego_pose', cam['ego_pose_token'])
    poserecord = nusc.get('ego_pose', cam['ego_pose_token'])
    R, T = Quaternion(poserecord['rotation']).rotation_matrix, np.array(poserecord['translation']).T
    pcl_path = osp.join(nusc.dataroot, pointsensor['filename'])
    pc = LidarPointCloud.from_file(pcl_path)
    im = Image.open(osp.join(nusc.dataroot, cam['filename']))
    img = np.array(im)


    # Points live in the point sensor frame. So they need to be transformed via global to the image plane.
    # First step: transform the pointcloud to the ego vehicle frame for the timestamp of the sweep.
    cs_record = nusc.get('calibrated_sensor', pointsensor['calibrated_sensor_token'])
    pc.rotate(Quaternion(cs_record['rotation']).rotation_matrix)
    pc.translate(np.array(cs_record['translation']))

    # 存外参数 - - - - - - - - - - - - - - - - - - - - - - - -
    calib_lidar2ego = np.eye(4) 
    calib_lidar2ego[:3, :3] = Quaternion(cs_record['rotation']).rotation_matrix
    calib_lidar2ego[:3, -1] = np.array(cs_record['translation']).reshape(3)
    calibs['calib_lidar2ego'] = calib_lidar2ego
    # - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    # Second step: transform from ego to the global frame.
    poserecord = nusc.get('ego_pose', pointsensor['ego_pose_token'])
    # 存外参数 - - - - - - - - - - - - - - - - - - - - - - - -
    calib_ego2world = np.eye(4) 
    calib_ego2world[:3, :3] = Quaternion(poserecord['rotation']).rotation_matrix
    calib_ego2world[:3, -1] = np.array(poserecord['translation']).reshape(3)
    calibs['calib_ego2world'] = calib_ego2world
    # - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # The ego_pose is the output of a lidar map-based localization algorithm described in our paper. The localization is 2-dimensional in the x-y plane.
    pc.rotate(Quaternion(poserecord['rotation']).rotation_matrix)
    pc.translate(np.array(poserecord['translation']))

    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
    if not (global_pc is None):
        pc_world = copy.deepcopy(pc.points)
        global_pc = np.concatenate([global_pc, pc_world.T], axis=0)

    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

    # Third step: transform from global into the ego vehicle frame for the timestamp of the image. 
    poserecord = nusc.get('ego_pose', cam['ego_pose_token'])
    pc.translate(-np.array(poserecord['translation']))
    pc.rotate(Quaternion(poserecord['rotation']).rotation_matrix.T)


    # Fourth step: transform from ego into the camera.
    cs_record = nusc.get('calibrated_sensor', cam['calibrated_sensor_token'])
    # 存外参数 - - - - - - - - - - - - - - - - - - - - - - - -
    calib_cam2ego = np.eye(4) 
    calib_cam2ego[:3, :3] = Quaternion(cs_record['rotation']).rotation_matrix
    calib_cam2ego[:3, -1] = np.array(cs_record['translation']).reshape(3)
    calibs['calib_cam2ego'] = calib_cam2ego
    # - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    pc.translate(-np.array(cs_record['translation']))
    pc.rotate(Quaternion(cs_record['rotation']).rotation_matrix.T)


    # Fifth step: actually take a "picture" of the point cloud.
    # Grab the depths (camera frame z axis points away from the camera).
    depths = pc.points[2, :] # depths.shape = (1,34784)
    raw_depth = pc.points[2]
    gt_from = 'lidarseg'
    # semantic_table = getattr(nusc, gt_from)
    coloring = depths
    # Take the actual picture (matrix multiplication with camera-matrix + renormalization).
    points = view_points(pc.points[:3, :], np.array(cs_record['camera_intrinsic']), normalize=True) # depths.shape = (3,34784)

    np.savetxt('./intrinsic.txt', np.array(cs_record['camera_intrinsic']))


    # TEMP TO DELETE ==================
    # points[2, :] = depths
    # temp_0, temp_1 = copy.deepcopy(points[0, :]), copy.deepcopy(points[1, :])
    # points[0, :], points[1, :] = temp_1, -temp_0
    # =================================

    min_dist = 0
    mask = np.ones(depths.shape[0], dtype=bool)
    mask = np.logical_and(mask, depths > min_dist)
    mask = np.logical_and(mask, points[0, :] > 1)
    mask = np.logical_and(mask, points[0, :] < im.size[0] - 1)
    mask = np.logical_and(mask, points[1, :] > 1)
    mask = np.logical_and(mask, points[1, :] < im.size[1] - 1)

    # TEMP TO DELETE =========================================
    points[2, :] = raw_depth
    # ========================================================

    points = points[:, mask]

    # 返回变换矩阵
    T = T[:,np.newaxis]

    transcation = np.concatenate([R,T],axis=1)
    transcation = np.concatenate([transcation,np.array([0,0,0,1])
    [np.newaxis,:]], axis=0)
    transcation = np.around(transcation, 6)

    H,W,C = img.shape

    # points是(3, 3053)且都是离散的数字，需要将points变成(1,1600,900)的图。
    points[:2,:] = np.around(points[:2,:])
    temp_depth = np.zeros((H,W,1)) #没有的存成200
    for i in range(len(points[0])):
        temp_depth[ min(H, int(points[1][i])), min(W, int(points[0][i]))] = points[2,i]

    depth = (temp_depth * 1000.0).astype(np.uint16)[..., 0]

    return img, depth, transcation, calibs

import cv2
import os
import numpy as np

def transcation_to_txt(i, transcation, scene_id):
    file = open('/home/wuke/nuScenes/scene_{}/pose/'.format(scene_id)+str(i) + '.txt', 'w')
    text = ''
    text = str(transcation[0][0]) + ' ' + str(transcation[0][1]) + ' ' + str(transcation[0][2]) + ' ' + str(transcation[0][3]) + '\n'
    text += str(transcation[1][0]) + ' ' + str(transcation[1][1]) + ' ' + str(transcation[1][2]) + ' ' + str(transcation[1][3]) + '\n'
    text += str(transcation[2][0]) + ' ' + str(transcation[2][1]) + ' ' + str(transcation[2][2]) + ' ' + str(transcation[2][3]) + '\n'
    text += str(transcation[3][0]) + ' ' + str(transcation[3][1]) + ' ' + str(transcation[3][2]) + ' ' + str(transcation[3][3])
    file.write(text)

def get_sample_id_list(scene_id):
    scene = nusc.scene[scene_id]
    sample_tokens = nusc.field2token('sample', 'scene_token', scene['token'])

    sample_list = []
    for sample_token in sample_tokens:
        sample = nusc.get('sample', sample_token)
        sample_list.append(sample)
    return sample_list

def main(scene_id = 0):

    # scene_id = 0
    # global_pc = np.empty((0, 4))

    sample_list = get_sample_id_list(scene_id)

    for i in range(len(sample_list)): # sample_id_list:
        # my_sample = nusc.sample[i]
        my_sample = sample_list[i]
        img, depth, transcation, calibs = token_to_ipt(my_sample)
        # calibs是一个字典，{'calib_lidar2ego':, 'calib_cam2ego':, 'calib_ego2world':}

        cv2.imwrite('/home/wuke/nuScenes/scene_{}/color/'.format(scene_id)+ str(i) + '.jpg', cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
        # depth = cv2.resize(depth,(640,480))
        cv2.imwrite('/home/wuke/nuScenes/scene_{}/depth/'.format(scene_id)+str(i) + '.png', depth, [int(cv2.IMWRITE_PNG_COMPRESSION), 1])
        transcation_to_txt(i, transcation, scene_id)

        # 存外参捏
        for key in list(calibs.keys()):
            np.savetxt('/home/wuke/nuScenes/scene_{}/{}/{}.txt'.format(scene_id, key, i), calibs[key])

    # np.save('/home/wuke/nuScenes/scene_{}/global_pc.npy'.format(scene_id), global_pc)


if __name__ == '__main__':

    for out in [68]:
        # out -= 1
        os.makedirs('/home/wuke/nuScenes/scene_{}/'.format(out), exist_ok=True)
        os.makedirs('/home/wuke/nuScenes/scene_{}/depth'.format(out), exist_ok=True)
        os.makedirs('/home/wuke/nuScenes/scene_{}/color'.format(out), exist_ok=True)
        os.makedirs('/home/wuke/nuScenes/scene_{}/pose'.format(out), exist_ok=True)
        # 存一下小外参
        os.makedirs('/home/wuke/nuScenes/scene_{}/calib_lidar2ego'.format(out), exist_ok=True)
        os.makedirs('/home/wuke/nuScenes/scene_{}/calib_cam2ego'.format(out), exist_ok=True)
        os.makedirs('/home/wuke/nuScenes/scene_{}/calib_ego2world'.format(out), exist_ok=True)

        main(out)

4.2 nuScenes-devkit 的API解析

  • 正经代码
pointsensor_token = sample_record['data'][pointsensor_channel]
camera_token = sample_record['data'][camera_channel]
cam = nusc.get('sample_data', camera_token)
pointsensor = nusc.get('sample_data', pointsensor_token)


# ① 雷达坐标系 → 小车坐标系
cs_record = nusc.get('calibrated_sensor', pointsensor['calibrated_sensor_token'])
pc.rotate(Quaternion(cs_record['rotation']).rotation_matrix)
pc.translate(np.array(cs_record['translation']))

# ② 小车坐标系 → 世界坐标系
poserecord = nusc.get('ego_pose', pointsensor['ego_pose_token'])
# The ego_pose is the output of a lidar map-based localization algorithm described in our paper. The localization is 2-dimensional in the x-y plane.
pc.rotate(Quaternion(poserecord['rotation']).rotation_matrix)
pc.translate(np.array(poserecord['translation']))

# ③ 世界坐标系 → 小车坐标系
poserecord = nusc.get('ego_pose', cam['ego_pose_token'])
pc.translate(-np.array(poserecord['translation']))
pc.rotate(Quaternion(poserecord['rotation']).rotation_matrix.T)

# ④ 小车坐标系 → 相机坐标系
cs_record = nusc.get('calibrated_sensor', cam['calibrated_sensor_token'])
pc.translate(-np.array(cs_record['translation']))
pc.rotate(Quaternion(cs_record['rotation']).rotation_matrix.T)

# ⑤ 相机坐标系 → 像素坐标系(u, v, depth)
points = view_points(pc.points[:3, :], np.array(cs_record['camera_intrinsic']), normalize=True) # depths.shape = (3,34784)

  • pc类：

    def translate(self, x: np.ndarray) -> None:
     """
     Applies a translation to the point cloud.
     :param x: <np.float: 3, 1>. Translation in x, y, z.
     """
     for i in range(3):
         self.points[i, :] = self.points[i, :] + x[i]

def rotate(self, rot_matrix: np.ndarray) -> None:
     """
     Applies a rotation.
     :param rot_matrix: <np.float: 3, 3>. Rotation matrix.
     """
     self.points[:3, :] = np.dot(rot_matrix, self.points[:3, :])

  • 现在需要的是：像素→相机→小车→世界，即需要⑤④②

    emmm，假设后面的变换全部都是按照人家原本的先旋转后平移的小策略进行，然后存一个各个变换的小矩阵。

4.3 完整的坐标变换代码

  • tf_nuScenes.py

    import numpy as np
import cv2
import copy

'''
intrinsic:
     _         _
    | fv  0  cv |
    | 0  fu  cu |  
    |_0   0   1_|

pixel_coord:
     _ _ _ _v
    |
    |
    |u

cam_coord:
     /z  
    /
   /_ _ _ _ x
   |
   |
   |y

world_coord:

 
 def transform(x_raw, source, target, intrinsic=None, calibs=None):

     if source == "cam" and target == "pixel":
         '''
         取points的前面三个值，即(N, 3)
         x.shape = (N, 3)
         '''
         x = copy.deepcopy(x_raw)
   
         points = x.T # (3, N)
   
         fu, fv, cu, cv = intrinsic['fu'], intrinsic['fv'], intrinsic['cu'], intrinsic['cv']
   
         view = np.eye(4)
         view[0,0], view[1,1], view[0,2], view[1,2] = fv, fu, cv, cu
   
         points = np.concatenate((points, np.ones((1, points.shape[1]))), axis=0) # (4, N)
   
         points = np.dot(view, points)
         points = points[:3, :]
         points = points / points[2, :].reshape(1, -1)
   
         y = points
   
   
     elif source == "depth" and target == "cam":
         '''
         x.shape = (H, W)
         '''
         fu, fv, cu, cv = intrinsic['fu'], intrinsic['fv'], intrinsic['cu'], intrinsic['cv']
   
         x = copy.deepcopy(x_raw)
         u, v = np.nonzero(x)
         z_cam = x[u, v] # (N ,)
   
         x_cam = (v - cv) * z_cam / fv # (N ,)
         y_cam = (u - cu) * z_cam / fu # (N ,)
   
         y = np.concatenate([x_cam[:,np.newaxis], y_cam[:,np.newaxis], z_cam[:,np.newaxis]], axis=-1) # (N, 3)
   
   
     elif source == "pixel" and target == "cam":
         '''
         x.shape = (N, 3)
         '''
         x = copy.deepcopy(x_raw)
         fu, fv, cu, cv = intrinsic['fu'], intrinsic['fv'], intrinsic['cu'], intrinsic['cv']
         u, v, z_cam = x[:, 0], x[:, 1], x[:, 2]
   
         x_cam = (v - cv) * z_cam / fv # (N ,)
         y_cam = (u - cu) * z_cam / fu # (N ,)
   
         y = np.concatenate([x_cam[:,np.newaxis], y_cam[:,np.newaxis], z_cam[:,np.newaxis]], axis=-1) # (N, 3)
   
   
     elif source == "cam" and target == "world":
         '''
         x.shape = (N, 3)
         '''
   
         x = copy.deepcopy(x_raw)
   
         # STEP 1 相机坐标系转小车坐标系（先旋转后平移）
         calib_cam2ego = calibs['calib_cam2ego']
         x_ego = np.dot(calib_cam2ego[:3,:3], x.T).T + calib_cam2ego[:3,-1].reshape(1, 3) # (N, 3)
   
         # STEP 2 小车坐标系转世界坐标系
         calib_ego2world = calibs['calib_ego2world']
         x_world = np.dot(calib_ego2world[:3,:3], x_ego.T).T + calib_ego2world[:3,-1].reshape(1, 3) # (N, 3)
   
         y = x_world                    
   
     elif source == "depth" and target == "world":
         x = transform(x_raw, source="depth", target="cam", intrinsic=intrinsic)
         y = transform(x, source="cam", target="world", calibs=calibs)
   
     return y
  • 可视化
import os
import numpy as np
import cv2
import open3d as o3d

import sys
sys.path.append('D:/DESKTOP/1014/')
from tf_nuScenes import *


def get_single_frame_data(idx):
    DATA_PATH = 'D:/DESKTOP/1014/DATA/OSDF_nuScenes_Scene68/'
    rgb = cv2.imread(DATA_PATH + '/color/{}.jpg'.format(idx))
    sparse_depth = cv2.imread(DATA_PATH + '/depth/{}.png'.format(idx), cv2.IMREAD_UNCHANGED) / 1000.0
    calib_cam2ego = np.loadtxt(DATA_PATH + '/calib_cam2ego/{}.txt'.format(idx))
    calid_ego2world = np.loadtxt(DATA_PATH + '/calib_ego2world/{}.txt'.format(idx))

    return rgb, sparse_depth, {'calib_cam2ego': calib_cam2ego, 'calib_ego2world': calid_ego2world}

intrinsic= {'fu': 1.266417203046554050e+03, 'fv': 1.266417203046554050e+03, 'cu': 4.915070657929475715e+02, 'cv': 8.162670197447984037e+02}

pcd_all = o3d.geometry.PointCloud()

for idx in range(40):
    rgb, sparse_depth, calibs = get_single_frame_data(idx)
    rgb = cv2.cvtColor(rgb, cv2.COLOR_BGR2RGB)
    mask = sparse_depth>0
    colors = rgb[mask]
    pc_world = transform(sparse_depth, 'depth', 'world', intrinsic=intrinsic, calibs=calibs)
    pcd_world = o3d.geometry.PointCloud()
    pcd_world.points = o3d.utility.Vector3dVector(pc_world.reshape(-1, 3))
    pcd_world.colors = o3d.utility.Vector3dVector(colors.reshape(-1, 3)/255.0)
    pcd_all += pcd_world

o3d.visualization.draw_geometries([pcd_all])

4.4 效果

在这里插入图片描述

五、三种数据集的pose格式相互转换

因为我需要把VKITTI2转换成ScanNet的pose格式才能丢到NICE-SLAM里面跑。

这一节实现的功能就是比如：我的数据集是VKITTI2，我想用ScanNet的读数据方式读VKITTI2并且做点云累计。

5.1 理论介绍

  • ScanNet

    • txt中直接load的pose:

    [ r 11 r 12 r 13 t 1 r 21 r 22 r 23 t 2 r 31 r 32 r 33 t 3 0 0 0 1 ] \begin{bmatrix} r_{11} & r_{12} & r_{13} & t_{1} \\ r_{21} & r_{22} & r_{23} & t_{2} \\ r_{31} & r_{32} & r_{33} & t_{3} \\ 0 & 0 & 0 &1 \end{bmatrix} ​r11​r21​r31​0​r12​r22​r32​0​r13​r23​r33​0​t1​t2​t3​1​ ​

    • 操作方式:

      p c _ c a m = ( x c a m y c a m z c a m ) T p c _ w o r l d = ( r 11 x c a m − r 12 y c a m − r 13 z c a m + t 1 r 21 x c a m − r 22 y c a m − r 23 z c a m + t 2 r 31 x c a m − r 32 y c a m − r 33 z c a m + t 3 ) pc\_cam = \begin{pmatrix}x_{cam}&y_{cam}&z_{cam} \end{pmatrix}^T\\ pc\_world = \begin{pmatrix} r_{11}x_{cam} - r_{12}y_{cam} - r_{13}z_{cam} + t_1 \\ r_{21}x_{cam} - r_{22}y_{cam} - r_{23}z_{cam} + t_2 \\ r_{31}x_{cam} - r_{32}y_{cam} - r_{33}z_{cam} + t_3 \end{pmatrix} pc_cam=(xcam​​ycam​​zcam​​)Tpc_world= ​r11​xcam​−r12​ycam​−r13​zcam​+t1​r21​xcam​−r22​ycam​−r23​zcam​+t2​r31​xcam​−r32​ycam​−r33​zcam​+t3​​ ​

  • VKITTI2

    • txt中直接load的pose：

    [ r 11 r 12 r 13 t 1 r 21 r 21 r 23 t 2 r 31 r 32 r 33 t 3 0 0 0 1 ] \begin{bmatrix} r_{11} & r_{12} & r_{13} & t_{1} \\ r_{21} & r_{21} & r_{23} & t_{2} \\ r_{31} & r_{32} & r_{33} & t_{3} \\ 0 & 0 & 0 &1 \end{bmatrix} ​r11​r21​r31​0​r12​r21​r32​0​r13​r23​r33​0​t1​t2​t3​1​ ​

    • 操作方式

      p c _ c a m = ( x c a m y c a m z c a m ) T p c _ w o r l d = ( − r 11 x c a m − r 21 y c a m − r 31 z c a m + 0.1 ( r 11 t 1 + r 21 t 2 + r 31 t 3 ) r 12 x c a m + r 22 y c a m + r 32 z c a m − 0.1 ( r 12 t 1 + r 22 t 2 + r 32 t 3 ) r 13 x c a m + r 23 y c a m + r 33 z c a m − 0.1 ( r 13 t 1 + r 23 t 2 + r 33 t 3 ) ) pc\_cam = \begin{pmatrix}x_{cam}&y_{cam}&z_{cam}\end{pmatrix}^T\\ \\ pc\_world = \begin{pmatrix} -r_{11}x_{cam} - r_{21}y_{cam} - r_{31}z_{cam} + 0.1(r_{11}t_1+r_{21}t_2+r_{31}t_3) \\ r_{12}x_{cam} + r_{22}y_{cam} + r_{32}z_{cam} - 0.1(r_{12}t_1+r_{22}t_2+r_{32}t_3) \\ r_{13}x_{cam} + r_{23}y_{cam} + r_{33}z_{cam} - 0.1(r_{13}t_1+r_{23}t_2+r_{33}t_3) \end{pmatrix} pc_cam=(xcam​​ycam​​zcam​​)Tpc_world= ​−r11​xcam​−r21​ycam​−r31​zcam​+0.1(r11​t1​+r21​t2​+r31​t3​)r12​xcam​+r22​ycam​+r32​zcam​−0.1(r12​t1​+r22​t2​+r32​t3​)r13​xcam​+r23​ycam​+r33​zcam​−0.1(r13​t1​+r23​t2​+r33​t3​)​ ​

  • KITTI

    • pykitti中读取并且保存的pose

      • 代码：

        def get_transpose(idx):
    # cam to velo
    T_velo_cam3 = np.linalg.inv(dataset.calib.T_cam3_velo)

    # velo to world
    oxt = oxts_list[idx]   
    T_w_imu = oxt.T_w_imu
    T_velo_imu = dataset.calib.T_velo_imu
    T_imu_velo = inverse_pose(T_velo_imu)
    T_w_velo = np.dot(T_w_imu, T_imu_velo)

    transpose = np.dot(T_w_velo, T_velo_cam3)

    # 保存好以后，KITTI只需要 pc_world = np.matmul(transpose, pc_cam.T).T[:, :3] 即可

    return transpose

      • 记作：

        ( r 11 r 12 r 13 t 1 r 21 r 21 r 23 t 2 r 31 r 32 r 33 t 3 0 0 0 1 ) \begin{pmatrix} r_{11} & r_{12} & r_{13} & t_{1} \\ r_{21} & r_{21} & r_{23} & t_{2} \\ r_{31} & r_{32} & r_{33} & t_{3} \\ 0 & 0 & 0 &1 \end{pmatrix} ​r11​r21​r31​0​r12​r21​r32​0​r13​r23​r33​0​t1​t2​t3​1​ ​

    • 操作方式

      p c _ c a m = ( x c a m y c a m z c a m ) T p c _ w o r l d = ( r 11 x c a m + r 12 y c a m + r 13 z c a m + t 1 r 21 x c a m + r 22 y c a m + r 23 z c a m + t 2 r 31 x c a m + r 32 y c a m + r 33 z c a m + t 3 ) pc\_cam = \begin{pmatrix}x_{cam}&y_{cam}&z_{cam} \end{pmatrix}^T\\ pc\_world = \begin{pmatrix} r_{11}x_{cam} + r_{12}y_{cam} + r_{13}z_{cam} + t_1 \\ r_{21}x_{cam} + r_{22}y_{cam} + r_{23}z_{cam} + t_2 \\ r_{31}x_{cam} + r_{32}y_{cam} + r_{33}z_{cam} + t_3 \end{pmatrix} pc_cam=(xcam​​ycam​​zcam​​)Tpc_world= ​r11​xcam​+r12​ycam​+r13​zcam​+t1​r21​xcam​+r22​ycam​+r23​zcam​+t2​r31​xcam​+r32​ycam​+r33​zcam​+t3​​ ​

5.2 代码

pose是用来做cam系到world系坐标变换的，这里直接放代码了：

# tf_exchange.py


import numpy as np
import copy


def exchange(x, source, target):
    ''' 
    x.shape = (4, 4)
    '''
    if source == 'vkitti2' and target == 'scannet':
        TR = np.eye(4)

        x_cp = copy.deepcopy(x)

        TR[0,0], TR[0,1], TR[0,2] = -x_cp[0,0], x_cp[1,0], x_cp[2,0]
        TR[0,-1] = 0.1 * (x_cp[0,0]*x_cp[0,-1] + x_cp[1,0]*x_cp[1,-1] + x_cp[2,0]*x_cp[2,-1])


        TR[1,0], TR[1,1], TR[1,2] = x_cp[0,1], -x_cp[1,1], -x_cp[2,1]
        TR[1,-1] = -0.1 * (x_cp[0,1]*x_cp[0,-1] + x_cp[1,1]*x_cp[1,-1] + x_cp[2,1]*x_cp[2,-1])

        TR[2,0], TR[2,1], TR[2,2] = x_cp[0,2], -x_cp[1,2], -x_cp[2,2]
        TR[2,-1] = -0.1 * (x_cp[0,2]*x_cp[0,-1] + x_cp[1,2]*x_cp[1,-1] + x_cp[2,2]*x_cp[2,-1])

        y = TR


    elif source == 'scannet' and target == 'vkitti2':
        TR = np.eye(4)

        TR[0,0], TR[0,1], TR[0,2] = -x[0,0], x[1,0], x[2,0]
        TR[1,0], TR[1,1], TR[1,2] = x[0,1], -x[1,1], -x[2,1]
        TR[2,0], TR[2,1], TR[2,2] = x[0,2], -x[1,2], -x[2,2]

        x_cp = copy.deepcopy(x)
        x_cp[0, -1] *= -1
        TR[:3, -1] = -10 * np.matmul(np.linalg.inv(TR[:3,:3].T), x_cp[:3, -1])

        y = TR

    elif source == 'kitti' and target == 'scannet':
        TR = copy.deepcopy(x)
        TR[:3, 1] *= -1
        TR[:3, 2] *= -1
        y = TR         

    elif source == 'scannet' and target == 'kitti':
        TR = copy.deepcopy(x)
        TR[:3, 1] *= -1
        TR[:3, 2] *= -1
        y = TR  

    elif source == 'vkitti2' and target == 'kitti':
        x = exchange(x, 'vkitti2', 'scannet')
        y = exchange(x, 'scannet', 'kitti')

    elif source == 'kitti' and target == 'vkitti2':
        x = exchange(x, 'kitti', 'scannet')
        y = exchange(x, 'scannet', 'vkitti2')            

    return y
Promethe_us
关注
  • 7
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Scannet数据集场景列表
05-16
Scannet数据集场景列表
nuscenes2kitti- Nuscenes数据集转KITTI数据集格式
h904798869的博客
12-26 1660
nuscenes2kitti-Nuscenes数据集转KITTI数据集格式目录结构
ScanNet 数据集常见文件的作用极其读取方式
月亮不知道的博客
04-22 1294
ScanNet 数据集是一个大规模的 RGB-D 视频数据集，它包含了丰富的三维场景理解任务所需的数据，如三维物体分类、语义体素标签和 CAD 模型检索等。和.sens和和.txt文件（如下面进行详细的解释。
TWISE:CVPR 2021提交我们的论文“在遮挡边界处具有双曲面外推的深度补全”的代码
04-19
双表面外推-TWISE- CVPR 2021提交代码，可在获得“在遮挡边界处具有双曲面外推的深度补全” 概述 以下是我们提出的算法的预告结果： 该图描述了我们的深度完成算法如何输入LiDAR数据和图像（a），以及对前景深度$ d_1 $（b）和背景深度$ d_2 $（c）以及权重$ \ sigma $（ e）。 将所有三个引线融合到完整的深度（d）。 前景-背景深度差（f）$ d_2-d_1 $很小，除了在深度不连续处。 依存关系 数据集生成 评估 预训练模型 虚拟KITTI 使用Semi-Dense GT建模异常值 因为我们声称我们的方法在边界上效果很好，所以我们还在VKITTI 2.0上进行了评估，VKITTI 2.0是在深度不连续处具有清晰且密集的GT深度的合成数据集。 由Unity游戏引擎创建的VKITTI $ 2.0 $，除了$ 5 $之外，还包含$ 5 $个不同的摄像头位置
点云深度学习之数据集处理（一）数据集的分类
SGL_LGS的博客
05-02 1万+
前段时间在做点云深度学习网络课题时，随手在博客“ModelNet40 中加入自己的数据集”中放了两串代码，目的是方便自己的存取（当时不会GIT的菜鸟）。结果成了所写博客中访问最多，提问最多的博文（瑟瑟发抖）。近段时间在恶补语言基础知识，索性换换脑，将这部分的知识进行一个相对完整的整理。希望对那些想快速入手点云深度学习，用来做课设、毕设的小朋友一点点帮助。以下都是个人的所学所思所想，不一定正确，仅做...
kitti数据集在3D目标检测中的入门
pangxing6491的博客
10-28 739
https://blog.csdn.net/qq_37534947/article/details/106628308
ScanNet点云文件解读记录
l434503227的博客
12-05 1618
本文主要表达作者对ScanNet数据集中点云数据理解和解读，和大家一起学习讨论。
KITTI数据集及标定文件介绍（详细）
jenkinwey的博客
09-20 5734
KITTI数据集介绍   Kitti数据集是目前国际上最大的自动驾驶场景下的计算机视觉算法评测数据集。KITTI包含市区、乡村和高速公路等场景采集的真实图像数据，每张图像中最多达15辆车和30个行人，还有各种程度的遮挡与截断。 KITTI数据集采集平台   KITTI数据集的数据采集平台装配有2个灰度摄像机，2个彩色摄像机，一个Velodyne64线3D激光雷达，4个光学镜头，以及1个GPS导航系统。 相机、激光雷达、IMU坐标系的方向分别为： 相机：x 轴向右，y 轴向下，z 轴向前 Velo
数据集下载scannet
04-27
数据集下载scannet
scannet 整理数据
最新发布
05-03
数据集共6G。 -- test / 100 pth -- train / 1201 pth -- val / 312 pth 读取 torch.load('*.pth') 结果 {'coord': array([[0.4467576 , ...e=float32), 'color': array([[ 92., 76., ...e=float32), 'scene_id': '...
download-scannet.py
03-04
主要是下载scannet数据集代码，通过邮件获取，侵权立删
PointNet-SemSeg-VKITTI3D:使用PointNet的VKITTI3D语义分割
04-30
使用PointNet对虚拟kitti数据集进行3D语义分割 主要代码来自 数据集 您可以从下载数据集。 所有文件均以numpy .npy文件形式提供。 每个文件包含一个N x F矩阵，其中N是场景中的点数，F是每个点的要素数，在这种情况下，F = 7。 功能包括XYZRGBL，3D XYZ位置，RGB颜色和地面真实语义标签L。每个文件都用于一个场景。 训练 下载并准备好数据后，请开始使用main.ipynb进行培训。 可视化数据 对于数据可视化，您可以使用vis_data_vispy.py文件。 使用PointNet的选定项目 Qi等人的。 （NIPS 2017）点云上的分层功能学习框架。 PointNet ++体系结构将PointNet递归应用于输入点集的嵌套分区。 它还为密度不均匀的点云提出了新颖的层。 Engelmann等人的。 （ICCV 2017研讨会）。 这项工作扩展了P
download_scannet.zip
01-27
Scannet数据集是计算机视觉领域中一个广泛使用的三维室内场景扫描数据集，它提供了详细的三维几何信息和丰富的语义注解。这个数据集对于3D重建、语义分割、对象检测、场景理解等任务的研究非常有价值。在这个场景中...
自动驾驶nuScenes数据集——一个KITTI以外的新数据集
热门推荐
MecHub
11-03 2万+
数据集简介 Setup Python version Python virtual environment Storage buckets 将数据集从buckets拷贝到instance 数据集的使用
Scannet(v2)数据集单个场景网盘链接
Zeal510的博客
01-08 807
链接: https://pan.baidu.com/s/15qthvhfwrnm9qptatD1ubg 提取码: ndbw。–来自百度网盘超级会员v2的分享。
Ubuntu22.04安装OpenPcDet训练kitti数据集(nuscenes-mini数据集）
RickySam的博客
07-18 2970
因为想要接触KITTI数据集，有相关项目需要配置OpenPcDet，而原服务器因系统重装为Ubuntu22.04版本，该版本较高故重新配置环境是需要参考各种渠道，在此将这些参考汇总，也方便自己以后再配置可以清晰一点。本文综合了多篇文章。
Nuscenes数据转换工具 -- bin2bag
Darchan的博客
07-11 1717
Nuscenes数据转换工具 -- bin2bag，该脚本工具可以完成bin数据到bag数据的转换。
深度学习（1）RGB-D数据集：ScanNet
sinat_41354290的博客
06-22 1万+
 本文主要介绍相关的RGB-D数据，并完成其搬运工作。 目录1. ScanNet数据集1.1 获取数据集1.2 解析数据集1.2.1 2D数据 1. ScanNet数据集 1513个采集场景数据，21个类别的对象，其中，1201个场景用于训练，312个场景用于测试。  ScanNet is an RGB-D video dataset containing 2.5 million views in more than 1500 scans, annotated with 3D camera poses,..
scannet数据集简介和下载
5233的博客
12-13 9088
scanne数据集下载，做分割任务用
scannet数据集下载
11-18
Scannet是一个室内场景的RGB-D数据集，可以用于计算机视觉和深度学习的研究和开发。如果你想下载Scannet数据集，可以按照以下步骤进行操作。 首先，打开Scannet数据集官方网站（https://www.scan-net.org/）。 其次，在网站的主页上，你可以找到一个"Downloads"（下载）链接，点击进入下载页面。 在下载页面上，你可以看到不同版本和格式的Scannet数据集可供下载。根据你的需要，选择适合你的数据集版本。 接下来，你需要填写一个下载请求表格，提供你的姓名、电子邮件地址、所在机构等信息。填写表格后，点击提交按钮。 提交请求后，你将会收到一封包含下载链接的确认电子邮件。打开确认邮件，并点击下载链接。 点击下载链接后，数据集将开始下载。数据集的大小较大，可能需要一些时间来完成下载过程。请确保你的网络连接稳定并具备足够的存储空间。 一旦下载完成，你可以解压缩数据集文件并开始使用Scannet数据集进行研究或开发。数据集文件通常包含了室内场景的深度图像、RGB图像、相机姿态信息、语义标签等数据。 需要注意的是，Scannet数据集是出于学术研究目的而提供的，因此在使用数据集时请遵守相关法律法规和学术道德规范，同时请尊重数据集的使用限制和许可协议。 希望上述内容能够对你下载Scannet数据集有所帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值