pybind11 | 绑定CGAL几何算法（numpy数据交换）

于 2022-12-30 15:09:10 发布
阅读量1.1k 收藏 3
点赞数 2
分类专栏： # CGAL pybind11 文章标签： numpy pybind11 CGAL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39784672/article/details/128496002
版权

文章目录

一 前言

对于CGAL，前段时间也用过相关的Python绑定，详情见文章：【CGAL+Python】安装CGAL的Python绑定。如果我们想要调用[Polygon Mesh Processing](CGAL 5.5.1 - Polygon Mesh Processing: User Manual)中的算法，在不就地读取网格文件的前提下，需要在Python代码中构建CGAL的多边形网格对象，显得非常的不方便和蹩脚。正好，我在之前使用过libigl库的Python绑定，其数据通过numpy进行交换，即输入和输出都是numpy数组。于是，在对pybind11进行了一段时间的学习后，我开始尝试通过pybind11对CGAL的相关函数进行绑定生成Python调用接口，更重要的是使用numpy数组进行数据交换。

二 numpy数据交换

2.1 pybind11对numpy的支持

在pybind11/numpy.h头文件中，提供了对Numpy array的支持。我们可以通过py::array_t<T>来实现一个Numpy array。

py::array_t支持一些基于Numpy的API：

  • .dtype()返回数组元素的类型。
  • .strides()返回数组strides的指针。
  • .reshape({i, j, ...})返回指定shape的数组视图。.resize({})也可以。
  • .index_at(i, j, ...)获取数组指定索引的元素。

为了更高效地访问大型数组，pybind11提供了不带检查的代理类unchecked<N>和mutable_unchecked<N>，其中N为数组所需的维数。

m.def("sum_3d", [](py::array_t<double> x) {
    auto r = x.unchecked<3>(); // x must have ndim = 3; can be non-writeable
    double sum = 0;
    for (py::ssize_t i = 0; i < r.shape(0); i++)
        for (py::ssize_t j = 0; j < r.shape(1); j++)
            for (py::ssize_t k = 0; k < r.shape(2); k++)
                sum += r(i, j, k);
    return sum;
});
m.def("increment_3d", [](py::array_t<double> x) {
    auto r = x.mutable_unchecked<3>(); // Will throw if ndim != 3 or flags.writeable is false
    for (py::ssize_t i = 0; i < r.shape(0); i++)
        for (py::ssize_t j = 0; j < r.shape(1); j++)
            for (py::ssize_t k = 0; k < r.shape(2); k++)
                r(i, j, k) += 1.0;
}, py::arg().noconvert());

这两个代理类的区别就是：当只用从一个array_t<T>对象中读取数据时，我们使用unchecked<N>对它进行代理访问；当我们需要修改一个array_t<T>对象中的数据时，我们使用mutable_unchecked<N>对它进行代理访问。

同时Numpy array支持缓冲协议（buffer protocol），因此我们也可以通过.request()对其的缓冲区信息进行访问。

struct buffer_info {
    void *ptr;	// Pointer to the underlying storage
    py::ssize_t itemsize;	// Size of individual items in bytes
    std::string format;
    py::ssize_t ndim;		// Number of dimensions
    std::vector<py::ssize_t> shape; // Shape of the tensor (1 entry per dimension)
    std::vector<py::ssize_t> strides;	//Number of bytes between adjacent entries
};

其他详细信息参见文档：NumPy - pybind11 documentation。

2.2 Numpy VF(py::array_t)与CGAL mesh(Surface Mesh)之间的转换

