识别不同的颗粒VTK文件中相同颗粒的信息变化

最新推荐文章于 2024-10-08 09:44:01 发布
最新推荐文章于 2024-10-08 09:44:01 发布
阅读量319 收藏
点赞数 2
分类专栏： Postprocess 文章标签： cfd c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49181094/article/details/107427095
版权

本文目的是通过读取两个时刻的颗粒信息文件，识别这两个时刻下某个求解范围或进程内具有相同编号的颗粒的信息变化情况。

对于两个时刻的VTK文件而言，其包含的颗粒可能是不一致的，因此还需要对这两个时刻此求解范围或进程内包含的相同颗粒进行识别。颗粒的VTK文件格式可参考颗粒VTK文件格式总结。

对应的求解程序如下（程序的解释已以注释的方式记录在cpp文件中；此外，由于这里需要对具有相同ID的颗粒在不同时刻下的不同信息进行对比，因而找到具有相同ID的颗粒之后将其不同时刻下的信息进行了整合并输出）：

/**
 * @file    vtkpost.cpp
 * @brief
 * @version
 * @date    Fri 25 Jan 2019 08:22:00 AM CST
 ******************************************************************************/

#include <math.h>
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <set>
#include <map>
using namespace std;

/* The last space is necessary. */
const string idmarker = "SCALARS id float 1 ";
const string nmarker  = "DATASET POLYDATA ";
const string pmarker  = "DATASET POLYDATA ";
const string tmarker  = "SCALARS type float 1 ";
const string rmarker  = "SCALARS radius float 1 ";
const string vmarker  = "VECTORS velocity float ";
const string amarker  = "VECTORS omega float ";
const string fmarker  = "VECTORS force float ";
const string fdmarker = "VECTORS fdrag float ";
const string fcmarker = "VECTORS collide float ";

typedef struct {
    int id, type;
    double xo, yo, zo;  // old position
    double xn, yn, zn;  // new position
    double uo, vo, wo;  // old velocity
    double un, vn, wn;  // new velocity
    double du, dv, dw;  // velocity changes
    double mu;          // magitude of velocity changes
    double rp;          // radius
    double auo, avo, awo;   // old angular velocity
    double aun, avn, awn;   // new angular velocity
    double dau, dav, daw;   // angular velocity changes
    double fxo, fyo, fzo;   // old force
    double fxn, fyn, fzn;   // new force
    double fdxo, fdyo, fdzo;    // old drag force
    double fdxn, fdyn, fdzn;    // new drag force
    double fcxo, fcyo, fczo;    // old collide force
    double fcxn, fcyn, fczn;    // new collide force
} Vtkout;

/* Find the mapping relations between reading sequence and the particle id */
map<int, int> find_seq2ids(const char *name);

/* Extract indices from the mapping relations. */
set<int> extract_id(const map<int, int> &mapping);

/* Find common indices between ...1.vtk and ...2.vtk. */
set<int> find_comm_id(
        const set<int> &ids1,
        const set<int> &ids2);

/* Generate mapping relations from reading sequence to common indices */
map<int, int> generate_ids2seq(const set<int> &commids);

/* Read the information of the common partiles in ...1.vtk and ...2.vtk. */
vector<Vtkout> read_comm_info(
        const char *name1,
        const map<int, int> &map1,
        const char *name2,
        const map<int, int> &map2,
        const set<int> &commids,
        const map<int, int> &commids2seq);

/* Write all collected data to a dat file. */
void write_data(const vector<Vtkout> &data);

/*----------------------------------------------------------------------------*/

