关于特征匹配可视化的cpp实现(参考多种示例)

最新推荐文章于 2023-07-01 23:22:28 发布
最新推荐文章于 2023-07-01 23:22:28 发布
阅读量243 收藏
点赞数
分类专栏： SLAM+SFM 文章标签： opencv 自动驾驶 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_40840693/article/details/106272322
版权 
#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
#include <cmath>
#include <opencv2/opencv.hpp>
# define M_PI           3.14159265358979323846
using namespace std;
using namespace cv;

enum MyEnum
{
	ONLY_LINES = 1,
	LINES_AND_POINTS = 2,
	COLOR_CODED_POINTS_X = 3,
	COLOR_CODED_POINTS_Y = 4,
	COLOR_CODED_POINTS_XpY = 5,
	POINTS_DeepMatch = 6,
	POINTS_DeepMatch_COLOR = 7
};

Mat draw_matches(Mat &matchingImage, vector<uchar> &inliersMask, MyEnum drawing_type, std::vector<Point2f> &obj, std::vector<Point2f> &scene, Mat &retained_matches, cv::Size &img1_size, cv::Size &img2_size)
{
	if (drawing_type == ONLY_LINES)
	{
		for (size_t i = 0; i<inliersMask.size(); i++){
			if (inliersMask[i])
			{
				line(matchingImage, obj[i], scene[i], Scalar(0, 0, 255));
			}
		}
	}
	else if (drawing_type == LINES_AND_POINTS)
	{
		for (size_t i = 0; i<inliersMask.size(); i++){
			if (inliersMask[i])
			{
				line(matchingImage, obj[i], scene[i], Scalar(255, 0, 0));
				circle(matchingImage, obj[i], 1, Scalar(0, 255, 255), 2);
				circle(matchingImage, scene[i], 1, Scalar(0, 255, 0), 2);
			}
		}
	}
	else if ((drawing_type == COLOR_CODED_POINTS_X) || (drawing_type == COLOR_CODED_POINTS_Y) || (drawing_type == COLOR_CODED_POINTS_XpY))
	{
		Mat _1_255(256, 1, CV_8UC1, Scalar(0));
		for (int i = 0; i < _1_255.rows; i++)
			_1_255.at<uchar>(i, 0) = i;
		Mat _colormap;
		applyColorMap(_1_255, _colormap, COLORMAP_HSV);
		int colormap_idx;
		Scalar color;
		for (size_t i = 0; i<inliersMask.size(); i++){
			if (inliersMask[i])
			{
				if (drawing_type == COLOR_CODED_POINTS_X)
					colormap_idx = int(obj[i].x * 256. / img1_size.width); //x - gradient
				if (drawing_type == COLOR_CODED_POINTS_Y)
					colormap_idx = int(obj[i].y * 256. / img1_size.height); //y - gradient
				if (drawing_type == COLOR_CODED_POINTS_XpY)
					colormap_idx = int((obj[i].x - img1_size.width * 0.5 + obj[i].y - img1_size.height * 0.5) * 256. / (img1_size.height * 0.5 + img1_size.width * 0.5)); //manhattan gradient

				colormap_idx = colormap_idx >= 0 ? colormap_idx : 256 + colormap_idx;
				const uchar* inData = _colormap.ptr<uchar>(colormap_idx);
				color = Scalar(inData[0], inData[1], inData[2]);
				circle(matchingImage, obj[i], 1, color, 2);
				circle(matchingImage, scene[i], 1, color, 2);
			}
		}
	}
	else if (drawing_type == POINTS_DeepMatch)
	{
		int img1_p1_x, img1_p2_x, img1_p3_y, img1_p4_y;
		int img2_p1_x, img2_p2_x, img2_p3_y, img2_p4_y;
		int pixel = 6;
		for (size_t i = 0; i<inliersMask.size(); i++){
			if (inliersMask[i])
			{
				img1_p1_x = obj[i].x - pixel < 0 ? 0 : obj[i].x - pixel;
				img1_p2_x = obj[i].x + pixel > img1_size.width - 1 ? img1_size.width - 1 : obj[i].x + pixel;
				img1_p3_y = obj[i].y - pixel < 0 ? 0 : obj[i].y - pixel;
				img1_p4_y = obj[i].y + pixel > img1_size.height - 1 ? img1_size.height - 1 : obj[i].y + pixel;

				line(matchingImage, Point(img1_p1_x, obj[i].y), Point(img1_p2_x, obj[i].y), Scalar(255, 0, 0), 2);
				line(matchingImage, Point(obj[i].x, img1_p3_y), Point(obj[i].x, img1_p4_y), Scalar(255, 0, 0), 2);

				//右图点要进行减去左图宽度操作
				img2_p1_x = scene[i].x - img1_size.width - pixel < 0 ? 0 : scene[i].x - pixel;
				img2_p2_x = scene[i].x - img1_size.width + pixel > img2_size.width - 1 ? img2_size.width - 1 : scene[i].x + pixel;
				img2_p3_y = scene[i].y - pixel < 0 ? 0 : scene[i].y - pixel;
				img2_p4_y = scene[i].y + pixel > img2_size.height - 1 ? img2_size.height - 1 : scene[i].y + pixel;

				line(matchingImage, Point(img2_p1_x, scene[i].y), Point(img2_p2_x, scene[i].y), Scalar(0, 0, 255), 2);
				line(matchingImage, Point(scene[i].x, img2_p3_y), Point(scene[i].x, img2_p4_y), Scalar(0, 0, 255), 2);
			}
		}
	}
	else if (drawing_type == POINTS_DeepMatch_COLOR)
	{
		int img1_p1_x, img1_p2_x, img1_p3_y, img1_p4_y;
		int img2_p1_x, img2_p2_x, img2_p3_y, img2_p4_y;
		int pixel = 6;

		
		//构建颜色矩阵
		cv::Scalar tempVal = cv::mean(retained_matches);
		float x1_mean = tempVal.val[0];
		float y1_mean = tempVal.val[1];

		Mat img1_xy;
		vector<Mat> split_channel;
		vector<Mat> merge_channel(2);
		split(retained_matches, split_channel);
		split_channel[0] -= x1_mean;
		split_channel[1] -= y1_mean;
		merge_channel[0] = split_channel[0];
		merge_channel[1] = split_channel[1];
		merge(merge_channel, img1_xy);
		//Mat img1_xy_Transpose = img1_xy.t();
		float aa = atan2(63.2115365, -211.2886977);
		Mat img_score(img1_xy.size().height, 1, CV_32S, Scalar(0));
		for (size_t k = 0; k < inliersMask.size(); k++){
			double cos = double(img1_xy.at<int>(k, 0));
			double sin = double(img1_xy.at<int>(k, 1));
			int temp = int(128 * atan2(sin, cos) / M_PI);
			//cpp像python一样求余 %
			img_score.at<int>(k, 0) = temp - 256 * floor(temp / 256.00);
		}

		Mat _1_255(256, 1, CV_8UC1, Scalar(0));
		for (int i = 0; i < _1_255.rows; i++)
			_1_255.at<uchar>(i, 0) = i;
		Mat _colormap;
		applyColorMap(_1_255, _colormap, COLORMAP_HSV);
		Scalar color;

		for (size_t i = 0; i<inliersMask.size(); i++){
			if (inliersMask[i])
			{
				const uchar* inData = _colormap.ptr<uchar>(img_score.at<int>(i, 0));
				color = Scalar(inData[0], inData[1], inData[2]);

				img1_p1_x = obj[i].x - pixel < 0 ? 0 : obj[i].x - pixel;
				img1_p2_x = obj[i].x + pixel > img1_size.width - 1 ? img1_size.width - 1 : obj[i].x + pixel;
				img1_p3_y = obj[i].y - pixel < 0 ? 0 : obj[i].y - pixel;
				img1_p4_y = obj[i].y + pixel > img1_size.height - 1 ? img1_size.height - 1 : obj[i].y + pixel;

				line(matchingImage, Point(img1_p1_x, obj[i].y), Point(img1_p2_x, obj[i].y), color, 2);
				line(matchingImage, Point(obj[i].x, img1_p3_y), Point(obj[i].x, img1_p4_y), color, 2);

				//右图点要进行减去左图宽度操作
				img2_p1_x = scene[i].x - img1_size.width - pixel < 0 ? 0 : scene[i].x - pixel;
				img2_p2_x = scene[i].x - img1_size.width + pixel > img2_size.width - 1 ? img2_size.width - 1 : scene[i].x + pixel;
				img2_p3_y = scene[i].y - pixel < 0 ? 0 : scene[i].y - pixel;
				img2_p4_y = scene[i].y + pixel > img2_size.height - 1 ? img2_size.height - 1 : scene[i].y + pixel;

				line(matchingImage, Point(img2_p1_x, scene[i].y), Point(img2_p2_x, scene[i].y), color, 2);
				line(matchingImage, Point(scene[i].x, img2_p3_y), Point(scene[i].x, img2_p4_y), color, 2);
			}
		}
	}
	return matchingImage;
}