// 将Numpy VF转换成CGAL mesh
CGAL_Mesh convert_mesh_from_Numpy_to_CGAL(py::array_t<double>& V, py::array_t<int>& F)
{
    CGAL_Mesh CGAL_mesh;
    // 获取V, F的信息
    py::buffer_info buf_v = V.request();
    py::buffer_info buf_f = F.request();
    if (buf_v.shape[1] != 3)
        throw std::runtime_error("vertex must be 3 dims ");
    if (buf_f.shape[1] != 3)
        throw std::runtime_error("face must be 3 dims ");

    auto v = V.unchecked<2>();
    auto f = F.unchecked<2>();

    // clear and reserve the mesh
    CGAL_mesh.clear();
    int vn = buf_v.shape[0];    // 顶点个数
    int fn = buf_f.shape[0];    // 面个数
    int e = 0;
    CGAL_mesh.reserve(vn, 2 * fn, e);

    //copy the vertices
    double x, y, z;
    for (py::ssize_t i = 0; i < v.shape(0); i++)
    {
        Point p;
        x = v(i, 0);
        y = v(i, 1);
        z = v(i, 2);
        p = Point(x, y, z);
        CGAL_mesh.add_vertex(p);
    }

    // copy the faces
    std::vector <int> vertices;
    for (py::ssize_t i = 0; i < f.shape(0); i++)
    {
        vertices.resize(3);
        vertices[0] = f(i, 0);
        vertices[1] = f(i, 1);
        vertices[2] = f(i, 2);
        CGAL_mesh.add_face(CGAL_Mesh::Vertex_index(vertices[0]),
            CGAL_Mesh::Vertex_index(vertices[1]),
            CGAL_Mesh::Vertex_index(vertices[2]));
    }

    return CGAL_mesh;
}

// 将CGAL mesh转换成Numpy VF
std::pair<py::array_t<double>, py::array_t<int>> convert_mesh_from_CGAL_to_Numpy(CGAL_Mesh& CGAL_mesh)
{
    //申请内存
    py::array_t<double> V = py::array_t<double>(CGAL_mesh.number_of_vertices() * 3);
    py::array_t<int> F = py::array_t<int>(CGAL_mesh.number_of_faces() * 3);
    std::pair<py::array_t<double>, py::array_t<int>> VF(V,F);

    V.resize({ int(CGAL_mesh.number_of_vertices()), 3 });
    F.resize({ int(CGAL_mesh.number_of_faces()), 3 });

    auto v = V.mutable_unchecked<2>();  // mutable_unchecked: can be writeable
    auto f = F.mutable_unchecked<2>();

    int i = 0;
    for (CGAL_Mesh::Vertex_index vd : vertices(CGAL_mesh))
    {
        v(i, 0) = CGAL_mesh.point(vd).x();
        v(i, 1) = CGAL_mesh.point(vd).y();
        v(i, 2) = CGAL_mesh.point(vd).z();
        i++;
    }

    i = 0;
    for (CGAL_Mesh::Face_index fd : faces(CGAL_mesh))
    {
        int j = 0;
        for (CGAL_Mesh::Vertex_index vd : CGAL::vertices_around_face(CGAL_mesh.halfedge(fd), CGAL_mesh))
        {
            f(i, j) = int(vd);
            j++;
        }
        i++;
    }

    return VF;
}

三 绑定CGAL算法示例

3.1 示例函数

在本文中我们尝试绑定[Polygon Mesh Processing](CGAL 5.5.1 - Polygon Mesh Processing: User Manual)中的isotropic_remeshing函数。

struct halfedge2edge
{
    halfedge2edge(const CGAL_Mesh& m, std::vector<edge_descriptor>& edges)
        : m_mesh(m), m_edges(edges)
    {}
    void operator()(const halfedge_descriptor& h) const
    {
        m_edges.push_back(edge(h, m_mesh));
    }
    const CGAL_Mesh& m_mesh;
    std::vector<edge_descriptor>& m_edges;
};

std::pair<py::array_t<double>, py::array_t<int>> isotropic_remeshing(py::array_t<double>& V, py::array_t<int>& F, double target_edge_length = 1, unsigned int nb_iter = 5)
{
    CGAL_Mesh mesh = convert_mesh_from_Numpy_to_CGAL(V, F);
    std::vector<edge_descriptor> border;
    PMP::border_halfedges(faces(mesh), mesh, boost::make_function_output_iterator(halfedge2edge(mesh, border)));
    PMP::split_long_edges(border, target_edge_length, mesh);
    PMP::isotropic_remeshing(faces(mesh), target_edge_length, mesh,
        CGAL::parameters::number_of_iterations(nb_iter)
        .protect_constraints(true));
    return convert_mesh_from_CGAL_to_Numpy(mesh);
}