int main(int argc, char *argv[])
{
    /* Only file name should be modified if necessary. */
    const char *name1 = "./part120000001.vtk";
    const char *name2 = "./part120000002.vtk";

    /* Use map1 and map2 to record the mapping relations between reading
     * sequence and particle indices of file 1 and file2, respectively.*/
    const map<int, int> map1 = find_seq2ids(name1);
    const map<int, int> map2 = find_seq2ids(name2);

    const set<int> ids1 = extract_id(map1);
    const set<int> ids2 = extract_id(map2);
    const int np1 = ids1.size();
    const int np2 = ids2.size();

    cout << "Particle number in file " << name1 << " is " << np1 << endl;
    cout << "Particle number in file " << name2 << " is " << np2 << endl;

    const set<int> commids = find_comm_id(ids1, ids2);
    const map<int, int> ids2seq = generate_ids2seq(commids);
    const int comm_np = commids.size();

    cout << "Common particle number is " << comm_np << endl;

    vector<Vtkout> data =
        read_comm_info(name1, map1, name2, map2, commids, ids2seq);

    /* for (auto it = ids2seq.begin(); it != ids2seq.end(); it++) { */
    /*     cout << it->first << "\t" << it->second << endl; */
    /* } */

    /* for (int i = 0; i < 10; i++) { */
    /*     cout << data[i].xo << "\t" << data[i].yo << "\t" << data[i].zo << endl; */
    /* } */

    write_data(data);

    return 0;
}

/*----------------------------------------------------------------------------*/

/* Find the mapping relations between reading sequence and the particle id */
map<int, int> find_seq2ids(const char *name)
{

    map<int, int> seq2ids;
    ifstream fin;
    string stmp, line;
    int np, id;

    /* Read all indices in ...1.vtk. */
    fin.open(name, ios::in);

    while (getline(fin, line)) {
        /* Find the particle number in current vtk file. */
        if (line == nmarker) {
            fin >> stmp >> np >> stmp;
        }

        /* Read all indices and insert all indices to a set. */
        if (line == idmarker) {
            for (int i = 0; i < np; i++) {
                getline(fin, line);
                fin >> id;
                seq2ids.insert(pair<int, int>(i, id));
            }
        }
    }

    fin.close();

    return seq2ids;
}

/* Extract indices from the mapping relations. */
set<int> extract_id(const map<int, int> &mapping)
{
    set<int> ids;
    for (auto it = mapping.begin(); it != mapping.end(); it++) {
        ids.insert(it->second);
    }

    return ids;
}

/* Find common indices between ...1.vtk and ...2.vtk. */
set<int> find_comm_id(
        const set<int> &ids1,
        const set<int> &ids2)
{
    set<int> commids;

    for (auto it = ids2.begin(); it != ids2.end(); it++) {
        if (ids1.find(*it) != ids1.end()) {
            commids.insert(*it);
        }
    }

    return commids;
}

/* Generate mapping relations from reading sequence to common indices */
map<int, int> generate_ids2seq(const set<int> &commids)
{
    int count = 0;
    map<int, int> ids2seq;
    for (auto it = commids.begin(); it != commids.end(); it++) {
        ids2seq.insert(pair<int, int>(*it, count));
        count++;
    }

    return ids2seq;
}

