“横平竖直”进行连线+将相邻框进行合并

最新推荐文章于 2022-03-02 15:19:16 发布
最新推荐文章于 2022-03-02 15:19:16 发布
阅读量529 收藏 2
点赞数
分类专栏： numpy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fanzonghao/article/details/97612478
版权

一.横平竖直”进行连线

解法1.将一些坐标点按照x相等,y相等连起来

解法1.根据 x或y总有一个相等的,用np.sum来找出和为1的点,然后在连起来,存在重复连线的问题.

import numpy as np
    coord = np.array([[10, 60],
                      [10, 20],
                      [20, 20],
                      [40, 40],
                      [40, 60],
                      [20, 40]])
    img = np.zeros((100, 100))
    h, w = coord.shape

    for i in range(h):
        index = np.sum(np.array(coord[i]).reshape(-1, 2) == coord, axis=-1)
        y = np.where(index == 1)

        for point in coord[y]:
            cv2.line(img, (coord[i][0], coord[i][1]), (point[0], point[1]), color=(255,255,255), thickness=3)
    cv2.imshow('img', img)
    cv2.waitKey(0)

解法2.先连x相等,在连y相等的

def coord_sort_ind(x,y):
    #按照x,y来排序
    ind = np.lexsort((y.tolist(), x.tolist())) # Sort by x, then by y
    return ind
def simple_line_():
    import numpy as np
    coord = np.array([[10, 60],
                      [10, 20],
                      [20, 20],
                      [40, 40],
                      [40, 60],
                      [20, 40]])
    # 按照先X后Y排的序
    ind = coord_sort_ind(coord[:, 0], coord[:, 1])
    coord_X=coord[ind]
    print(coord_X)

    # # 按照先Y后X排的序
    ind = coord_sort_ind(coord[:, 1], coord[:, 0])
    print(ind)
    coord_Y = coord[ind]
    print(coord_Y)

    img = np.zeros((100, 100))
    h, w = coord.shape
    # x想等的连接
    for i in range(0, h, 2):
        cv2.line(img, (coord_X[i][0], coord_X[i][1]), (coord_X[i + 1][0], coord_X[i + 1][1]), color=(255, 255, 255),
                 thickness=3)
        # y想等的连接
        cv2.line(img, (coord_Y[i][0], coord_Y[i][1]), (coord_Y[i + 1][0], coord_Y[i + 1][1]), color=(255, 255, 255),
                 thickness=3)

    cv2.imshow('img', img)
    cv2.waitKey(0)

二.将相邻框进行合并

目前解法是将两个相邻的框合并，得到大框在继续合并，算法还需要优化成一次性合并成功

import numpy as np
import cv2
def get_cluster(points,x_dis,y1_dis):
    points = points[points[:, 0].argsort()]
    x1,y1,x2,y2=points[:,0],points[:,1],points[:,-2],points[:,-1]
    #只对竖值框进行合并操作
    points=points[np.where(x2-x1<y2-y1)[0]]
    # points=points[:13]
    # print('points:',points)
    # # debug to show
    # for i,point in enumerate(points):
    #         font = cv2.FONT_HERSHEY_SIMPLEX
    #         cv2.putText(img, str(i), (point[0], point[1]), font, 2.5, (255, 255, 255), 2)
    #         cv2.rectangle(img, (point[0], point[1]), (point[-2], point[-1]), color=(255, 255, 255), thickness=3)
    # cv2.imwrite('img_rect.jpg', img)

    # print(points.shape[0])
    cluster = []
    while points.shape[0]:
        temp=[]
        # print('points:',points)
        #x1-x2<
        index_x = np.where(abs(points[0][-2]-points[:, 0]) < x_dis)[0]
        # print('index_x:',index_x)
        # if len(index_x):
        #     #y1-y1<
        index_y1 = np.where(abs(points[0][1]-points[:, 1]) < y1_dis)[0]
        # print('index_y: ',index_y1)
        #y2-y2<h
        index_y2 = np.where(abs(points[0][-1]-points[:, -1]) < (points[:, -1]-points[:, 1]))[0]
        # print('index_y2:',index_y2)
        # common_index=[i for i in index_x  if i in index_y]
        common_index = list(set(index_x) & set(index_y1) & set(index_y2))
        # print('common_index:',common_index)
        # print('common_index:',common_index)
        if len(common_index):
            temp.append(points[0])
            temp.extend(points[common_index])
            points = np.delete(points, obj=common_index+[0], axis=0)
        else:
            temp.append(points[0])
            points=points[1:]
        cluster.append(temp)

    # # print(points)
    # print('cluster:',cluster)
    # print(len(cluster))
    # for i in range(len(cluster)):
    #     every_cluster=np.array(cluster[i]).reshape(-1,4)
    #     print('every_cluster:',every_cluster)
    #     for point in every_cluster:
    #         font = cv2.FONT_HERSHEY_SIMPLEX
    #         cv2.putText(img, str(i), (point[0],point[1]), font, 2, (255, 255, 255), 2)
    #         cv2.rectangle(img,(point[0],point[1]),(point[-2],point[-1]),color=(255,255,255),thickness=3)
    # cv2.imwrite('img_rect_clu.jpg',img)
    return cluster