3.2 绑定部分代码

PYBIND11_MODULE(numpy_cgal, m) {

    m.doc() = "The CGAL geometry algorithms which called via the Numpy array";
    m.def("isotropic_remeshing", &isotropic_remeshing, "remeshes a triangular mesh",
        py::arg("V"), py::arg("F"), 
        py::arg("target_edge_length") = 1, py::arg("nb_iter") = 5);

}

3.3 示例完整代码

#include <pybind11/pybind11.h>
#include <pybind11/numpy.h>
#include <CGAL/Surface_mesh.h>
#include <CGAL/Simple_cartesian.h>
#include <CGAL/Polygon_mesh_processing/remesh.h>
namespace PMP = CGAL::Polygon_mesh_processing;
namespace py = pybind11;
typedef CGAL::Simple_cartesian<double>                          Kernal;
typedef Kernal::Point_3                                         Point;
typedef CGAL::Surface_mesh<Point>                               CGAL_Mesh;
typedef boost::graph_traits<CGAL_Mesh>::halfedge_descriptor     halfedge_descriptor;
typedef boost::graph_traits<CGAL_Mesh>::edge_descriptor         edge_descriptor;


// 将Numpy VF转换成CGAL mesh
CGAL_Mesh convert_mesh_from_Numpy_to_CGAL(py::array_t<double>& V, py::array_t<int>& F)
{
    CGAL_Mesh CGAL_mesh;
    // 获取V, F的信息
    py::buffer_info buf_v = V.request();
    py::buffer_info buf_f = F.request();
    // Validate
    if (buf_v.ndim != 2)
        throw std::runtime_error("Number of dimensions of `V` must be 2");

    if (buf_v.shape[1] != 3)
        throw std::runtime_error("Number of columns in `V` must be 3");

    if (buf_f.ndim != 2)
        throw std::runtime_error("Number of dimensions of `F` must be 2");

    if (buf_f.shape[1] != 3)
        throw std::runtime_error("Number of columns in `F` must be 3");

    auto v = V.unchecked<2>(); // unchecked: can be non - writeable
    auto f = F.unchecked<2>();

    // clear and reserve the mesh
    CGAL_mesh.clear();
    int vn = buf_v.shape[0];    // 顶点个数
    int fn = buf_f.shape[0];    // 面个数
    int e = 0;
    CGAL_mesh.reserve(vn, e, fn);

    //copy the vertices
    double x, y, z;
    for (py::ssize_t i = 0; i < v.shape(0); i++)
    {
        Point p;
        x = v(i, 0);
        y = v(i, 1);
        z = v(i, 2);
        p = Point(x, y, z);
        CGAL_mesh.add_vertex(p);
    }

    // copy the faces
    std::vector <int> vertices;
    for (py::ssize_t i = 0; i < f.shape(0); i++)
    {
        vertices.resize(3);
        vertices[0] = f(i, 0);
        vertices[1] = f(i, 1);
        vertices[2] = f(i, 2);
        CGAL_mesh.add_face(CGAL_Mesh::Vertex_index(vertices[0]),
            CGAL_Mesh::Vertex_index(vertices[1]),
            CGAL_Mesh::Vertex_index(vertices[2]));
    }

    return CGAL_mesh;
}

