一个计算任意凸多边形重叠面积的算法

最新推荐文章于 2024-07-25 11:44:32 发布
最新推荐文章于 2024-07-25 11:44:32 发布
阅读量2.1k 收藏 8
点赞数
分类专栏： cfd 文章标签： 几何学 算法 cfd
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fz200923180031/article/details/108190586
版权

任意凸多边形重叠面积计算

简介

本算法可以用来计算任意给定的两个凸多边形的重叠面积。算法思路写起来比较麻烦，希望大家能自己跟着代码走，把思路捋清楚。初次实现这个算法我是用fortran语言编写的，但考虑到除了做科学计算的群体以外似乎用fortran的不多，所以这边在原代码的基础上将它改写成了C++，由于基本是从Fortran逐行改过来的，所以一些代码细节可能会看着别扭。另外，算法的思路是适用于任意两个凸多边形重叠面积计算的，不过下面代码中我是假设了多边形类型只包括三角形和四边形（当时我的任务中只涉及到这两个类型），所以很多变量没用动态类型，因为边数最多为4。
好了，不多说了，直接贴代码。。算法的重点在 “重叠形状的重建”那一块。

完整代码

#include <stdio.h>
#include <iostream>
#include <vector>
#include <math.h>

using namespace std;

typedef struct{
	int nVer;
	double coord[4][2];
} t_polygon;

bool PointInPolygon(double* coord, t_polygon* polygon) {
    
	bool res;
	double vec1[2], vec2[2], ref, tmp;
	int i, nVer, point2;

	nVer = polygon->nVer;
	vec1[0] = polygon->coord[1][0] - polygon->coord[0][0];
	vec1[1] = polygon->coord[1][1] - polygon->coord[0][1];
	vec2[0] = coord[0] - polygon->coord[0][0];
	vec2[1] = coord[1] - polygon->coord[0][1];

	ref = vec1[0] * vec2[1] - vec1[1] * vec2[0];

	res = true;

	for (i = 2; i <= nVer; i++){
		point2 = i + 1;
		if (i == nVer) point2 = 1;
		vec1[0] = polygon->coord[point2 - 1][0] - polygon->coord[i - 1][0];
		vec1[1] = polygon->coord[point2 - 1][1] - polygon->coord[i - 1][1];
		vec2[0] = coord[0] - polygon->coord[i-1][0];
		vec2[1] = coord[1] - polygon->coord[i-1][1];
		tmp = vec1[0] * vec2[1] - vec1[1] * vec2[0];
		if (tmp*ref < 0.0) res = false;
	}
	
	return res;
}

double CalArea(int nVer, double** coord){
	double area;
	int i, point1, point2;

	area = 0.0;
	for (i = 1; i <= nVer; i++){
		point1 = i;
		point2 = i + 1;
		if (i == nVer) point2 = 1;

		area += ((coord[point2-1][0] + coord[point1-1][0])*(coord[point2-1][1] - coord[point1-1][1]));
	}

	area = 0.5*fabs(area);
	return area;
}