def fix_bbox_point(cluster):
    points=[]
    for i,evry_cluster in enumerate(cluster):
        every_cluster = np.array(cluster[i]).reshape(-1, 4)
        x1,y1,x2,y2=np.min(every_cluster[:,0]),np.min(every_cluster[:,1])\
        ,np.max(every_cluster[:,-2]),np.max(every_cluster[:,-1])
        points.append([x1,y1,x2,y2])
    return np.array(points)

def union_bboxs(points):
    cluster_first = get_cluster(points, x_dis=50, y1_dis=300)
    # print('===cluster=====')
    # print(len(cluster_first))
    first_bboxs = fix_bbox_point(cluster_first)

    cluster_second = get_cluster(first_bboxs, x_dis=50, y1_dis=300)
    # print('===cluster=====')
    # print(len(cluster_second))
    second_bboxs = fix_bbox_point(cluster_second)

    cluster_third = get_cluster(second_bboxs, x_dis=50, y1_dis=400)
    # print('===cluster=====')
    # print(len(cluster_third))
    third_bboxs = fix_bbox_point(cluster_third)
    return third_bboxs

if __name__ == '__main__':
    # points = np.array([[1264, 1480, 1346, 1790],
    #                    [2278, 1873, 2380, 2542],
    #                    [3209, 2279, 3286, 2599],
    #                    [2195, 3468, 2277, 3772],
    #                    [844, 1087, 924, 1399],
    #                    [92, 876, 181, 1327],
    #                    [951, 306, 1033, 596],
    #                    [1652, 299, 1729, 604],
    #                    [2196, 1957, 2270, 2535],
    #                    [916, 4251, 994, 4563],
    #                    [1131, 1915, 1214, 2505],
    #                    [1042, 265, 1116, 532],
    #                    [2124, 2036, 2195, 2603],
    #                    [934, 1054, 1003, 1258],
    #                    [1522, 3561, 1585, 4086],
    #                    [999, 4220, 1068, 4422],
    #                    [2404, 586, 2516, 1209],
    #                    [1452, 3618, 1528, 4151],
    #                    [1354, 1449, 1425, 1655],
    #                    [1583, 3532, 1683, 4109],
    #                    [1207, 1525, 1256, 1792],
    #                    [2144, 3511, 2191, 3779],
    #                    [3162, 2319, 3205, 2549],
    #                    [787, 1124, 837, 1395],
    #                    [896, 339, 944, 606],
    #                    [1741, 260, 1813, 467],
    #                    [219, 3230, 330, 3785],
    #                    [1424, 2675, 1506, 2818],
    #                    [2528, 538, 2714, 1709],
    #                    [2287, 664, 2394, 1596],
    #                    [231, 1703, 428, 2598],
    #                    [287, 248, 473, 1638],
    #                    [186, 280, 265, 1025],
    #                    [1670, 3480, 1756, 3852],
    #                    [1754, 2277, 1836, 2431],
    #                    [3284, 2241, 3360, 2455],
    #                    [2823, 1662, 3163, 1730],
    #                    [2897, 2852, 3285, 2946],
    #                    [2972, 2700, 3049, 2790]])

    points=np.array([[700,1888,  789, 2199],
                     [1918, 1487, 2000, 1798],
                     [1045,  683, 1129,  995],
                     [2867,  279, 2975,  958],
                     [1929, 3088, 2012, 3393],
                     [1006,  272, 1087,  583],
                     [2476, 3089, 2560, 3396],
                     [ 820, 3094,  904, 3406],
                     [2532, 3499, 2616, 3810],
                     [1335, 1080, 1411, 1378],
                     [2204, 2283, 2288, 2587],
                     [1138,  644, 1213,  975],
                     [1611, 1884, 1695, 2196],
                     [2823, 2283, 2906, 2603],
                     [ 773, 2286,  853, 2606],
                     [1562,  262, 1642,  585],
                     [2458, 1883, 2540, 2196],
                     [1749, 3491, 1831, 3803],
                     [ 634, 1266,  715, 1785],
                     [1646,  236, 1722,  515],
                     [ 988, 3889, 1060, 4221],
                     [ 725, 1167,  836, 1743],
                     [2592,  455, 2703, 1365],
                     [2721,  375, 2853, 1289],
                     [ 846, 1104,  938, 1481],
                     [ 857, 2255,  935, 2583],
                     [1419, 1043, 1494, 1316],
                     [1707, 2310, 1814, 3001],
                     [1327, 3046, 1405, 3387],
                     [1244, 3081, 1327, 3404],
                     [1814, 2264, 1903, 2656],
                     [2543, 1844, 2617, 2053],
                     [2845, 3894, 2918, 4215],
                     [2147, 2330, 2197, 2559],
                     [2402, 1922, 2452, 2198],
                     [1058, 3860, 1122, 4065],
                     [3308, 1779, 3396, 2183],
                     [2293, 2248, 2370, 2454],
                     [1857, 1531, 1908, 1760],
                     [1697, 3535, 1745, 3803],
                     [1189, 3133, 1236, 3367],
                     [2419, 3135, 2468, 3360],
                     [1873, 3124, 1923, 3400],
                     [ 988,  719, 1038,  995],
                     [2480, 3539, 2529, 3809],
                     [2017, 3057, 2083, 3278],
                     [2095, 2368, 2138, 2598],
                     [ 766, 3135,  815, 3409],
                     [1559, 1964, 1607, 2160],
                     [1504, 1966, 1550, 2202],
                     [2913, 2248, 2996, 2455],
                     [ 766, 4318,  838, 4580],
                     [1802, 1571, 1848, 1797],
                     [ 374,  801,  457, 1032],
                     [ 637, 1926,  690, 2164],
                     [1636, 2441, 1708, 2998],
                     [ 964,  353, 1012,  549],
                     [3243,  290, 3389, 1431],
                     [1869, 3963, 1952, 4206],
                     [3131, 2120, 3215, 2800],
                     [2858, 4314, 2934, 4593],
                     [2802, 3939, 2844, 4189],
                     [ 484,  716,  570,  955],
                     [2913, 3860, 2988, 4126],
                     [ 330,  645,  566,  717]])


    # print(points[30:33])
    # points = points[12:21]
    img = np.zeros((5000, 4000))
    cluster_first=get_cluster(points,x_dis=50,y1_dis=300)
    print('===first cluster=====')
    print(len(cluster_first))
    first_bboxs=fix_bbox_point(cluster_first)
    print('===second cluster===')
    cluster_second = get_cluster(first_bboxs, x_dis=50, y1_dis=400)
    print(len(cluster_second))
    second_bboxs = fix_bbox_point(cluster_second)
    # #debug
    # for i,point in enumerate(first_bboxs):
    #     font = cv2.FONT_HERSHEY_SIMPLEX
    #     cv2.putText(img, str(i), (point[0], point[1]), font, 2.5, (255, 255, 255), 2)
    #     cv2.rectangle(img, (point[0], point[1]), (point[-2], point[-1]), color=(255, 255, 255), thickness=3)
    # cv2.imwrite('img_rect_first_bbx.jpg', img)
    #
    #
    # # debug
    # for i, point in enumerate(second_bboxs):
    #     font = cv2.FONT_HERSHEY_SIMPLEX
    #     cv2.putText(img, str(i), (point[0], point[1]), font, 2.5, (255, 255, 255), 2)
    #     cv2.rectangle(img, (point[0], point[1]), (point[-2], point[-1]), color=(255, 255, 255), thickness=3)
    # cv2.imwrite('img_rect_second_bbx.jpg', img)

    cluster_third = get_cluster(second_bboxs, x_dis=50, y1_dis=400)
    print('===cluster=====')
    print(len(cluster_third))
    third_bboxs = fix_bbox_point(cluster_third)
    # debug
    for i, point in enumerate(third_bboxs):
        font = cv2.FONT_HERSHEY_SIMPLEX
        cv2.putText(img, str(i), (point[0], point[1]), font, 2.5, (255, 255, 255), 2)
        cv2.rectangle(img, (point[0], point[1]), (point[-2], point[-1]), color=(255, 255, 255), thickness=3)
    cv2.imwrite('img_rect_third_bbx.jpg', img)