//int main()
//{
//	Mat imgLeft = imread("img1.ppm");
//	Mat imgRight = imread("img3.ppm");
//
//	int maxHeight = max(imgLeft.size().height, imgRight.size().height);
//	Size sz = Size(imgLeft.size().width + imgRight.size().width, maxHeight);
//	Mat matchingImage = Mat::zeros(sz, CV_8UC3);
//	// 设置matchingImage的感兴趣区域大小并赋予原图
//	Mat roi1 = Mat(matchingImage, Rect(0, 0, imgLeft.size().width, imgLeft.size().height));
//	imgLeft.copyTo(roi1);
//	Mat roi2 = Mat(matchingImage, Rect(imgLeft.size().width, 0, imgRight.size().width, imgRight.size().height));
//	imgRight.copyTo(roi2);
//
//	std::ifstream fout;
//	fout.open("./opencv_coord_matchPoint.txt", std::fstream::out | std::fstream::in);
//	if (!fout)
//	{
//		std::cerr << "error:========" << "File Not Opened" << std::endl;
//		return -1;
//	}
//	//设置精度  小数点后两位
//	//fout.setf(ios::fixed, ios::floatfield);
//	//fout.precision(2);
//	string sline;//每一行
//	string out;
//	string x1, y1, x2, y2;
//	int i_x1, i_y1, i_x2, i_y2;
//	std::vector<Point2f>obj;
//	std::vector<Point2f>scene;
//	while (getline(fout, sline))
//	{
//		istringstream sin(sline);
//		sin >> x1 >> y1 >> x2 >> y2;
//		//cout << x1 << " " << y1 << " " << x2 << " " << y2 << " " << "\n";
//		i_x1 = std::stoi(x1);
//		i_y1 = std::stoi(y1);
//		i_x2 = std::stoi(x2);
//		i_y2 = std::stoi(y2);
//
//		obj.push_back(Point(i_x1 - 1, i_y1 - 1));
//		scene.push_back(Point(imgLeft.size().width + i_x2 - 1, i_y2 - 1));
//	}
//
//	Mat retained_matches(obj.size(), 1, CV_32SC4, Scalar(0, 0, 0, 0));
//	for (size_t p = 0; p < obj.size(); ++p)
//	{
//		retained_matches.at<Vec4i>(p, 0)[0] = obj[p].x;
//		retained_matches.at<Vec4i>(p, 0)[1] = obj[p].y;
//		retained_matches.at<Vec4i>(p, 0)[2] = scene[p].x - imgLeft.size().width;
//		retained_matches.at<Vec4i>(p, 0)[3] = scene[p].y;
//	}
//
//
//	vector<uchar>inliersMask(obj.size());
//	Mat H = findHomography(scene, obj, CV_FM_RANSAC, 1, inliersMask);
//	MyEnum drawing_type = POINTS_DeepMatch_COLOR;
//	Mat result = draw_matches(matchingImage, inliersMask, drawing_type, obj, scene, retained_matches, imgLeft.size(), imgRight.size());
//	Mat showImg;
//	resize(result, showImg, Size(matchingImage.cols / 2, matchingImage.rows / 2), 0, 0, INTER_LINEAR);
//	imshow("draw_matchPoint", showImg);
//	waitKey();
//	return 0;
//}