// 将CGAL mesh转换成Numpy VF
std::pair<py::array_t<double>, py::array_t<int>> convert_mesh_from_CGAL_to_Numpy(CGAL_Mesh& CGAL_mesh)
{
    //申请内存
    py::array_t<double> V = py::array_t<double>(CGAL_mesh.number_of_vertices() * 3);
    py::array_t<int> F = py::array_t<int>(CGAL_mesh.number_of_faces() * 3);
    std::pair<py::array_t<double>, py::array_t<int>> VF(V,F);

    V.resize({ int(CGAL_mesh.number_of_vertices()), 3 });
    F.resize({ int(CGAL_mesh.number_of_faces()), 3 });

    auto v = V.mutable_unchecked<2>();  // mutable_unchecked: can be writeable
    auto f = F.mutable_unchecked<2>();

    int i = 0;
    for (CGAL_Mesh::Vertex_index vd : vertices(CGAL_mesh))
    {
        v(i, 0) = CGAL_mesh.point(vd).x();
        v(i, 1) = CGAL_mesh.point(vd).y();
        v(i, 2) = CGAL_mesh.point(vd).z();
        i++;
    }

    i = 0;
    for (CGAL_Mesh::Face_index fd : faces(CGAL_mesh))
    {
        int j = 0;
        for (CGAL_Mesh::Vertex_index vd : CGAL::vertices_around_face(CGAL_mesh.halfedge(fd), CGAL_mesh))
        {
            f(i, j) = int(vd);
            j++;
        }
        i++;
    }

    return VF;
}

struct halfedge2edge
{
    halfedge2edge(const CGAL_Mesh& m, std::vector<edge_descriptor>& edges)
        : m_mesh(m), m_edges(edges)
    {}
    void operator()(const halfedge_descriptor& h) const
    {
        m_edges.push_back(edge(h, m_mesh));
    }
    const CGAL_Mesh& m_mesh;
    std::vector<edge_descriptor>& m_edges;
};

std::pair<py::array_t<double>, py::array_t<int>> isotropic_remeshing(py::array_t<double>& V, py::array_t<int>& F, double target_edge_length = 1, unsigned int nb_iter = 5)
{
    CGAL_Mesh mesh = convert_mesh_from_Numpy_to_CGAL(V, F);
    std::vector<edge_descriptor> border;
    PMP::border_halfedges(faces(mesh), mesh, boost::make_function_output_iterator(halfedge2edge(mesh, border)));
    PMP::split_long_edges(border, target_edge_length, mesh);
    PMP::isotropic_remeshing(faces(mesh), target_edge_length, mesh,
        CGAL::parameters::number_of_iterations(nb_iter)
        .protect_constraints(true));
    return convert_mesh_from_CGAL_to_Numpy(mesh);
}

// 绑定代码
PYBIND11_MODULE(numpy_cgal, m) 
{
    m.doc() = "The CGAL geometry algorithms which called via the Numpy array";
    m.def("isotropic_remeshing", &isotropic_remeshing, "remeshes a triangular mesh",
        py::arg("V"), py::arg("F"), 
        py::arg("target_edge_length") = 1, py::arg("nb_iter") = 5);
}

这里为了图方便将所有代码全写在了一个源文件里，正常来说应当将绑定代码和绑定对象分开。

四 编译生成和测试

4.1 编译生成pyd文件

在这个示例中，我是直接使用Visual Studio编译生成pyd文件。操作很简单，首先是按照这篇文章：pybind11学习 | VS2022下安装配置在VS中配置好pybind11，然后按照这篇文章：CGAL的安装与在VS中的配置在VS中配置好CGAL。在pybind11和CGAL都配置成功的前提下，生成解决方案即可得到pyd文件。如果电脑上没装Visual Studio，也可以尝试使用CMake进行构建，也是十分简单的，只需在这篇文章：pybind11学习 | 使用CMake构建系统并生成pyd文件的示例基础上在CMakeLists.txt中添加CGAL的库文件和头文件即可。

4.2 Python调用测试

测试代码如下：

import igl
import numpy as np
from CGAL import CGAL_Polygon_mesh_processing
from CGAL.CGAL_Polyhedron_3 import Polyhedron_3
import os.path


def isotropic_remeshing_off(filename, targetedgelength, remeshIter):
    if os.path.isfile(filename + ".off"):
        V, F, _ = igl.read_off(filename + "_iso_remesh.off", False)
        return F, V
    P = Polyhedron_3(filename + ".off")
    flist = []
    for fh in P.facets():
        flist.append(fh)
    CGAL_Polygon_mesh_processing.isotropic_remeshing(flist, targetedgelength, P, remeshIter)
    P.write_to_file(filename + "_iso_remesh.off")
    V, F, _ = igl.read_off(filename + "_iso_remesh.off", False)
    return F, V