double OverlappedArea(t_polygon* polygon1, t_polygon* polygon2){
	  
	//calculate the overlapped area of two arbitrary convex polygon.Here, only triangel and quadrangle are considered.
	double olp_area;
	t_polygon* polygon_tmp;
	double (*coord1)[2], (*coord2)[2], (*coord_tmp)[2];
	double** coord_new = nullptr;
	double coord_intpoin[8][2];      //coordinate of the intersection point.最多有8个交点。
	int connections[4][4] = { { -1, -1, -1, -1 }, { -1, -1, -1, -1 }, { -1, -1, -1, -1 }, { -1, -1, -1, -1 } },  //used to indicate which intersection point it is.
		intpoin_on_edge1[4][2] = { { -1, -1 }, { -1, -1 }, { -1, -1 }, { -1, -1 } },      //used to indicate which edge intersect with the current edge.For polygon1.
		intpoin_on_edge2[4][2] = { { -1, -1 }, { -1, -1 }, { -1, -1 }, { -1, -1 } };		 //used to indicate which edge intersect with the current edge.For polygon2.
	int (*intpoin_on_edge)[2];		 // a temp pointer
	int tag[16] = {0};				 // 4 vertices + 4 vertices + 8 intpoins
	vector<int> vec_vtx;			 // store vertices
	bool inPolygon;
	int i, j, iVer, i_next, i_tmp, iEdge,
		idxA, idxB, idxP, idxQ;		 // edge(A, B), and edge(P, Q)
	int nVer, nVer1, nVer2, counter;
	double PA[2], QA[2], norm[2], coord_m[2], temp, t, d, e, t_old;
	double eps = 1e-14;
	int error;

	coord1 = polygon1->coord;
	coord2 = polygon2->coord;
	nVer1 = polygon1->nVer;
	nVer2 = polygon2->nVer;
	
	counter = 0;

	//determine intpoin_on_edge1
	for (i = 1; i <= nVer1; i++){
		idxP = i;
		idxQ = i + 1;
		if (idxP == nVer1) idxQ = 1;
		for (j = 1; j <= nVer2; j++){
			idxA = j;
			idxB = j + 1;
			if (idxA == nVer2) idxB = 1;
			norm[0] = coord2[idxA - 1][1] - coord2[idxB - 1][1]; //AB = (x,y), then norm = (-y,x)
			norm[1] = coord2[idxB - 1][0] - coord2[idxA - 1][0];
			norm[0] = norm[0] / sqrt(norm[0] * norm[0] + norm[1] * norm[1]);
			norm[1] = norm[1] / sqrt(norm[0] * norm[0] + norm[1] * norm[1]);
			
			PA[0] = coord2[idxA-1][0] - coord1[idxP-1][0];
			PA[1] = coord2[idxA - 1][1] - coord1[idxP - 1][1];

			QA[0] = coord2[idxA-1][0] - coord1[idxQ-1][0];
			QA[1] = coord2[idxA - 1][1] - coord1[idxQ - 1][1];
			d = PA[0] * norm[0] + PA[1] * norm[1];
			e = QA[0] * norm[0] + QA[1] * norm[1];

			if (d*e >= 0.0) continue;
			
			t = d / (d - e);
			coord_m[0] = (1.0 - t)*coord1[idxP-1][0] + t*coord1[idxQ-1][0];
			coord_m[1] = (1.0 - t)*coord1[idxP - 1][1] + t*coord1[idxQ - 1][1];
			if ((coord_m[0] - coord2[idxA-1][0])*(coord_m[0] - coord2[idxB-1][0]) +
				(coord_m[1] - coord2[idxA-1][1])*(coord_m[1] - coord2[idxB-1][1]) <= 0.0) {

				counter += 1;
				coord_intpoin[counter - 1][0] = coord_m[0];
				coord_intpoin[counter - 1][1] = coord_m[1];
				connections[j-1][i-1] = counter;
			
				if (intpoin_on_edge1[i-1][0]==-1){
					intpoin_on_edge1[i-1][0] = j;
					t_old = t;
				}
				else{
					if (t < t_old){
						intpoin_on_edge1[i-1][1] = intpoin_on_edge1[i-1][0];
						intpoin_on_edge1[i-1][0] = j;
					}else
						intpoin_on_edge1[i-1][1] = j;
					break;
				}
			}
		}
	}

	/*for (i = 0; i < 4; i++){
		for (j = 0; j < 4; j++){
			printf("%d  ", connections[i][j]);
		}
		printf("\n");
	}*/

	//determine intpoin_on_edge2
	for (i = 1; i <= nVer2; i++){
		idxP = i;
		idxQ = i + 1;
		if (idxP == nVer2) idxQ = 1;

		for (j = 1; j <= nVer1; j++){
			idxA = j;
			idxB = j + 1;
			if (idxA == nVer1) idxB = 1;

			norm[0] = coord1[idxA-1][1] - coord1[idxB-1][1];
			norm[1] = coord1[idxB-1][0] - coord1[idxA-1][0];
			norm[0] = norm[0] / sqrt(norm[0] * norm[0] + norm[1] * norm[1]);
			norm[1] = norm[1] / sqrt(norm[0] * norm[0] + norm[1] * norm[1]);

			PA[0] = coord1[idxA - 1][0] - coord2[idxP - 1][0];
			PA[1] = coord1[idxA - 1][1] - coord2[idxP - 1][1];
			QA[0] = coord1[idxA - 1][0] - coord2[idxQ - 1][0];
			QA[1] = coord1[idxA - 1][1] - coord2[idxQ - 1][1];
			d = PA[0] * norm[0] + PA[1] * norm[1];
			e = QA[0] * norm[0] + QA[1] * norm[1];

			if (d*e >= 0.0) continue;

			t = d / (d - e);
			coord_m[0] = (1.0 - t)*coord2[idxP-1][0] + t*coord2[idxQ-1][0];
			coord_m[1] = (1.0 - t)*coord2[idxP - 1][1] + t*coord2[idxQ - 1][1];
			if ((coord_m[0] - coord1[idxA - 1][0])*(coord_m[0] - coord1[idxB - 1][0]) +
				(coord_m[1] - coord1[idxA - 1][1])*(coord_m[1] - coord1[idxB - 1][1]) <= 0.0){

				if (connections[i-1][j-1] == -1){
					counter += 1;
					coord_intpoin[counter-1][0] = coord_m[0];
					coord_intpoin[counter - 1][1] = coord_m[1];
					connections[i-1][j-1] = counter;
				}
				if (intpoin_on_edge2[i-1][0]==-1){
					intpoin_on_edge2[i-1][0] = j;
					t_old = t;
				}
				else{
					if (t < t_old){
						intpoin_on_edge2[i - 1][1] = intpoin_on_edge2[i - 1][0];
						intpoin_on_edge2[i - 1][0] = j;
					}else
						intpoin_on_edge2[i-1][1] = j;
					break;
				}
			}
		}
	}
	
	// if there is no intersection point
	if (counter == 0){
		coord_new = new double*[4];
		for (i = 0; i < 4; i++){
			coord_new[i] = new double[2];
		}
		for (i = 0; i < nVer1; i++){
			coord_new[i][0] = coord1[i][0];
			coord_new[i][1] = coord1[i][1];
		}
		temp = CalArea(nVer1,coord_new);
		for (i = 0; i < nVer2; i++){
			coord_new[i][0] = coord2[i][0];
			coord_new[i][1] = coord2[i][1];
		}
		olp_area = CalArea(nVer2, coord_new);
		if (temp < olp_area) olp_area = temp;

		if (coord_new != nullptr){
			for (i = 0; i < 4; i++){
				delete[] coord_new[i];
			}
			delete[] coord_new;
		}

		return olp_area;
	}

	//constructe the overlapped shape
	i = 1;
	iEdge = 1;
	inPolygon = PointInPolygon(coord1[0], polygon2);
	do {
		if (i <= 4){
			iVer = i;
			//iEdge = i;
			if (i != 4)
				i_next = i + 1;
			else
				i_next = 1;
			coord_tmp = coord1;
			polygon_tmp = polygon2;
			intpoin_on_edge = intpoin_on_edge1;
		}
		else if (i <= 8){
			iVer = i - 4;
			//iEdge = i;
			if (i != 8)
				i_next = i + 1;
			else
				i_next = 5;
			coord_tmp = coord2;
			polygon_tmp = polygon1;
			intpoin_on_edge = intpoin_on_edge2;
		}
		else {//i>8
			switch(iEdge){
			case 1:
			case 2:
			case 3:
				iVer = iEdge + 1;
				coord_tmp = coord1;
				polygon_tmp = polygon2;
				break;
			case 4:
				iVer = 1;
				coord_tmp = coord1;
				polygon_tmp = polygon2;
				break;
			case 5:
			case 6:
			case 7:
				iVer = iEdge + 1 - 4;
				coord_tmp = coord2;
				polygon_tmp = polygon1;
				break;
			case 8:
				iVer = 1;
				coord_tmp = coord2;
				polygon_tmp = polygon1;
				break;
			}
		}

		if (i <= 8){
			if (inPolygon){
				vec_vtx.push_back(i);
				tag[i-1] = 1;
				if (intpoin_on_edge[iVer-1][0]==-1){
					i = i_next;
					iEdge = i_next;
					inPolygon = true;
				}
				else{
					if (i <= 4){
						i = 8 + connections[intpoin_on_edge[iVer - 1][0]-1][iVer - 1];
						iEdge = 4 + intpoin_on_edge[iVer - 1][0];
					}
					else{
						i = 8 + connections[iVer-1][intpoin_on_edge[iVer-1][0]-1];
						iEdge = intpoin_on_edge[iVer-1][0];
					}
				}
			}
			else{
				if (intpoin_on_edge[iVer - 1][0] == -1){
					i = i_next;
					iEdge = i_next;
					inPolygon = false;
				}
				else{
					if (i <= 4)
						//iEdge = i,
						i = 8 + connections[intpoin_on_edge[iVer - 1][0]-1][iVer - 1];
					else
						//iEdge = i,
						i = 8 + connections[iVer - 1][intpoin_on_edge[iVer - 1][0]-1];
				}
			}
		}
		else{ //i>8
			vec_vtx.push_back(i);
			tag[i - 1] = 1;
			if (PointInPolygon(coord_tmp[iVer-1], polygon_tmp)){
				if (iEdge <= 4)
					i = iVer;
				else
					i = iVer + 4;
				inPolygon = true;
			}
			else{
				if (iEdge <= 4){
					i = 8 + connections[intpoin_on_edge1[iEdge - 1][1]-1][iEdge - 1];
					iEdge = 4 + intpoin_on_edge1[iEdge - 1][1];
				}
				else{
					i = 8 + connections[iEdge-4-1][intpoin_on_edge2[iEdge - 4 - 1][1]-1];
					iEdge = intpoin_on_edge2[iEdge-4-1][1];
				}
			}
		}
	} while (tag[i - 1] == 0);

	//calculate the polygon area according to its vertices 
	nVer = vec_vtx.size();
	coord_new = new double* [nVer];
	for (i = 0; i < nVer; i++){
		coord_new[i] = new double [2];
	}

	for (i = 1; i <= nVer; i++){
		j = vec_vtx[i-1];
		if (j <= 4){
			coord_new[i - 1][0] = coord1[j - 1][0];
			coord_new[i - 1][1] = coord1[j - 1][1];
		}
		else if(j<=8){
			coord_new[i - 1][0] = coord2[j - 4 - 1][0];
			coord_new[i - 1][1] = coord2[j - 4 - 1][1];
		}
		else{
			coord_new[i - 1][0] = coord_intpoin[j - 8 - 1][0];
			coord_new[i - 1][1] = coord_intpoin[j - 8 - 1][1];
		}
	}

	olp_area = CalArea(nVer, coord_new);

	if (coord_new != nullptr){
		for (i = 0; i < nVer; i++){
			delete[] coord_new[i];
		}
		delete[] coord_new;
	}

	return olp_area;
}
	