合并前： 

合并后：

薛定谔的智能
关注
专栏目录
关于外边框相邻合并
fingerartist的博客
05-24 1504
关于外边框相邻合并@[TOC] 外边距合并以及清除外边距合并 什么是外边距合并和内外边距合并? 外边距合并以及内外边距合并的清除方式 外边距合并其实就是两个不同标签元素的外边距发生了合并，标签之间没有内边距、边框，设置外边距margin时，即两个外边距合并成了一个，显示边距大的。 那么问题来了，一般外边距合并有哪几种情况呢？小编这里就简单说一下三种情况，如有不周之处，还望指正！！！！ 1、两个块级兄弟元素。 2、父子级关系的元素。 3、页面固定位置的元素。 前两者就不多说了，相信很多人都遇见过，清除方式也很
UG编程常用刀路参数功能详解，值得收藏的内容
j13712128767的博客
04-23 5905
UG软件的功能非常的多，尤其是用UG编程的，需要了解得很多，但其实最常用的也就是5个刀路功能，下面就给大家分享一下功能的介绍！ 平面铣 （常用于加工平面） 15种平面铣加工方式图标： ① 表面区域铣加工方式图标，需要以面定仪切削区域。 ② 表面铣加工方式图标，用于加工表面几何。 ③ 表面铣加工方式图标，用于默认切削方式为混合。 ④ 平面铣加工方式图标，当用户定义切削边界和底面后系统将切削加工至底平面 。平面铣加工方式可满足一般的平面加工方式具有通用性 ⑤ 平面轮廓铣式为切削轮廓 ⑥ 跟随零件粗加工方式，默
合并多个过小的相邻bound boxes
weixin_44210775的博客
07-24 461
合并多个过小的相邻bound boxes 做目标检测时，训练集中有一些过小（占图片比例过小）且相邻的bound box. 我写了一个简单的函数将所有boundbox合并。 import cv2 def is_small_box(loc, w, h, thre=0.1): return ((loc[3]-loc[1])<thre*h)&((loc[2]-loc[0])<thre*w) def merge_bound_box_near(locs, w, h, thre=0.01):
重叠相邻的多个矩形框进行合并
qq_36638362的博客
12-23 4126
分割出的多个矩形框，进行合并（重叠/相邻） 重叠把代码中的20和5去掉即可，其中：20代表左右相邻距离20个像素，5代表上下相邻5个像素 应用范围发票字符检测。等 int num; do { num = 0; for (size_t i = 0; i < rects.size(); i++) { for (size_t j = 0; j < rects....
图像中检测出的m个小矩形框按照彼此相邻合并成n个大矩形框C++代码
安大小旋风的博客
07-04 2791
注：本人的图像中的框大小都一样，使用了opencv的中的Mat格式。可能有BUG，还请指正！效果如下图所示： 代码链接：https://download.csdn.net/download/crossing2012/11274508 原代码函数前面我是带类声明的，可能你不需要，请自行修改，核心函数全部都贴上了。 【上述链接的核心代码写的有些冗余，现贴上最新的核心代码】 /*函数功...
Python合并重叠矩形框
xfxuezhang.cn
01-21 1万+
将重叠框合并为一个大的框
matlab的自定义常数是a,Simulink仿真入门到精通（二） Simulink模块
weixin_39553776的博客
03-18 4639
2.1 Simulink模块的组成要素用户构建系统模型时无需直接面对成千上万行的代码，而是通过模块化图形界面以模块化的方式构建，能够使理解变得容易，让大脑减负。通过层次化模块分布将系统功能模块化，而将每个功能的细节隐藏在模块内部。模块的构成元素输入/输出端口：作为模块之间传递数据的纽带，连接输入信号和输出信号。模块外观：通常为矩形或圆形，上面带有说明文字或图像并显示有输出/输出端口名。模块对话框：...
基于分治法和DCEL数据结构的Delaunay三角剖分
donkeylong的专栏
12-01 9903
平面点集的 Delaunay 三角剖分简介以下文字摘自互动百科： 　　Voronoi图，又叫泰森多边形或Dirichlet图，它是由一组由连接两邻点直线的垂直平分线组成的连续多边形组成。N个在平面上有区别的点，按照最邻近原则划分平面，每个点与它的最近邻区域相关联。Delaunay三角形是由与相邻Voronoi多边形共享一条边的相关点连接而成的三角形。Delaunay三角形的外接圆圆
数字图像处理——第十章（图像分割）
denglavender的博客
06-15 1万+
形态学图像处理中，输入的是图像，输出的是从图像中提取出来的属性，分割是该方向上的另一步骤。 分割将图像细分为构成它的子区域或物体。细分的程度取决于要解决的问题。当感兴趣的物体或区域已经被检测出来了，那就停止分割。 单色图像的分割算法通常基于灰度值的两个基本性质：不连续性和相似性。第一种是以灰度变换（即灰度的突变）为基础分割图像，如边缘检测；第二种是根据事先预定义的相似性准则把图像分成相似的区域，如阈值分割、区域生长。 图像分割的数学描述 令R表示一幅图像占据的整个空间区域。将图像分割视为把R分为n个子区域R
数字图像处理
weixin_47560863的博客
03-02 2865
基础 人眼与相机 ISO : 大、对入射光的敏感性、放大噪声 光圈大: 进光量大、景深小、背景模糊 红眼: 视网膜是橘红色 主观亮度是光强的对数函数 数字图像 图像坐标系逆时针转90度，就是常见的坐标系 最近邻插值、双线性插值、双三次插值(16个顶点) D4D_4D4​曼哈顿距离、D8D_8D8​棋盘格距离(包含斜对角线) 图像增强 改善图像，以便于人的观看或自动的图像分析与识别 灰度变换 反色: s=1−rs= 1-rs=1−r 幂函数: s=rγs = r^\gammas=rγ、 γ
python合并bbox(heatmap定位)
baidu_40840693的博客
12-02 1147
参考: https://stackoverflow.com/questions/55593506/merge-the-bounding-boxes-near-by-into-one #Generate two text boxes a larger one that covers them def merge_boxes(box1, box2): return [min(box1[0], box2[0]), min(box1[1], box2[1]), ma
h, w = img.shape什么意思？
weixin_44682222的博客
09-12 1万+
image.shape属性是读入图片后的一个元组dutuple 返回图片的(高,宽,位深) 比如image.shape返回(687, 740, 3) 而h,w=(687, 740, 3) 分解了元组并分别用h,w获得了前两个数据，即高687、宽740
7-2 横平竖直 (10分)
sddfnsff的博客
06-14 3083
程序填空题。根据题目要求完善下面的代码。请提交完整代码。 一个木块如果高度比宽度大，我们说它是竖着放的，否则我们说它是平放的。 读入一个木块的高度和宽度。如果它是平放的，则输出A，否则输出B。 import java.util.Scanner; public class Main{ public static void main(String[] args){ Scanner in = new Scanner(System.in); int height, width; char status; heigh
『Python笔记』python中的for循环总结(enumerate)
热门推荐
AI新视界
11-19 6万+
目录 1、可以明确循环的次数 2、iteratle_object(可迭代对象) 3、enumerate()使用方法为 4、补充：统计文件行数可以这样写： 1、可以明确循环的次数 遍历一个数据集内的成员 在列表解析中使用 生成器表达式中使用 2、iteratle_object(可迭代对象) String（字符串） List（列表） Tuple（元组） Dictionary...
马尔科夫聚类python实现_python实现mean-shift聚类算法
weixin_39618824的博客
12-11 519
本文实例为大家分享了python实现mean-shift聚类算法的具体代码，供大家参考，具体内容如下1、新建MeanShift.py文件import numpy as np# 定义 预先设定 的阈值STOP_THRESHOLD = 1e-4CLUSTER_THRESHOLD = 1e-1# 定义度量函数def distance(a, b):return np.linalg.norm(np.arra...
python轮廓合并
jacke121的专栏
03-26 6024
OpenCV python 轮廓之间的距离(相似性) 处理图片:[cs1.jpg] 处理图片:[cs2.jpg] 处理图片:[hand.jpg] import cv2 def get_contours(img): """获取连通域 :param img: 输入图片 :return: 最大连通域 """ # 灰度化, 二值化, 连通域分析 img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) ...
第二次过程性考核
weixin_30417487的博客
10-13 692
第二次过程性考核——面向对象程序设计 -------------------------------------------------------------------------------------------------------------------------------------------------- 码云仓库地址：https://gitee.com/sm...
判断点是否在多边形的内部(C#)
weixin_33851177的博客
10-13 898
要判断点是否在多边形的内部，适用于任意多边形的方法最常用的就是射线法，即以要判断的点向左或者向右作水平射线，与多边形交点的个数为奇数个时则在多边形的内部，若为偶数个交点时则在多边形的外部，其中0个交点也为偶数个交点。 依据该原理，于是有了第一种实现 /// <summary> /// 判断点是否在多边形内. ///...
python如何将一个手绘的迷宫图通过图像处理使其变得方方正正线条横平竖直
最新发布
06-14
要将手绘的迷宫图变得方方正正线条横平竖直，可以通过以下步骤实现： 1. 读取迷宫图像，并将其转换为灰度图像。 2. 对灰度图像进行二值化处理，将其转换为黑白图像。 3. 对黑白图像进行膨胀操作，使得迷宫的边界更加明显。 4. 对膨胀后的图像进行边缘检测，找到迷宫的边界。 5. 对边界进行直线拟合，得到迷宫的直线边界。 6. 根据直线边界将迷宫图像进行扭曲矫正，使其变得方方正正线条横平竖直。 代码示例： ```python import cv2 import numpy as np # 读取迷宫图像并转换为灰度图像 img = cv2.imread('maze.jpg') gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # 将灰度图像进行二值化处理 thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)[1] # 对二值化后的图像进行膨胀操作 kernel = np.ones((5, 5), np.uint8) dilation = cv2.dilate(thresh, kernel, iterations=5) # 对膨胀后的图像进行边缘检测 edges = cv2.Canny(dilation, 100, 200) # 对边缘进行直线拟合 lines = cv2.HoughLines(edges, 1, np.pi/180, 200) for line in lines: rho, theta = line[0] a = np.cos(theta) b = np.sin(theta) x0 = a*rho y0 = b*rho x1 = int(x0 + 1000*(-b)) y1 = int(y0 + 1000*(a)) x2 = int(x0 - 1000*(-b)) y2 = int(y0 - 1000*(a)) cv2.line(img, (x1,y1), (x2,y2), (0,0,255), 2) # 对图像进行扭曲矫正 rows, cols = img.shape[:2] src_pts = np.float32([[0, 0], [cols-1, 0], [0, rows-1], [cols-1, rows-1]]) dst_pts = np.float32([[0, 0], [cols-1, 0], [cols*0.1, rows-1], [cols*0.9, rows-1]]) M = cv2.getPerspectiveTransform(src_pts, dst_pts) warped = cv2.warpPerspective(img, M, (cols, rows)) # 显示结果 cv2.imshow('Original', img) cv2.imshow('Warped', warped) cv2.waitKey(0) cv2.destroyAllWindows() ``` 注：以上代码仅供参考，具体实现应根据实际情况进行调整。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值