def isotropic_remeshing_bindings(V, F, targetedgelength, remeshIter):
    import numpy_cgal
    V, F = numpy_cgal.isotropic_remeshing(V, F, targetedgelength, remeshIter)
    return F, V


if __name__ == "__main__":
    v, f = igl.read_triangle_mesh("test_mesh.off", dtypef = np.float64)
    f_remeshed, v_remeshed = isotropic_remeshing_bindings(v, f, 1, 5)

其中，第一个isotropic_remeshing_off函数是通过文章【CGAL+Python】安装CGAL的Python绑定中提到的绑定加上读写off文件实现的CGAL重新网格化算法调用。第二个isotropic_remeshing_bindings函数是通过调用pybind11生成的Python拓展模块（即本文的方法，numpy_cgal.pyd为上一小节生成的pyd文件）实现的。

调试结果如下：

在这里插入图片描述

可以看到，函数输入为ndarray类型，输出仍然为ndarray类型，且成功重新网格化，测试完毕。

五 总结

本文主要介绍一种在Python代码中调用C++第三方库API的思路。主要目的是抛砖引玉，本文的方法不一定是最好的，仅供大家参考学习。

参考和拓展

[1] CGAL 5.5.1 - Surface Mesh: User Manual

[2] CGAL 5.5.1 - Polygon Mesh Processing: User Manual

[3] pybind11 documentation

[4] pybind11—opencv图像处理(numpy数据交换) - 简书 (jianshu.com)

[5] pybind11-wrapped CGAL (github.com)

[6] cmpute/cgal.py: Pybind11 binding of cgal. Aimed at extending and easy use (github.com)