int main()
{
	Mat imgLeft = imread("img1.ppm");
	Mat imgRight = imread("img2.ppm");

	vector<KeyPoint> keyPoint1;
	ORB orb(500000);
	orb.detect(imgLeft, keyPoint1);
	Mat descriImage1;
	orb.compute(imgLeft, keyPoint1, descriImage1);
	vector<KeyPoint> keyPoints2;
	orb.detect(imgRight, keyPoints2);
	Mat descriImage2;
	orb.compute(imgRight, keyPoints2, descriImage2);
	vector<DMatch> matches;
	Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("BruteForce-Hamming");
	matcher->match(descriImage1, descriImage2, matches);

	int maxHeight = max(imgLeft.size().height, imgRight.size().height);
	Size sz = Size(imgLeft.size().width + imgRight.size().width, maxHeight);
	Mat matchingImage = Mat::zeros(sz, CV_8UC3);
	// 设置matchingImage的感兴趣区域大小并赋予原图
	Mat roi1 = Mat(matchingImage, Rect(0, 0, imgLeft.size().width, imgLeft.size().height));
	imgLeft.copyTo(roi1);
	Mat roi2 = Mat(matchingImage, Rect(imgLeft.size().width, 0, imgRight.size().width, imgRight.size().height));
	imgRight.copyTo(roi2);

	double max_dist = 0; double min_dist = 100;
	for (int i = 0; i < descriImage1.rows; i++)
	{
		double dist = matches[i].distance;
		if (dist < min_dist) min_dist = dist;
		if (dist > max_dist) max_dist = dist;
	}
	std::vector< DMatch > good_matches;
	for (int i = 0; i < descriImage1.rows; i++)
	{
		if (matches[i].distance < 0.9*max_dist)
		{
			good_matches.push_back(matches[i]);
		}
	}
	std::vector<Point2f>obj;
	std::vector<Point2f>scene;
	Mat retained_matches(good_matches.size(), 1, CV_32SC4, Scalar(0, 0, 0, 0));
	int x1 = 0, y1 = 0, x2 = 0, y2 = 0;
	for (size_t i = 0; i < good_matches.size(); ++i)
	{
		x2 = keyPoints2[good_matches[i].trainIdx].pt.x + imgLeft.size().width;
		y2 = keyPoints2[good_matches[i].trainIdx].pt.y;
		obj.push_back(keyPoint1[good_matches[i].queryIdx].pt);
		scene.push_back(cv::Point(x2, y2));
		retained_matches.at<Vec4i>(i, 0)[0] = keyPoint1[good_matches[i].queryIdx].pt.x;
		retained_matches.at<Vec4i>(i, 0)[1] = keyPoint1[good_matches[i].queryIdx].pt.y;
		retained_matches.at<Vec4i>(i, 0)[2] = x2;
		retained_matches.at<Vec4i>(i, 0)[3] = y2;
	}

	vector<uchar>inliersMask(obj.size());
	Mat H = findHomography(scene, obj, CV_FM_RANSAC, 3, inliersMask);
	MyEnum drawing_type = POINTS_DeepMatch_COLOR;
	Mat result = draw_matches(matchingImage, inliersMask, drawing_type, obj, scene, retained_matches, imgLeft.size(), imgRight.size());
	Mat showImg;
	resize(result, showImg, Size(matchingImage.cols / 2, matchingImage.rows / 2), 0, 0, INTER_LINEAR);
	imshow("draw_matchPoint", showImg);
	waitKey();
	return 0;
}