/* Read the information of the common partiles in ...1.vtk and ...2.vtk. */
vector<Vtkout> read_comm_info(
        const char *name1,
        const map<int, int> &map1,
        const char *name2,
        const map<int, int> &map2,
        const set<int> &commids,
        const map<int, int> &commids2seq)
{
    const int np1 = map1.size();
    const int np2 = map2.size();
    const int comm_np = commids.size();

    int itmp;
    double xtmp, ytmp, ztmp, dtmp;
    string stmp, line;
    ifstream fin;
    vector<Vtkout> data(comm_np);

    /* Read all information from ...1.vtk */
    fin.open(name1, ios::in);

    while (getline(fin, line)) {
        if (line == pmarker) {
            cout << "Find pmarker" << endl;
            getline(fin, line);
            for (int i = 0; i < np1; i++) {
                fin >> xtmp >> ytmp >> ztmp;
                map<int, int>::const_iterator m1it = map1.find(i);
                if (commids.find(m1it->second) != commids.end()) {
                    map<int, int>::const_iterator cit = commids2seq.find(m1it->second);
                    data[cit->second].id = m1it->second;
                    data[cit->second].xo = xtmp;
                    data[cit->second].yo = ytmp;
                    data[cit->second].zo = ztmp;
                }
            }
        }

        if (line == vmarker) {
            cout << "Find vmarker" << endl;
            for (int i = 0; i < np1; i++) {
                fin >> xtmp >> ytmp >> ztmp;
                map<int, int>::const_iterator m1it = map1.find(i);
                if (commids.find(m1it->second) != commids.end()) {
                    map<int, int>::const_iterator cit = commids2seq.find(m1it->second);
                    data[cit->second].uo = xtmp;
                    data[cit->second].vo = ytmp;
                    data[cit->second].wo = ztmp;
                }
            }
        }

        if (line == amarker) {
            cout << "Find amarker" << endl;
            for (int i = 0; i < np1; i++) {
                fin >> xtmp >> ytmp >> ztmp;
                map<int, int>::const_iterator m1it = map1.find(i);
                if (commids.find(m1it->second) != commids.end()) {
                    map<int, int>::const_iterator cit = commids2seq.find(m1it->second);
                    data[cit->second].auo = xtmp;
                    data[cit->second].avo = ytmp;
                    data[cit->second].awo = ztmp;
                }
            }
        }

        if (line == fmarker) {
            cout << "Find fmarker" << endl;
            for (int i = 0; i < np1; i++) {
                fin >> xtmp >> ytmp >> ztmp;
                map<int, int>::const_iterator m1it = map1.find(i);
                if (commids.find(m1it->second) != commids.end()) {
                    map<int, int>::const_iterator cit = commids2seq.find(m1it->second);
                    data[cit->second].fxo = xtmp;
                    data[cit->second].fyo = ytmp;
                    data[cit->second].fzo = ztmp;
                }
            }
        }

        if (line == fdmarker) {
            cout << "Find fdmarker" << endl;
            for (int i = 0; i < np1; i++) {
                fin >> xtmp >> ytmp >> ztmp;
                map<int, int>::const_iterator m1it = map1.find(i);
                if (commids.find(m1it->second) != commids.end()) {
                    map<int, int>::const_iterator cit = commids2seq.find(m1it->second);
                    data[cit->second].fdxo = xtmp;
                    data[cit->second].fdyo = ytmp;
                    data[cit->second].fdzo = ztmp;
                }
            }
        }

        if (line == fcmarker) {
            cout << "Find fcmarker" << endl;
            for (int i = 0; i < np1; i++) {
                fin >> xtmp >> ytmp >> ztmp;
                map<int, int>::const_iterator m1it = map1.find(i);
                if (commids.find(m1it->second) != commids.end()) {
                    map<int, int>::const_iterator cit = commids2seq.find(m1it->second);
                    data[cit->second].fcxo = xtmp;
                    data[cit->second].fcyo = ytmp;
                    data[cit->second].fczo = ztmp;
                }
            }
        }

        if (line == tmarker) {
            cout << "Find tmarker" << endl;
            getline(fin, line);
            for (int i = 0; i < np1; i++) {
                fin >> itmp;
                map<int, int>::const_iterator m1it = map1.find(i);
                if (commids.find(m1it->second) != commids.end()) {
                    map<int, int>::const_iterator cit = commids2seq.find(m1it->second);
                    data[cit->second].type = itmp;
                }
            }
        }

        if (line == rmarker) {
            cout << "Find rmarker" << endl;
            getline(fin, line);
            for (int i = 0; i < np1; i++) {
                fin >> dtmp;
                map<int, int>::const_iterator m1it = map1.find(i);
                if (commids.find(m1it->second) != commids.end()) {
                    map<int, int>::const_iterator cit = commids2seq.find(m1it->second);
                    data[cit->second].rp = dtmp;
                }
            }
        }
    }

    fin.close();


    /* Read all information from ...2.vtk */
    fin.open(name2, ios::in);

    while (getline(fin, line)) {
        if (line == pmarker) {
            cout << "Find pmarker" << endl;
            getline(fin, line);
            for (int i = 0; i < np2; i++) {
                fin >> xtmp >> ytmp >> ztmp;
                map<int, int>::const_iterator m2it = map2.find(i);
                if (commids.find(m2it->second) != commids.end()) {
                    map<int, int>::const_iterator cit = commids2seq.find(m2it->second);
                    data[cit->second].xn = xtmp;
                    data[cit->second].yn = ytmp;
                    data[cit->second].zn = ztmp;
                }
            }
        }

        if (line == vmarker) {
            cout << "Find vmarker" << endl;
            for (int i = 0; i < np2; i++) {
                fin >> xtmp >> ytmp >> ztmp;
                map<int, int>::const_iterator m2it = map2.find(i);
                if (commids.find(m2it->second) != commids.end()) {
                    map<int, int>::const_iterator cit = commids2seq.find(m2it->second);
                    data[cit->second].un = xtmp;
                    data[cit->second].vn = ytmp;
                    data[cit->second].wn = ztmp;
                }
            }
        }

        if (line == amarker) {
            cout << "Find amarker" << endl;
            for (int i = 0; i < np2; i++) {
                fin >> xtmp >> ytmp >> ztmp;
                map<int, int>::const_iterator m2it = map2.find(i);
                if (commids.find(m2it->second) != commids.end()) {
                    map<int, int>::const_iterator cit = commids2seq.find(m2it->second);
                    data[cit->second].aun = xtmp;
                    data[cit->second].avn = ytmp;
                    data[cit->second].awn = ztmp;
                }
            }
        }

        if (line == fmarker) {
            cout << "Find fmarker" << endl;
            for (int i = 0; i < np2; i++) {
                fin >> xtmp >> ytmp >> ztmp;
                map<int, int>::const_iterator m2it = map2.find(i);
                if (commids.find(m2it->second) != commids.end()) {
                    map<int, int>::const_iterator cit = commids2seq.find(m2it->second);
                    data[cit->second].fxn = xtmp;
                    data[cit->second].fyn = ytmp;
                    data[cit->second].fzn = ztmp;
                }
            }
        }

        if (line == fdmarker) {
            cout << "Find fdmarker" << endl;
            for (int i = 0; i < np2; i++) {
                fin >> xtmp >> ytmp >> ztmp;
                map<int, int>::const_iterator m2it = map2.find(i);
                if (commids.find(m2it->second) != commids.end()) {
                    map<int, int>::const_iterator cit = commids2seq.find(m2it->second);
                    data[cit->second].fdxn = xtmp;
                    data[cit->second].fdyn = ytmp;
                    data[cit->second].fdzn = ztmp;
                }
            }
        }

        if (line == fcmarker) {
            cout << "Find fcmarker" << endl;
            for (int i = 0; i < np2; i++) {
                fin >> xtmp >> ytmp >> ztmp;
                map<int, int>::const_iterator m2it = map2.find(i);
                if (commids.find(m2it->second) != commids.end()) {
                    map<int, int>::const_iterator cit = commids2seq.find(m2it->second);
                    data[cit->second].fcxn = xtmp;
                    data[cit->second].fcyn = ytmp;
                    data[cit->second].fczn = ztmp;
                }
            }
        }
    }

    fin.close();

    for (auto it = data.begin(); it != data.end(); it++) {
        it->du = it->un - it->uo;
        it->dv = it->vn - it->vo;
        it->dw = it->wn - it->wo;
        it->mu = sqrt(pow(it->du, 2) + pow(it->dv, 2) + pow(it->dw, 2));

        it->dau = it->aun - it->auo;
        it->dav = it->avn - it->avo;
        it->daw = it->awn - it->awo;
    }

    return data;
}