MSTIFIY
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
pybind11和numpy进行交互
aakwnam6338的博客
07-04 1705
使用一个遵循buffer protocol的对象就可以和numpy交互了. 这个buffer_protocol要有哪些东西呢? 要有如下接口: struct buffer_info { void *ptr; ssize_t itemsize; std::string format; ssize_t ndim; ...
CGAL Python Bindings
weixin_33682719的博客
01-12 653
2019独角兽企业重金招聘Python工程师标准>>> ...
pybind11使用教程笔记__5.2_python C++ interface__numpy
weixin_41521681的博客
05-25 2982
NumPy1. Buffer protocolSee also2. Arrays3. Structured types4. Vectorizing functionsNoteSee also5. Direct accessSee also6. Ellipsis 1. Buffer protocol python支持 非常通用和方便地与plugin libraries交换数据。types可以expose a buffer view [1], 提供 fast direct access to the raw i
pybind11：numpy 2D转c++的Eigen
原来也有北瓜
03-09 398
CMakeLists.txt文件 cmake_minimum_required(VERSION 2.8.12) project(shp) # Eigen include_directories("/usr/include/eigen3") add_subdirectory(pybind11) pybind11_add_module(shp shape_detection.cpp) cpp文件 #include <pybind11/pybind11.h> #include <pybin
C++数组和python数组相互转换（pybind11 numpy和指针数据转换） tcy
tcy-阿春
08-30 6155
1.实例：指针-->numpy #include <iostream> #include<pybind11/pybind11.h> #undef max//放在<pybind11/numpy.h>之前（#define NOMINMAX有时不起作用） #include<pybind11/numpy.h> namespace py = pybind11; using namespace py::literals; //*指针-->nump.
CGAL计算几何库 5.5.2版本
07-27
CGAL计算几何库 5.5.2版本，rar压缩包中包含： cgal-5.5.2.zip CGAL-5.5.2-doc_html.zip CGAL-5.5.2-examples.zip CGAL-5.5.2-library.zip CGAL-5.5.2-win64-auxiliary-libraries-gmp-mpfr.zip
cgal.zip_cgal_cgal数据结构
09-24
cgal的基础的数据结构半边的解释 以及对 cgal文档的参考方法
libcgal-julia：Julia的CGAL绑定
02-15
是一个功能强大且易于访问的C ++库，旨在提供计算几何学（因此得名）的算法，着重于可靠性和效率，同时仍提供可靠的结果。 建筑 可以使用.github/scripts下的build_tarballs.jl 脚本来构建项目。 这也用在CI中以及...
CGAL计算几何算法库
03-22
CGAL计算几何算法库
pybind11和numpy进行交互的方法
09-19
主要介绍了pybind11和numpy进行交互的方法，本文通过实例代码给大家介绍的非常详细，具有一定的参考借鉴价值 ,需要的朋友可以参考下
pygalmesh:CGAL网格生成器的Python前端
05-04
轻松创建高质量的网格物体。 pygalmesh是 和的Python前端。 pygalmesh使创建高质量2D，3D体积网格，周期性体积网格和曲面网格变得容易。 例子 2D网格 CGAL根据线性约束生成2D网格。 import numpy import pygalmesh points = numpy . array ([[ 0.0 , 0.0 ], [ 1.0 , 0.0 ], [ 1.0 , 1.0 ], [ 0.0 , 1.0 ]]) constraints = [[ 0 , 1 ], [ 1 , 2 ], [ 2 , 3 ], [ 3 , 0 ]] mesh = pygalmesh . generate_2d ( points , constraints , max_edge_size = 1.0e-1 , num_lloyd_steps =
CGAL-5.2-win64-auxiliary-libraries-gmp-mpfr--CGAL计算几何算法库.zip
01-04
CGAL具有广泛的数据结构和算法，包括Voronoi图，单元格复合体和多面体，三角剖分，曲线排列，表面和体积网格生成，空间搜索，alpha形状，几何处理等等。这些的使用导致美观，视觉复杂和准确的表示。 特征 算术和...
【CGAL+Python】安装CGAL的Python绑定
MSTIFIY的博客
11-23 2759
【CGAL+Python】安装CGAL的Python绑定
linux 编译cgal,CGAL Bindings python Linux(Ubuntu) 安装配置 使用 CGAL-5.0.2库
weixin_29165725的博客
05-01 795
准备阶段：环境准备：linuxcmake (version > 2.8.11)，本文里面是cmake3.14cmake下载：https://cmake.org/download/CGAL库依赖库列表：boost下载：Boost C++ Librariesgmp下载 ：https://gmplib.org/mpfr下载：https://www.mpfr.org/mpfr-current/CG...
Python WIN7 64位 安装-numpy-scipy-matplotlib-CGAL
Night_Fate的专栏
06-15 2071
本文记录了WIN 7 64 位python
Python安装cgal-bindings
using namespace 数学工具构造器;
04-21 3323
直接pip install cgal-bindings，报错。存在以下依赖： boost cgal swig 安装boost boost官网：https://www.boost.org/ 下载最新版： wget https://dl.bintray.com/boostorg/release/1.70.0/source/boost_1_70_0.tar.gz tar -zxvf boost_1_...
求救啊！！！python3.7如何配置CGAL
xiongerdidi的博客
09-10 1072
有没有python大佬教教我，尝试安装好几天了，还是安装不好。
CGAL Bindings python Linux(Ubuntu) 安装配置 使用 CGAL-5.0.2库
weixin_43882112的博客
04-23 2091
准备阶段： 环境准备： linux cmake (version > 2.8.11)，本文里面是cmake3.14 cmake下载：https://cmake.org/download/ CGAL库依赖库列表： boost下载：Boost C++ Libraries gmp下载 ：https://gmplib.org/ mpfr下载：https://www.mpfr...
pyzmq-23.2.1-cp310-cp310-musllinux_1_1_x86_64.whl
最新发布
06-07
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
python有这样CGAL几何库吗
04-28
它是一个Python模块，可以在Python中使用CGAL的几何算法和数据结构。PyCGAL提供了一个高性能、可扩展的Python接口，可以用于各种几何计算，如计算几何、三角剖分、拓扑学等。同时，它还支持NumPy数组，可以方便地...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值