5基于块的反向投影（cvCalcArrBackProjectPatch）

最新推荐文章于 2022-11-01 16:09:39 发布
最新推荐文章于 2022-11-01 16:09:39 发布
阅读量309 收藏 1
点赞数
分类专栏： open cv 文章标签： 块反向映射

基于块的反向投影

根据输入的图像计算色相饱和度（hue-saturation）直方图，以网格形式显示，利用颜色模板直方图进行基于块的反向投影，在测试图像中找出该颜色模板直方图对应的区域，程序中，对于手的检测cvCalcArrBackProjectPatch()做区域检测器，对于杯子的检测cvCalcArrBackProjectPatch()做目标检测器，对应具体代码如下：

#include <cv.h>
#include <highgui.h>  
#include <stdlib.h>  
#include <stdio.h> 
#include <math.h>

using namespace std;

int main(int argc, char* argv[])
{
    //源图像 HSV格式图像
    IplImage* Ihand_model, *Ihand_test, *Ihand_mask, *hsv1, *hsv2, *hsv3, *hsv4, *Icup_model, *Icup_test, *Icup_mask;   

    //未处理的肤色模板图像
    if (!(Ihand_model = cvLoadImage("D:\\Template\\OpenCV\\Template49_hue-saturation_BackProjection_Patch\\Debug\\hand1.jpg")))
        return -1;
    //寻找手掌反向投影的测试图像
    if (!(Ihand_test = cvLoadImage("D:\\Template\\OpenCV\\Template49_hue-saturation_BackProjection_Patch\\Debug\\hand3.jpg")))
        return -2;
    //用于处理肤色模板图像的掩码，此处调入图像掩码应为单通道
    if (!(Ihand_mask = cvLoadImage("D:\\Template\\OpenCV\\Template49_hue-saturation_BackProjection_Patch\\Debug\\Imask.jpg",
        CV_LOAD_IMAGE_GRAYSCALE)))
        return -3;
    //未处理的杯子颜色模板图像
    if (!(Icup_model = cvLoadImage("D:\\Template\\OpenCV\\Template49_hue-saturation_BackProjection_Patch\\Debug\\cup2.jpg")))
        return -4;
    //寻找杯子反向投影的测试图像
    if (!(Icup_test = cvLoadImage("D:\\Template\\OpenCV\\Template49_hue-saturation_BackProjection_Patch\\Debug\\cup1.jpg")))
        return -5;
    //用于处理杯子颜色模板图像的掩码 可获取杯子反向投影块大小
    if (!(Icup_mask = cvLoadImage("D:\\Template\\OpenCV\\Template49_hue-saturation_BackProjection_Patch\\Debug\\cup3.jpg",
        CV_LOAD_IMAGE_GRAYSCALE)))
        return -6;

    int hand_patch_width = 5;                       //手掌反向投影块宽度
    int hand_patch_height = 5;                      //手掌反向投影块高度

    int cup_patch_width = Icup_model->width;        //杯子反向投影块宽度
    int cup_patch_height = Icup_model->height;      //杯子反向投影块高度

    cvXorS(Ihand_mask, cvScalar(255), Ihand_mask);          //掩码图像按位异或，求反，以手掌以外区域作为掩码
    cvXorS(Icup_mask, cvScalar(255), Icup_mask);            //掩码图像按位异或，求反，以杯子以外区域作为掩码

    cvSet(Ihand_model, cvScalarAll(0), Ihand_mask);         //将手掌以外区域变黑，生成肤色模板图像
    cvSet(Icup_model, cvScalarAll(0), Icup_mask);           //将手掌以外区域变黑，生成肤色模板图像

    hsv1 = cvCreateImage(cvGetSize(Ihand_model), Ihand_model->depth, Ihand_model->nChannels);   //HSV
    hsv2 = cvCreateImage(cvGetSize(Ihand_test), Ihand_test->depth, Ihand_test->nChannels);      //HSV
    hsv3 = cvCreateImage(cvGetSize(Icup_model), Icup_model->depth, Icup_model->nChannels);      //HSV
    hsv4 = cvCreateImage(cvGetSize(Icup_test), Icup_test->depth, Icup_test->nChannels);         //HSV

    cvCvtColor(Ihand_model, hsv1, CV_BGR2HSV);      //源图像->HSV格式图像
    cvCvtColor(Ihand_test, hsv2, CV_BGR2HSV);       //源图像->HSV格式图像
    cvCvtColor(Icup_model, hsv3, CV_BGR2HSV);       //源图像->HSV格式图像
    cvCvtColor(Icup_test, hsv4, CV_BGR2HSV);        //源图像->HSV格式图像

    //反向投影图像 大小:测试图像-块的大小 浮点型数组
    IplImage *Iback_projection_patch_hand = cvCreateImage(
        cvSize(Ihand_test->width - hand_patch_width + 1, Ihand_test->height - hand_patch_height + 1), 
        IPL_DEPTH_32F, 1);
    IplImage *Iback_projection_patch_cup = cvCreateImage(
        cvSize(Icup_test->width - cup_patch_width + 1, Icup_test->height - cup_patch_height + 1),
        IPL_DEPTH_32F, 1);

    //色调(hue) 饱和度(saturation) 明度(value) 创建三通道图像
    IplImage *h_plane_1 = cvCreateImage(cvSize(hsv1->width, hsv1->height), IPL_DEPTH_8U, 1);
    IplImage *s_plane_1 = cvCreateImage(cvSize(hsv1->width, hsv1->height), IPL_DEPTH_8U, 1);
    IplImage *v_plane_1 = cvCreateImage(cvSize(hsv1->width, hsv1->height), IPL_DEPTH_8U, 1);

    IplImage *h_plane_2 = cvCreateImage(cvSize(hsv2->width, hsv2->height), IPL_DEPTH_8U, 1);
    IplImage *s_plane_2 = cvCreateImage(cvSize(hsv2->width, hsv2->height), IPL_DEPTH_8U, 1);
    IplImage *v_plane_2 = cvCreateImage(cvSize(hsv2->width, hsv2->height), IPL_DEPTH_8U, 1);

    IplImage *h_plane_3 = cvCreateImage(cvSize(hsv3->width, hsv3->height), IPL_DEPTH_8U, 1);
    IplImage *s_plane_3 = cvCreateImage(cvSize(hsv3->width, hsv3->height), IPL_DEPTH_8U, 1);
    IplImage *v_plane_3 = cvCreateImage(cvSize(hsv3->width, hsv3->height), IPL_DEPTH_8U, 1);

    IplImage *h_plane_4 = cvCreateImage(cvSize(hsv4->width, hsv4->height), IPL_DEPTH_8U, 1);
    IplImage *s_plane_4 = cvCreateImage(cvSize(hsv4->width, hsv4->height), IPL_DEPTH_8U, 1);
    IplImage *v_plane_4 = cvCreateImage(cvSize(hsv4->width, hsv4->height), IPL_DEPTH_8U, 1);

    IplImage *planes1[] = { h_plane_1, s_plane_1 };                     //色相饱和度数组
    IplImage *planes2[] = { h_plane_2, s_plane_2 };                     //色相饱和度数组
    IplImage *planes3[] = { h_plane_3, s_plane_3 };                     //色相饱和度数组
    IplImage *planes4[] = { h_plane_4, s_plane_4 };                     //色相饱和度数组

    cvCvtPixToPlane(hsv1, h_plane_1, s_plane_1, v_plane_1, NULL);       //图像分割
    cvCvtPixToPlane(hsv2, h_plane_2, s_plane_2, v_plane_2, NULL);       //图像分割
    cvCvtPixToPlane(hsv3, h_plane_3, s_plane_3, v_plane_3, NULL);
    cvCvtPixToPlane(hsv4, h_plane_4, s_plane_4, v_plane_4, NULL);
    //cvSplit(hsv4, h_plane_4, s_plane_4, v_plane_4, NULL);             //两函数效果相似

    int h_bins = 30, s_bins = 32;               //h维bins的个数，s维bins的个数               

    //建立模板和测试直方图
    CvHistogram *hist_model_hand, *hist_test_hand, *hist_model_cup, *hist_test_cup;

    int hist_size[] = { h_bins, s_bins };       //对应维数包含bins个数的数组
    float h_ranges[] = { 0, 180 };              //H通道划分范围 饱和度0-180
    float s_ranges[] = { 0, 255 };              //S通道划分范围
    float* ranges[] = { h_ranges, s_ranges };   //划分范围数对, ****均匀bin，range只要最大最小边界

    //创建直方图 （维数，对应维数bins个数，密集矩阵方式存储，划分范围数对，均匀直方图）
    hist_model_hand = cvCreateHist(2, hist_size, CV_HIST_ARRAY, ranges, 1);
    hist_test_hand = cvCreateHist(2, hist_size, CV_HIST_ARRAY, ranges, 1);
    hist_model_cup= cvCreateHist(2, hist_size, CV_HIST_ARRAY, ranges, 1);
    hist_test_cup = cvCreateHist(2, hist_size, CV_HIST_ARRAY, ranges, 1);
    //计算直方图
    cvCalcHist(planes1, hist_model_hand, 0, 0);     //计算直方图（图像，直方图结构，不累加，掩码）肤色直方图
    cvCalcHist(planes2, hist_test_hand, 0, 0);      //计算直方图（图像，直方图结构，不累加，掩码）测试直方图
    cvCalcHist(planes3, hist_model_cup, 0, 0);      //计算直方图（图像，直方图结构，不累加，掩码）杯色直方图
    cvCalcHist(planes4, hist_test_cup, 0, 0);       //计算直方图（图像，直方图结构，不累加，掩码）测试直方图
    //直方图归一化
    cvNormalizeHist(hist_model_hand, 1.0);          //直方图归一化
    cvNormalizeHist(hist_test_hand, 1.0);           //直方图归一化
    cvNormalizeHist(hist_model_cup, 1.0);           //直方图归一化
    cvNormalizeHist(hist_test_cup, 1.0);            //直方图归一化

    //绘制可视化直方图
    int scale = 10;     //直方图颜色值图像显示倍数
    IplImage* Ihist_model_hand = cvCreateImage(cvSize(h_bins*scale, s_bins*scale), 8, 3);   //300*320
    IplImage* Ihist_test_hand = cvCreateImage(cvSize(h_bins*scale, s_bins*scale), 8, 3);    //300*320
    IplImage* Ihist_model_cup = cvCreateImage(cvSize(h_bins*scale, s_bins*scale), 8, 3);    //300*320
    IplImage* Ihist_test_cup = cvCreateImage(cvSize(h_bins*scale, s_bins*scale), 8, 3);     //300*320

    //直方图颜色值图像清零
    cvZero(Ihist_model_hand);
    cvZero(Ihist_test_hand);
    cvZero(Ihist_model_cup);
    cvZero(Ihist_test_cup);

    //以小灰度块填充图像
    float max_value_model_hand = 0; //直方图中最大值，为映射做准备
    float max_value_test_hand = 0;
    float max_value_model_cup = 0;  //直方图中最大值，为映射做准备
    float max_value_test_cup = 0;

    cvGetMinMaxHistValue(hist_model_hand, NULL, &max_value_model_hand, NULL, NULL); //直方图最大值
    cvGetMinMaxHistValue(hist_test_hand, NULL, &max_value_test_hand, NULL, NULL);   //直方图最大值
    cvGetMinMaxHistValue(hist_model_cup, NULL, &max_value_model_cup, NULL, NULL);   //直方图最大值
    cvGetMinMaxHistValue(hist_test_cup, NULL, &max_value_test_cup, NULL, NULL);     //直方图最大值

    for (int h = 0; h < h_bins; h++)
    {
        for (int s = 0; s < s_bins; s++)
        {
            float bin_val_model_hand = cvQueryHistValue_2D(hist_model_hand, h, s);  //bin中的浮点数
            float bin_val_test_hand = cvQueryHistValue_2D(hist_test_hand, h, s);    //bin中的浮点数
            float bin_val_model_cup = cvQueryHistValue_2D(hist_model_cup, h, s);    //bin中的浮点数
            float bin_val_test_cup = cvQueryHistValue_2D(hist_test_cup, h, s);      //bin中的浮点数

            int intensity1 = cvRound(bin_val_model_hand * 255 / max_value_model_hand);  //映射到255空间
            int intensity2 = cvRound(bin_val_test_hand * 255 / max_value_test_hand);    //归一后太小
            int intensity3 = cvRound(bin_val_model_cup * 255 / max_value_model_cup);    //映射到255空间
            int intensity4 = cvRound(bin_val_test_cup * 255 / max_value_test_cup);      //归一后太小

            cvRectangle(Ihist_model_hand, cvPoint(h*scale, s*scale),            //绘制小灰度块填充图像
                cvPoint((h + 1)*scale - 1, (s + 1)*scale - 1),
                CV_RGB(intensity1, intensity1, intensity1), CV_FILLED);
            cvRectangle(Ihist_test_hand, cvPoint(h*scale, s*scale),
                cvPoint((h + 1)*scale - 1, (s + 1)*scale - 1),
                CV_RGB(intensity2, intensity2, intensity2), CV_FILLED);
            cvRectangle(Ihist_model_cup, cvPoint(h*scale, s*scale),         //绘制小灰度块填充图像
                cvPoint((h + 1)*scale - 1, (s + 1)*scale - 1),
                CV_RGB(intensity3, intensity3, intensity3), CV_FILLED);
            cvRectangle(Ihist_test_cup, cvPoint(h*scale, s*scale),
                cvPoint((h + 1)*scale - 1, (s + 1)*scale - 1),
                CV_RGB(intensity4, intensity4, intensity4), CV_FILLED);
        }
    }

    CvSize hand_patch_size = cvSize(hand_patch_width, hand_patch_height);   //手掌反向投影块尺寸
    CvSize cup_patch_size = cvSize(cup_patch_width, cup_patch_height);      //杯子反向投影块尺寸

    //做区域检测器 采样窗口小于目标 测试图像数组 块的反向投影图像 块大小 模板直方图 比较方式（相关） 归一化水平
    cvCalcArrBackProjectPatch((CvArr **)planes2, Iback_projection_patch_hand, hand_patch_size, hist_model_hand, CV_COMP_CORREL, 1);
    //做目标检测器 采样窗口等于目标 测试图像数组 块的反向投影图像 块大小 模板直方图 比较方式（相关） 归一化水平
    cvCalcArrBackProjectPatch((CvArr **)planes4, Iback_projection_patch_cup, cup_patch_size, hist_model_cup, CV_COMP_CORREL, 1);

    cvNamedWindow("Mask_Hand", 1);
    cvNamedWindow("Model_Hand", 1);
    cvNamedWindow("Test_Hand", 1);
    cvNamedWindow("HIST_Model_Hand", 1);
    cvNamedWindow("HIST_Test_Hand", 1);
    cvNamedWindow("BACK_Projection_Hand", 1);

    cvNamedWindow("Mask_Cup", 1);
    cvNamedWindow("Model_Cup", 1);
    cvNamedWindow("Test_Cup", 1);
    cvNamedWindow("HIST_Model_Cup", 1);
    cvNamedWindow("HIST_Test_Cup", 1);
    cvNamedWindow("BACK_Projection_Cup", 1);

    cvShowImage("Mask_Hand", Ihand_mask);
    cvShowImage("Model_Hand", Ihand_model);
    cvShowImage("Test_Hand", Ihand_test);
    cvShowImage("HIST_Model_Hand", Ihist_model_hand);
    cvShowImage("HIST_Test_Hand", Ihist_test_hand);
    cvShowImage("BACK_Projection_Hand", Iback_projection_patch_hand);

    cvShowImage("Mask_Cup", Icup_mask);
    cvShowImage("Model_Cup", Icup_model);
    cvShowImage("Test_Cup", Icup_test);
    cvShowImage("HIST_Model_Cup", Ihist_model_cup);
    cvShowImage("HIST_Test_Cup", Ihist_test_cup);
    cvShowImage("BACK_Projection_Cup", Iback_projection_patch_cup);

    cvWaitKey(0);
    //system("pause");

    cvReleaseHist(&hist_model_hand);
    cvReleaseHist(&hist_test_hand);
    cvReleaseHist(&hist_model_cup);
    cvReleaseHist(&hist_test_cup);

    cvReleaseImage(&Ihand_model);
    cvReleaseImage(&Ihand_test);
    cvReleaseImage(&Ihand_mask);
    cvReleaseImage(&hsv1);
    cvReleaseImage(&hsv2);
    cvReleaseImage(&hsv3);
    cvReleaseImage(&hsv4);  
    cvReleaseImage(&Icup_model);
    cvReleaseImage(&Icup_test);
    cvReleaseImage(&Icup_mask);
    cvReleaseImage(&h_plane_1);
    cvReleaseImage(&s_plane_1);
    cvReleaseImage(&v_plane_1);
    cvReleaseImage(&h_plane_2);
    cvReleaseImage(&s_plane_2);
    cvReleaseImage(&v_plane_2);
    cvReleaseImage(&h_plane_3);
    cvReleaseImage(&s_plane_3);
    cvReleaseImage(&v_plane_3);
    cvReleaseImage(&h_plane_4);
    cvReleaseImage(&s_plane_4);
    cvReleaseImage(&v_plane_4);
    cvReleaseImage(&Ihist_model_hand);
    cvReleaseImage(&Ihist_test_hand);
    cvReleaseImage(&Ihist_model_cup);
    cvReleaseImage(&Ihist_test_cup);
    cvReleaseImage(&Iback_projection_patch_hand);
    cvReleaseImage(&Iback_projection_patch_cup);

    cvDestroyAllWindows();
}