知识在于分享
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于边界的模板匹配的原理及算法实现 C++
02-15
实现边缘检测、匹配得分计算、阈值处理和结果可视化 } int main() { // 加载大图和模板图像 cv::Mat image = cv::imread("large_image.jpg"); cv::Mat templateImage = cv::imread("template.jpg"); // 边界...
GLMViz：高帧率，完全可配置的OpenGL音乐可视化程序
02-04
1. **源代码文件**：这些文件（如`.cpp`和`.h`）包含了GLMViz的实现细节，展示了如何使用OpenGL进行音乐可视化。 2. **资源文件**：可能包括颜色方案、纹理、字体等，用于自定义可视化效果。 3. **构建脚本**：帮助...
opencv Mat与Vector、Mat与数组、Vector与数组之间互转 详解
qq_27278957的博客
12-15 9540
1、Mat与vector互转 reshape()函数返回的Mat，即是修改通道、行、列后的矩阵，是原矩阵，并没有进行矩阵的拷贝操作，这个在官方文档中介绍到了。 #include <opencv2/opencv.hpp> using namespace cv; using namespace std; /***************** Mat转vector ******...
【OpenCV】c++实现 图像矩阵与数组的相互转化
立志如山，行道如水
02-22 9769
图像矩阵在内存中的存储方式 灰度图 灰度图一个像素由一个字节组成，即单通道 RGB图 RGB图像的一个像素由以B，G，R顺序的三个字节组成，即三通道 代码实现 图片–>二维数组 //传入图片地址，输出二维vector vector<vector<uchar> > decode(char* path) //path为图片路径 { Mat img ...
C++ vector学习
weixin_44126988的博客
06-19 295
c++vector中基本函数学习
纯C语言 不用 OpenCV 开源库 实现ORB特征提取及匹配 可视化
Morty 的挖坑记录
03-29 3029
参考：画直线https://blog.csdn.net/Bluechalk/article/details/84578197 C语言图像读取及基本操作https://blog.csdn.net/zhangquan2015/article/details/80160864 ORB特征https://blog.csdn.net/qq_32998593/article/details/7922...
ORB-SLAM2系列第五章—— 特征匹配
weixin_45947476的博客
04-06 5477
系列文章目录 ORB-SLAM2系列第一章——简介 ORB-SLAM2系列第二章——ORB 特征点提取 ORB-SLAM2系列第三章—— 地图初始化 ORB-SLAM2系列第四章—— 地图点、关键帧、图结构 文章目录系列文章目录前言一、单目初始化中的特征匹配二、通过视觉词袋进行特征匹配1.直观理解词袋2.为什么要研究BoW？3.如何制作、生成BoW？总结 前言 迎浏览我的SLAM专栏，包括slam安装运行、代码注释、原理详解，一起加油淦穿SLAM。 一、单目初始化中的特征匹配 初始化搜索匹配，对应函数
MFC+Opencv2.4.3实现简单的模板匹配
06-04
5. **绘制匹配结果**：在原始图像上，可以使用`rectangle()`函数画出匹配区域，以便于可视化。 **5. MFC集成OpenCV** 在MFC项目中集成OpenCV，需要设置项目的链接器依赖项，添加OpenCV库，并确保头文件路径正确。...
OpenCV实现ORB算法描述与匹配（C++实现）.zip
04-12
接着，使用BFMatcher进行匹配，并可视化匹配结果。在这个过程中，可以调整ORB的参数和BFMatcher的匹配策略以优化结果。 在实际应用中，ORB算法常被用于图像检索、目标识别、SLAM（Simultaneous Localization And ...
SIFT特征提取代码实现
04-05
最后，我们可视化关键点并在窗口中显示结果。 在实际应用中，SIFT特征提取通常与其他算法结合使用，如RANSAC（随机样本一致性）用于去除匹配过程中的错误匹配，提高匹配的准确性。此外，SIFT特征也可以与BoW（Bag-...
图像特征的匹配－OpenCV3.0
热门推荐
机器会学习的博客
03-26 1万+
图像特征的匹配 　　通过对图像提取特征后，得到特征点和描述特征点信息的特征向量，在对图像的检索和匹配当中主要通过对描述符［特征向量］的计算来实现，下面主要通过ORB来进行图像特征的提取，使用不同的算法来实现图像的匹配． １．暴力匹配(Brute-Force) ２．K-临近匹配 ３．FLANN匹配(Fast Library for Approximate Nearest Neighbors)...
c++常用格式转换和常用函数
Happinessคิดถึง的博客
08-25 542
** 更新时间：2020-08-25 ** vector 互转 stringstream vector 转 stringstream vector<unsigned char> buf_jpg; stringstream picliu; //oss内存图片数据流 //图片输入到流,内存方式上传 for (int i = 0; i < buf_jpg.size(); i++) { picliu << buf_jpg[i]; } stringstream 转
视觉里程计1（slam十四讲ch7）——特征点，特征匹配
赤豆几维
08-31 5149
Brook_icv 转载于 https://www.cnblogs.com/wangguchangqing/p/8076061.html  slamcn.org：高翔和他的朋友们做的一个系统介绍slam的网站 大牛讲堂｜SLAM最终话：视觉里程计 1.概念：什么是里程计？ 　　在里程计问题中，我们希望测量一个运动物体的轨迹。这可以通过许多不同的手段来实现。例如，我们在汽车轮胎上安装计数...
【图像处理】可视化HSV色彩空间阈值编辑器
luoyir1997的博客
10-19 8720
# -*- coding:utf-8 -*- import cv2 import numpy as np """ 功能：读取一张图片，显示出来，转化为HSV色彩空间 并通过滑块调节HSV阈值，实时显示 """ image = cv2.imread('1.jpg') # 根据路径读取一张图片 cv2.imshow("BGR", image) # 显示图片 hsv_low = np.array([0, 0, 0]) hsv_high = np.array([0, 0, 0]) # 下面几个.
Opencv 基本操作四 指针数组、vector与Mat之间的相互转换 | Mat切片成Vector＜mat＞并还原
a486259的博客
09-14 9967
在深度学习模型部署中通常存在读取图像为mat，然后将mat转换为float指针传入模型的操作。为了快捷开发，因此对指针数组、vector与Mat之间的相互转换进行整理。实现了指针数组、vector之间的相互转换；vector与Mat之间的相互转换（含单通道图像和多通道图像）。vector转mat主要应用在语义分割结果的处理中。
OpenCV的特征提取和匹配
weixin_39821439的博客
07-07 1552
。
c++学习【7】光流法
m0_46973820的博客
06-12 521
如果一行中的单词数目不符合预期，或者某个单词中包含空格、制表符等空白字符，就会导致读取出错。是C++标准库中的一个输入流类，它可以将字符串作为输入流进行处理。当使用istringstream对象的输入流运算符>>来解析字符串时，默认情况下它会以空格为分隔符。在C++中，通常用于表示输入文件流对象，用于从文件中读取数据。我们可以这样使用，从标准输入流中读取三个整型数值，并分别存储到变量x、y、z中。对象，它被用来打开和读取associate.txt文件。将字符串解析为整型数值，并将其存储在变量x、y、z中。
c++学习【4】提取特征
m0_46973820的博客
06-05 430
KeyPoint 是 OpenCV 中用于表示图像中关键点的结构体，包含关键点的坐标、响应值、方向等属性。Ptr 是一个智能指针类，可以指向任何 OpenCV 中的对象，并自动管理其内存。使用 Ptr 类型的智能指针，可以避免手动释放内存的繁琐操作，提高代码的可读性和可维护性。在C++中，Ptr是OpenCV库中的一个智能指针类（smart pointer），用于管理动态分配的对象。
c++顺序表类模板及其可视化界面
最新发布
chen666946的博客
07-01 910
顺序表适用于对访问频繁、插入和删除操作较少的场景，例如按位置随机查找元素的需求较多的情况。然而，如果需要频繁进行插入和删除操作，顺序表的性能可能较差，需要考虑使用其他数据结构，如链表。在顺序表中，元素的插入、删除和访问操作相对简单高效。通过使用数组或固定大小的内存块，顺序表可以实现随机访问，即通过下标直接访问任意位置的元素，时间复杂度为O(1)。插入和删除效率低：在顺序表中插入或删除元素时，需要移动其他元素来保持顺序表的连续性。连续存储：顺序表使用连续的存储空间，元素在内存中的存储位置是相邻的。
PCL实现对布尔描述子特征匹配并将匹配结果可视化
05-28
// 可视化匹配结果 PCLVisualizer viewer; viewer.addPointCloud(cloud1, "cloud1"); viewer.addPointCloud(cloud2, "cloud2"); for (size_t i = 0; i < correspondences->size(); ++i) { PointT p1 = cloud1-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值