void write_data(const vector<Vtkout> &data)
{
    ofstream fout;
    fout.open("result.dat");

    fout << "id" << "\t" << "type" << "\t" << "rp" << "\t"
         << "xo" << "\t" << "yo" << "\t" << "zo" << "\t"
         << "xn" << "\t" << "yn" << "\t" << "zn" << "\t"
         << "uo" << "\t" << "vo" << "\t" << "wo" << "\t"
         << "un" << "\t" << "vn" << "\t" << "wn" << "\t"
         << "du" << "\t" << "dv" << "\t" << "dw" << "\t"
         << "mu" << "\t"
         << "auo" << "\t" << "avo" << "\t" << "awo" << "\t"
         << "aun" << "\t" << "avn" << "\t" << "awn" << "\t"
         << "dau" << "\t" << "dav" << "\t" << "daw" << "\t"
         << "fxo" << "\t" << "fyo" << "\t" << "fzo" << "\t"
         << "fxn" << "\t" << "fyn" << "\t" << "fzn" << "\t"
         << "fdxo" << "\t" << "fdyo" << "\t" << "fdzo" << "\t"
         << "fdxn" << "\t" << "fdyn" << "\t" << "fdzn" << "\t"
         << "fcxo" << "\t" << "fcyo" << "\t" << "fczo" << "\t"
         << "fcxn" << "\t" << "fcyn" << "\t" << "fczn" << "\t"
         << endl;

    for (auto it = data.begin(); it != data.end(); it++) {
        fout << it->id << "\t" << it->type << "\t" << it->rp << "\t"
             << it->xo << "\t" << it->yo << "\t" << it->zo << "\t"
             << it->xn << "\t" << it->yn << "\t" << it->zn << "\t"
             << it->uo << "\t" << it->vo << "\t" << it->wo << "\t"
             << it->un << "\t" << it->vn << "\t" << it->wn << "\t"
             << it->du << "\t" << it->dv << "\t" << it->dw << "\t"
             << it->mu << "\t"
             << it->auo << "\t" << it->avo << "\t" << it->awo << "\t"
             << it->aun << "\t" << it->avn << "\t" << it->awn << "\t"
             << it->dau << "\t" << it->dav << "\t" << it->daw << "\t"
             << it->fxo << "\t" << it->fyo << "\t" << it->fzo << "\t"
             << it->fxn << "\t" << it->fyn << "\t" << it->fzn << "\t"
             << it->fdxo << "\t" << it->fdyo << "\t" << it->fdzo << "\t"
             << it->fdxn << "\t" << it->fdyn << "\t" << it->fdzn << "\t"
             << it->fcxo << "\t" << it->fcyo << "\t" << it->fczo << "\t"
             << it->fcxn << "\t" << it->fcyn << "\t" << it->fczn << "\t"
             << endl;
    }

    fout.close();
}