这里写图片描述

alpha_Escher
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
opencv学习(三十九)之反向投影calcBackProject()
烟雨博客
04-13 2万+
1.概述反向投影是一种记录给定图像中的像素点如何适应直方图模型像素分布的方式，简单来讲，反向投影就是首先计算某一特征的直方图模型，然后使用模型去寻找图像中存在的特征。反向投影在某一位置的值就是原图对应位置像素值在原图像中的总数目。2.反向投影原理原理采用OpenCV docs介绍！使用肤色直方图来解释反向投影的工作原理。假设我们已经获得一个肤色直方图(Hue-Staturation),旁边的直方图就
opencv中直方图的反向投影详解
04-02
本程序详细解释了直方图反响投影后的图片和以前图片的对比 比给出直方图和图像对比
【opencv学习笔记 14 直方图的反向投影】calcBackProject()函数的使用
12-21
直方图的反向投影 """ 直方图的反向投影 我的理解就是给一个sample 然后获取它的图像直方图 然后使用这个直方图在target里面寻找相似的特征 """ import cv2 as cv from matplotlib import pyplot as plt def back_projection_demo(): # 读取图片 sample = cv.imread("imgsample.jpg") target = cv.imread("img.jpg") # 转换为HSV格式 roi_hsv = cv.cvtColor(sample, cv.C
Pixel-level Extrinsic Self Calibration of High Resolution LiDAR and Camera in Targetless Environment
weixin_45626706的博客
11-01 794
目录Pixel-level Extrinsic Self Calibration of High Resolution LiDAR and Camera in Targetless EnvironmentsAbstract1.Introduction2.Related Works3.MethodA. OverviewB. Edge Extraction and Matching1) Edge Extraction:2) Matching:C. Extrinsic Calibration1) Measurem
【自动驾驶】【零基础】基础自动驾驶控制算法笔记
m0_62664599的博客
09-13 5947
111
opengl入门
jia_zhengshen的专栏
07-11 6283
十分感谢原作者的无私奉献。                         OpenGL入门教程 1.第一课： 说起编程作图，大概还有很多人想起TC的#include 吧？ 但是各位是否想过，那些画面绚丽的PC游戏是如何编写出来的？就靠TC那可怜的640*480分辨率、16色来做吗？显然是不行的。 本帖的目的是让大家放弃TC的老旧图形接口，让大家接触一些新事物。 OpenGL
直方图匹配-Opencv种cvCalcBackProject的理解
热门推荐
SevenColorFish的专栏
10-02 1万+
转自：http://blog.163.com/chenliangren@126/blog/static/168305659201071711434658/ 示例可看本博客：http://blog.163.com/chenliangren@126/blog/static/1683
python+OpenCV笔记（二十七）：反投影图像
ReadyGo!!!的博客
01-27 2345
python+OpenCV笔记（二十七）：反投影图像
opencv学习笔记（三十一）基于块的反向投影
u014751607的博客
03-07 880
参考了这篇文章 http://blog.csdn.net/fdl19881/article/details/6726438 检测原理： 书上说的很麻烦，按照博主的理解就很简单： cvCalcBackProjectPatch的大概意义 ，按我的理解的话，应该是通过块窗口搜索图像，比较窗口中对应像素的二维直方图与给定直方图的差异，若完全相同，那当然就越匹配。 对于不同的相关度方法，越匹
opencv 反向投影 cvCalcBackProject的示例 ,用图像中某中颜色的区域
08-27 7756
在学习 《学习opencv》的cvCalcBackProject时自己写的例子 #include #include #include #include #include using namespace std; int main() { IplImage *s
基于反向投影的手部分割
07-08
本实例代码主要是基于Opencv开发的，其使用的语言为C++。其主要实现了基于肤色的手部分割，实现较为简单，项目中包含了测试程序以及测试图片，可以直接运行。
opencv3/C++ 直方图反向投影实例
08-25
今天小编就为大家分享一篇opencv3/C++ 直方图反向投影实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
基于反向投影的手部分割---增强版
07-08
本项目是一个基于Opencv实现的手部分割，其实现的主要原理便是利用“漫水填充”、“反向投影”等方式来实现手部的分割。
论文研究-基于反向投影的zero-shotlearning目标分类算法研究.pdf
07-22
提出基于反向投影的ZSL目标分类方法，将类别原型投影到视觉空间，利用视觉特征的语义性学习出映射函数，参数优化过程仅通过解析解就可以获得。在两个基准数据集的实验结果表明，提出的反向投影方法分类结果较传统...
Python OpenCV处理图像之图像直方图和反向投影
09-20
主要为大家详细介绍了Python OpenCV处理图像之图像直方图和反向投影，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
大学物理册答案上下都有
最新发布
04-26
大学物理册答案上下都有
UWB超宽带信道研究及源码.zip
04-26
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
Suno AI语音技术的资源描述
04-26
Suno AI 是一家领先的人工智能（AI）公司，专注于开发创新的语音技术和解决方案。以下是关于 Suno AI 的资源描述： 语音识别技术：Suno AI 拥有先进的语音识别技术，能够准确地将语音转换为文本。他们的语音识别系统经过了大量的训练和优化，具有高度的准确性和鲁棒性，可应用于多种场景，如语音助手、语音搜索、智能客服等。 语音合成技术：除了语音识别，Suno AI 还致力于开发自然、流畅的语音合成技术。他们的语音合成系统能够生成高质量、逼真的语音输出，可以用于语音助手、自动化客服、有声书等领域。 智能语音应用开发：Suno AI 提供了一系列工具和平台，帮助开发者快速构建和部署智能语音应用。他们的开发工具包括 API 接口、SDK、开发文档等，支持多种编程语言和平台，让开发者可以轻松地集成语音功能到自己的应用中。 行业解决方案：Suno AI 为各行各业提供定制化的语音解决方案，满足客户特定的需求和业务场景。他们与零售、金融、医疗等领域的企业合作，提供智能语音客服、语音导航、语音支付等解决方案，帮助客户提升服务质量和效率。
opencv如何增加反向投影的图像特征c++
05-26
反向投影是一种图像处理技术，它可以将图像中的像素点映射到另一个图像上。在OpenCV中，可以使用cv::calcBackProject()函数来计算反向投影的图像特征。 以下是一个简单的C++示例代码，演示如何使用反向投影来增强...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值