int PolygonRcs(t_polygon* polygon, int nVer, double coord[4][2]){
	int i, j;
	polygon->nVer = nVer;
	for (i = 0; i < nVer; i++){
		for (j = 0; j < 2;j++)
			polygon->coord[i][j] = coord[i][j];
	}
	return 0;
}


void main(){

	t_polygon *polygon1, *polygon2;
	double olp_area;
	//double coord1[4][2] = { { 0.0, 0.0 }, { 0.5, 0.8660254 }, { 1.0, 0.0 }, { 0.0, 0.0 } };
	//double coord2[4][2] = { { 0.5, 0.5 }, { 1.5, 0.5 }, { 1.5, -0.5 }, { 0.5, -0.5 } };
	double coord1[4][2] = { { 0.0, 0.0 }, { 0.5, 0.8660254 }, { 1.0, 0.0 }, { 0.0, 0.0 } };
	double coord2[4][2] = { { 0.1, 0.5 }, { 0.9, 0.5 }, { 0.9, -0.5 }, { 0.1, -0.5 } };

	polygon1 = new t_polygon;
	polygon2 = new t_polygon;

	PolygonRcs(polygon1, 3, coord1);
	PolygonRcs(polygon2, 4, coord2);

	olp_area = OverlappedArea(polygon1, polygon2);

	printf("overlapped area = %f\n", olp_area);
	
	getchar();
}
jianzheng590
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
凸多边形判断_求解两个任意凸多边形的IOU值
weixin_39622710的博客
12-16 625
计算任意两个凸多边形 的IOU值。（根据两个凸多边形的顶点坐标计算）分别计算每一个凸多边形的面积。利用向量叉乘求面积。计算两个凸多边形的相交面积。两个凸多边形相交区域构成的多边形L，先求出L的各个顶点，然后再求出面积。L的顶点包括凸多边形 在 中的顶点、 在 中的顶点以及 与 的交点。 一、计算凸多边形的面积 我们知道三角形abc的面积可以由1/2absin(θ)求出，其...
凸多边形重叠计算
在到处之间找我
11-29 3967
文章目录前言求交点前进情况$P_{i-1}P_i 和 Q_{j-1}Q_j$ 夹角伪代码排列交点和顶点伪代码交点个数完整伪代码 前言 两个凸多边形的重叠问题就是对两个凸多边形求相交部分的问题。约定凸多边形指它的边界和内部，凸多边形仍用顶点坐标的逆时针方向序列确定。 设给出的两个凸多边形 P 和 Q 的顶点序列分别是 P1,P2,…,PL 和 Q1,Q2,…,Qm。 假设 P 的边界上不包含 Q 的...
Python | 凸多边形间重叠面积计算
lovetaozibaby的博客
10-20 1万+
简介 跟某人讨论一个排样问题。 他说，算法搜索速度很慢，每两个物体间的重叠面积计算时间若按1s来算，300个物体需要计算将近9万次。 我说，这用计算机视觉难道不是几句话解决的嘛！ （小小的嘚瑟一把，虽然做了这么久的CV，一直觉得自己一无所成，但是没想到默默的就能解决别人的问题了哈哈哈~~） 本文档目的为： 给定的数据为多边形的各个顶点，为N*2的矩阵，N 为多边形的顶点个数，计算任意两个多边形重叠...
计算两个多边形的重叠面积（C++）
qq_43561784的博客
04-19 1045
【代码】计算两个多边形的重叠面积（C++）
【计算几何】凸多面体重叠判断算法：GJK 算法详解 & C++代码实现二维情形的凸多边形重叠判断
热门推荐
知不足而奋进，望远山而前行
01-21 2万+
GJK 算法是由 Gilbert，Johnson，Keerthi 三位前辈发明的，用来计算两个凸多面体之间的碰撞检测，以及最近距离。GJK 算法可以在OMNO(M+N)OMN的时间复杂度内，检测出碰撞，算法在每次迭代的过程中，都会优先选择靠近原点的方向，因此收敛速度会很快。算法的证明过程比较复杂，但是原理还是比较容易理解的。GJK的初衷是确定两个凸包之间的距离。GJK还可以用于在小距离穿透情况下获取碰撞信息，并可以通过其他算法进行补充以实现更大距离的穿透。通过随机的方式获取初始方向。
计算两个不规则多边形重叠的面积
xuyin1204的博客
05-20 3344
#include <iostream> #include <cmath> #include <cstring> using namespace std; const int maxn = 300; const double eps = 1e-6; int dcmp(double x) { if(x > eps) return 1; return x < -eps ? -1 : 0; } struct Point { double x
python求图形面积_求高效的，计算两多边形重叠面积的算法，python实现
weixin_39560066的博客
11-25 695
[Asm] 纯文本查看 复制代码import randomimport timefrom sympy.geometry import *import numpy as npfrom scipy import statsdef polygon_over_area(obj_a, obj_b):p_a = obj_a # sympy.geometry.Polygonp_b = obj_bx_obj =...
计算图片中两个任意形状多边形相交部分的大小
dddeee的专栏
11-14 322
本文使用opencv实现对于一张图中任意两个多边形相交面积的大小，而且是使用图像处理的方法，思路很是清奇
任意两个多边形（非凸）相交的面积，目前最全的原理讲解及代码
qq_43021748的博客
07-14 1519
项目中遇到一个求两个任意多边形重叠面积的问题，乍一想感觉问题太简单了；然后就出现了下图的尴尬情况：这玩意不好求啊，网上搜索找到一个方案采用了Sutherland-Hodgeman-Polygon-Clipping Algorihtm（自行了解），主要解决了凸多变形重叠区域的contour的寻找，算法的思想就是沿着一个凸多边形的边裁切， 直到将所有的凸多边形的边全部裁切完成。但是面对非凸多边形而且有多个闭合的相交区域的情况的时候，一条边的裁切可能会将另一条边裁掉，因此算法不适用。
计算两个矩形之间的IOU面积和重叠率
06-25
本项目聚焦于计算两个矩形之间的IOU面积和重叠率，这对于理解算法如何判断物体的检测精度至关重要。 首先，我们需要了解IOU的基本概念。IOU是两个矩形交集面积与并集面积的比值，公式可表示为： \[ IOU = \frac{...
python实现图像处理凹多边形交叉面积计算
05-06
计算两个凹多边形交叉面积的常用方法是将其分解为多个凸多边形或三角形，然后分别计算这些部分的面积。这个过程通常包括以下几个步骤： 1. **判断多边形的凸凹性**：可以使用Ray Casting算法（也称作射线法），如果...
计算多边形面积C#代码
07-10
具体来说，对于一个由n个顶点构成的多边形，假设其顶点坐标为(x1, y1), (x2, y2), ..., (xn, yn)，则多边形的面积S可通过下式计算： \[ S = \frac{1}{2} |(x_1y_2 + x_2y_3 + \cdots + x_ny_1) - (y_1x_2 + y_2x_3 ...
动态规划-凸多边形最优三角剖分
11-16
在凸多边形最优三角剖分这一问题中，我们需要找到一种方法，将一个凸多边形分割成尽可能少的三角形，同时使得这些三角形的周长之和最小。这种问题在图形处理、计算机图形学以及计算几何等领域有着重要的应用。 首先...
任意多边形三角化代码，可直接运行
12-29
这里提供的代码实现了一个能够对任意多边形进行三角化的功能，确保了准确性和无误的性能。 首先，我们来看“多边形”的概念。多边形是平面内由一条闭合的连续线段连接而成的图形，这些线段称为边，线段的交点称为...
常见公式的几何解释
人无远虑，必有近忧
05-01 3506
本文旨在深入探讨常见数学公式的几何意义，通过直观的图形和解释，帮助读者更好地理解并掌握这些公式的本质。文章首先概述了公式与几何图形之间的紧密联系，然后选取了几个典型的数学公式，进行详细解析。每个公式都将配以相应的几何图形，通过形象化的方式展示其内在逻辑和实际应用。此外，文章还将讨论如何运用这些几何解释来简化复杂的数学计算，提高解题效率。
2024 暑假友谊赛-热身2
qq_42643660的博客
07-24 983
树的直径，N%m=N-(N/m)*m，期望dp..迷，简单线段树
打卡第22天------回溯算法
GodLoveMe的博客
07-24 638
开始学习了，希望我可以尽快成功上岸！
河南萌新联赛2024第（二）场：南阳理工学院
最新发布
a13997460860的博客
07-25 1163
这场比赛里面出到了很多的题，都是需要很多的时间去写，主要考察到了代码的实现能力，与codeforces里面的题有些差距。codeforces打多了还是有点不习惯的。题挺好的，尤其是H题感觉很考代码实现能力与STL的使用熟练度。多写写这样的题还是对我们很有好处的。只不过前三题都太水了，没有一点难度。
计算两个凹多边形的重叠面积
04-01
计算两个凹多边形的重叠面积可以通过以下步骤实现： 1. 将两个凹多边形分别拆分成多个三角形。 2. 对于每个三角形，判断其是否与另一个多边形有重叠部分。 3. 如果有重叠部分，则计算重叠三角形的面积。 4. 将所有重叠三角形的面积求和即为两个凹多边形的重叠面积。 需要注意的是，在判断三角形是否有重叠部分时，可以使用线段相交的方法进行计算。具体来说，可以对于一个三角形的每条边，判断其是否与另一个多边形的任意一条边相交，如果有相交，则可以计算出相交线段的长度，从而得到重叠部分的面积。 同时，对于凹多边形的拆分，可以使用三角剖分算法进行处理。常见的三角剖分算法包括 Delaunay 三角剖分和 Ear Clipping 算法等。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值