相关的编译和运行命令如下：

# Compile:
g++ vtkpost.cpp -std=c++11 -o vtkpost

# Run:
./vtkpost

# Abbr. in results:
#    postfix o: old
#    postfix n: new
#    prefix  d: change
#    f: force
#    fd: drag
#    fc: collide
#    ......
#    (also see from line 32 to line 48 in vtkpost.cpp)
姜蜉蝣
关注
专栏目录
MATLAB算法实战应用案例精讲-【人工智能】枝晶生长模型（附matlab代码实现）
qq_36130719的博客
01-17 2734
在自然界中，雪花是人们最常见的枝晶。在人为控制的条件下，也常常从熔体、溶液或固溶体、蒸气以及电解沉积长出固体的过程中观察到枝晶。枝晶生长是一种生长的不稳定现象，常起因于过冷的液体，或晶体的生长速度受限于溶质原子向固体表面的扩散速度。造成以上条件的原因，可以是液相中负的温度梯度，也可以是负的浓度梯度。在这种模式下，晶体倾向于在其棱角处优先生长，从而形成突触状结构。在纯金属熔体中，只有在界面前沿液体中的温度梯度是负值时，枝晶形态才可能发展为主要形态；
颗粒VTK文件格式总结
姜蜉蝣的博客
07-18 512
本文总结了颗粒的VTK格式中所包含的常见内容。
CFDEM后处理:如何用paraview读取颗粒数据? :用lpp将dump转换成vtk文件
beidou111的博客
07-11 3590
liggghts(lammps)输出的文件格式是dump 但是paraview只能处理chunk类型文件, 也就是说, paraview能够处理的类型是**.vtk**文件 于是需要转换文件格式. 查看了一下tutorials里面的Allrun.sh脚本, 发现它是这么做的: CFDEM里面给了一个Python脚本, 只要运行如下命令即可完成转换. python $CFDEM_LPP_DIR/lp...
FPGA 20个例程篇：9.DDR3内存颗粒初始化写入并通过RS232读取（下）
wandou0511的博客
07-24 4762
2.对于写数据操作，和读写地址操作相类似，也是四个信号app_wdf_data、app_wdf_rdy、app_wdf_wren、app_wdf_end一定要对齐，一样的其中app_wdf_rdy是由MIGIP核所产生的输出信号，另外三个信号均由用户端产生并输出到MIGIP核，当MIGIP核默认突发长度为8时，app_wdf_end和app_wdf_wren相同，在app_wdf_rdy为高时去拉高app_wdf_wren，则此时app_wdf_data数据有效输入到MIGIP核；.........
vtk实战(八)—读取.raw文件
看那天上的彩云
04-25 2807
#include vtkSmartPointer.h> #include vtkRenderWindow.h> #include vtkRenderWindowInteractor.h> #include vtkRenderer.h> #include vtkActor.h> #include vtkProperty.h> #include vtkParticleReader.h> #includ
VTK利用点云高程渲染点云（+读写文件）
u013094443的博客
10-01 4708
原始数据格式是个TXT文件，，包含x，y，z坐标，现在想利用点云的高程进行渲染，但是使用vtkSimplePointReader类读取的 x-y-z坐标只能给点云统一指定颜色，而类vtkParticleReader读取的数据形式为x-y-z-a，后来自己从新写了下文件，将x-y-z后面再写个z值作为a，然后实现利用a（也就是原数据的z渲染点云），代码如下： #include #include
基于C++的VTK对不同格式的文件进行读取与另存源码和用到的素材文件.txt
04-02
本资源包含基于C++的VTK对不同格式的文件进行读取与另存源码和用到的素材文件。 实例1：读取STL文件并渲染显示...本资源配套CSDN博客“基于C++的VTK不同格式文件读取与另存整理”，可 前往查看具体原理和实现效果！！！
VTK示例文件 VTK_Example
06-13
在使用VS编译 VTK 8.2.0 时顺手生成的VTK示例文件,大概有20余个吧,文件夹里已经包含依赖,可正常运行 VTK示例文件 VTK_Example
vtk读取stl文件
04-11
STL（Stereo Lithography）文件格式，是3D打印和计算机辅助设计(CAD)领域中常见的文件格式，用于存储三维模型的几何信息。STL 文件通常由一系列三角面片组成，每个面片包含三个顶点坐标和法线向量，用于描述物体的...
VTK用户手册--中文翻译版.rar_VTK 教材_vtk_vtk中文帮助_vtk中文手册_vtk用户指南
07-15
VTK中文用户手册，VTK初学者最好的学习资料，建议查看官方最新文档。
VTK修炼之道56中的资源文件fran_cut.vtk文件
11-07
VTK修炼之道56中的资源文件fran_cut.vtk文件，之前有博主写了相关代码没有上传文件。
编写VTK文件，导入paraview显示
lllllalzh的博客
05-25 1891
vtk文件格式 编写vtk导入paraview
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1284
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
【C++】List
最新发布
m0_46676283的博客
10-08 312
文章目录1.list的介绍及使用1.1 list的介绍 本节目标 1.list的介绍及使用 2.list的深度剖析及模拟实现 3.list与vector的对比 4.本节习题 1.list的介绍及使用 1.1 list的介绍
（STL）map与set的封装--采用红黑树
2302_80190394的博客
10-04 831
（STL）map与set的封装--采用红黑树
C++之多态篇(超详细版)
2302_79795375的博客
10-04 900
public:cout
C++中数据类型的大小
mankeywang的博客
09-30 398
不同数据类型的大小
【STL】queue的模拟实现
gaogo
10-07 249
利用deque实现queue的模拟实现
将流场信息保存到vtk文件中
04-03
1. 首先需要安装vtk库，可以使用pip命令进行安装：`pip install vtk` 2. 在代码中导入vtk库：`import vtk` ...这样就可以将流场信息保存到vtk文件中了。可以使用ParaView等工具打开vtk文件进行可视化和分析。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值