分形几何算法和实现

最新推荐文章于 2023-06-01 13:28:58 发布
最新推荐文章于 2023-06-01 13:28:58 发布
阅读量1.6w 收藏 27
点赞数 4
分类专栏： C_world

初识分形

1、分形的含义：

英文单词Fractal，它是由美籍法国数学家曼德勃罗（Benoit Mandelbrot）创造出来的。其含义是不规则的、破碎的、分数的。曼德勃罗是想用此词来描述自然界中传统欧几里得几何学所不能描述的一大类复杂无规的几何对象。

2、分形的几何特征：

自相似性：自相似，便是局部与整体的相似。

自仿射性：自仿射性是自相似性的一种拓展。如果，将自相似性看成是局部到整体在各个方向上的等比例变换的结果的话，那么，自仿射性就是局部到整体在不同方向上的不等比例变换的结果。前者称为自相似变换，后者称为自仿射变换。

精细结构：任意小局部总是包含细致的结构。

3、分形与计算机科学：

分形理论的发展离不开计算机图形学的支持，如果一个分形构造的表达，不用计算机的帮助是很难让人理解的。不仅如此，分形算法与现有计算机图形学的其他算法相结合，还会产生出非常美丽的图形，而且可以构造出复杂纹理和复杂形状，从而产生非常逼真的物质形态和视觉效果。

分形作为一种方法，在图形学领域主要是利用迭代、递归等技术来实现某一具体的分形构造。

分形几何学与计算机图形学相结合，将会产生一门新的学科——分形图形学。它的主要任务是以分形几何学为数学基础，构造非规则的几何图素，从而实现分形体的可视化，以及对自然景物的逼真模拟。

本文地址：http://www.cnblogs.com/archimedes/p/fractal-c.html，转载请注明源地址。

分形图的递归算法

递归算法就不赘述了，凡是搞编程的应该都不陌生，可以参考我早前写过的一些递归程序题目小练一下:《递归练习(C语言)》

以Koch曲线的递归算法为例：

代码如下：

#include<stdio.h>
#include<math.h>
#include<conio.h>
#include"graphics.h"
void  koch(double x0, double y0, double x1, double y1, int k)
{
    double x2, y2, x3, y3, x4, y4;
    x2 = 2.0/3 * x0 + 1.0/3 * x1;  /*由上面的运算可以得到其余三点 坐标的计算式*/
    y2 = 2.0/3 * y0 + 1.0/3 * y1;
    x3 = 1.0/3 * x0 + 2.0/3 * x1;
    y3 = 1.0/3 * y0 + 2.0/3 * y1;
    x4 = 1.0/2 * (x0 + x1) - sqrt(3.0)/6 * (y1 - y0);
    y4 = 1.0/2 * (y0 + y1) + sqrt(3.0)/6 * (x1 - x0);
    if( k > 1)    /*如果迭代次数大于1，就继续迭代下去，即执行以下程序*/
    {
        koch(x0, y0, x2, y2, k - 1);  /*对以(x0, y0)和(x2, y2)为端点的线段作为
        初始线段进行迭代运算，以下类同*/
        koch(x2, y2, x4, y4, k - 1);
        koch(x4, y4, x3, y3, k - 1);
        koch(x3, y3, x1, y1, k - 1);
    } else {      /*如果迭代次数等于1，停止迭代，画出迭代生成的图形*/
        line(x0, y0, x2, y2);       /*用直线联结两点(x0, y0)和(x2, y2)*/
        line(x2, y2, x4, y4);       /*用直线联结两点(x2, y2)和(x4, y4)*/
        line(x4, y4, x3, y3);       /*用直线联结两点(x4, y4)和(x3, y3)*/
        line(x3, y3, x1, y1);       /*用直线联结两点(x3, y3)和(x1, y1)*/
    }
}

int main()
{
    int n, gdriver = DETECT, gmode;      /*定义迭代次数n*/
    initgraph(&gdriver, &gmode,"C:\\Win-TC\\BGI");     /*图形系统初始化*/
    printf("Please input the value of the positive integer n (n<9):");
    scanf("%d", &n);               /*输入迭代次数n*/
    setcolor(GREEN);
    koch(50, 120, 450, 120, n);
    getch();
    closegraph(); /*关闭图形系统*/
    return 0;
}

LS文法

LS文法先定义了绘图规则：

F：以当前方向前进一步，并画线；

f：以当前方向前进一步，不画线；

＋：逆时针旋转角；

－：顺时针旋转角；

[：表示暂时保存当前的画图状态；

]：表示提取出保存的画图状态。 “[”和“]”要成对的出现。

Koch曲线的LS文法如下：

 w：F（初始字母）

 a ：60(旋转角度)

 P：F → F ＋ F － － F ＋ F（F的替代文法）

根据这一文法生成Koch曲线的步骤（假设迭代两次）：

第一步： 得到迭代两次的文法。

 第一次迭代结果：

             F ＋ F － － F ＋ F

 第二次迭代结果：(第一次迭代得到的结果的每一个F用规则P替换)

             F ＋ F － － F ＋ F ＋ F ＋ F － － F ＋ F － － F ＋ F － － F ＋ F ＋ F ＋ F － － F ＋ F

第二步：按照迭代得到的文法绘图。

当然，还有实现其他分形图的LS文法，这里就不一一举出了

下面的算法没有用递归，纯C语言实现：

/****************************************************
** Completed on 2014.11.11 11:11
** Programming environment：win xp + win-tc 2.0
** Language: ANSI C
** copyright(c)  codingwu   (Email: oskernel@126.com)
*****************************************************/
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#include<ctype.h>
#include<malloc.h>
#include<conio.h>
#include<graphics.h>

#define PI 3.1415926
#define stacksize 1024

typedef struct _point {
    double x;
    double y;
    double delta;
}point;

typedef struct _L_Sys {
    char *name;
    char *startStr; /* 初始字符串 */
    char *replaceF;
    char *replaceX;  /* 替换X字符串 */
    char *replaceY;  /* 替换Y字符串 */
    char *replaceS;  /* 替换S字符串 */
    char *replaceG;  /* 替换G字符串 */
    char *replaceK;  /* 替换K字符串 */
    char *replaceL;  /* 替换L字符串 */
    char *replaceH;  /* 替换H字符串 */
    int StartX;  /* 起始点坐标 */
    int StartY;
    int depth;   /* 递归深度 */
    int ruleNumber;  /* 规则数 */
    double angle;
    double direct_init;
    double length;

}L_Sys;

L_Sys ls[100];

void init_L_Sys(L_Sys *LS, char *_name, char *_startStr, char *_replaceF,
        char *_replaceX, char *_replaceY, char *_replaceS, char *_replaceG,
        char *_replaceK, char *_replaceL, char *_replaceH,  int _StartX,
        int _StartY, int _depth, int _ruleNumber, double _angle,
        double _direct_init, double _length)    /* 初始化 */
{
    (*LS).name = (char *)malloc(strlen(_name) + 1);
    if((*LS).name == NULL) return;
    strcpy((*LS).name, _name);
    (*LS).startStr = (char *)malloc(strlen(_startStr) + 1);
    if((*LS).startStr == NULL) return;
    strcpy((*LS).startStr, _startStr);
    (*LS).replaceF = (char *)malloc(strlen(_replaceF) + 1);
    if((*LS).replaceF == NULL) return;
    strcpy((*LS).replaceF, _replaceF);
    (*LS).replaceX = (char *)malloc(strlen(_replaceX) + 1);
    if((*LS).replaceX == NULL) return;
    strcpy((*LS).replaceX, _replaceX);
    (*LS).replaceY = (char *)malloc(strlen(_replaceY) + 1);
    if((*LS).replaceY == NULL) return;
    strcpy((*LS).replaceY, _replaceY);
    (*LS).replaceS = (char *)malloc(strlen(_replaceS) + 1);
    if((*LS).replaceS == NULL) return;
    strcpy((*LS).replaceS, _replaceS);
    (*LS).replaceG = (char *)malloc(strlen(_replaceG) + 1);
    if((*LS).replaceG == NULL) return;
    strcpy((*LS).replaceG, _replaceG);
    (*LS).replaceK = (char *)malloc(strlen(_replaceK) + 1);
    if((*LS).replaceK == NULL) return;
    strcpy((*LS).replaceK, _replaceK);
    (*LS).replaceL = (char *)malloc(strlen(_replaceL) + 1);
    if((*LS).replaceL == NULL) return;
    strcpy((*LS).replaceL, _replaceL);
    (*LS).replaceH = (char *)malloc(strlen(_replaceH) + 1);
    if((*LS).replaceH == NULL) return;
    strcpy((*LS).replaceH, _replaceH);
    (*LS).StartX = _StartX;
    (*LS).StartY = _StartY;
    (*LS).depth = _depth;
    (*LS).ruleNumber = _ruleNumber;
    (*LS).angle = _angle;
    (*LS).direct_init = _direct_init;
    (*LS).length = _length;
}

void init(int n)
{
 /*init_L_Sys(&ls[i], "hualei", "Start", "F", "X", "Y", "S", "G", "K", "L", "H",
        pStartX, pStartY, depth, ruleNumber, angle, direct_init, length);          */
    switch(n) {
    case 0:
        init_L_Sys(&ls[0], "xiecao", "G", "F-XF", "", "", "",
            "GFX[+++++GFG][-----GFG]", "", "", "", 340, 20, 6, 2, -3, 60, 3.3);
        break;
    case 1:
        init_L_Sys(&ls[1], "shusan", "X", "FF", "--FXF++FXF++FXF--", "", "",
            "", "", "", "", 200, 50, 6, 2, -60, 0, 6);
        break;
    case 2:
        init_L_Sys(&ls[2], "hualei", "F", "F[+F[+F][-F]F][-F[+F][-F]F]F[+F][-F]F",
         "", "", "", "", "", "", "", 200, 20, 5, 1, 30, 90, 6);
        break;
    case 3:
        init_L_Sys(&ls[3], "shuzhi", "K", "", "", "", "[+++G][---H]FFS",
        "G+G[-FH]F", "FSF", "", "-H[+FG]F",
        200, 210, 13, 4, -18, -90, 9.5);
        break;
    case 4:
        init_L_Sys(&ls[4], "shuzhi", "F", "F[+F]F[-F]F", "", "", "",
        "", "", "", "",
        200, 5, 6, 1, -25.7341, 90, 1.5);
        break;
    case 5:
        init_L_Sys(&ls[5], "korch", "F", "F[+F]F[-F]F", "", "", "",
        "", "", "", "",
        200, 5, 6, 1, -25.7341, 90, 1.5);
        break;    
    case 6:
        init_L_Sys(&ls[6], "pugongying", "Y", "", "X[-FFF][+FFF]FX",
        "YFX[+Y][-Y]", "", "", "", "", "",
        200, 10, 10, 2, 30, 90, 0.37);
        break;    
    case 7:
        init_L_Sys(&ls[7], "guanmucong", "F", "FF-[-F+F+F]+[+F-F-F]", "", "",
         "", "", "", "", "",
        250, 20, 6, 1, -30, 90, 3.5);
        break;    

    case 8:
        init_L_Sys(&ls[8], "kaihuadecao", "G", "", "XFX", "", "",
        "[+FGF][-FGF]XG", "", "", "",
        200, 10, 8, 2, -30, 90, 3);
        break;
    case 9:
        init_L_Sys(&ls[9], "guanmucong2", "F",
        "F[+++++++++++++++++++++++++F]-F[-------------------------F]F", "", "",
        "", "", "", "", "",
        370, 30, 6, 1, -1.2, 90, 2);
        break;
    case 10:
        init_L_Sys(&ls[10], "yangliu", "F", "FF+[+F-F-F]-[-F+F+F]", "", "",
        "", "", "", "", "", 170, 0, 5, 1, -22.5, 90, 7);
        break;
    case 11:
        init_L_Sys(&ls[11], "Juliet", "X", "", "X+YF+", "-FX-Y", "", "", "", "", "",
        95, 250, 17, 2, 90, 0, 1);
    case 12:
        init_L_Sys(&ls[12], "zhuanqiang", "X", "", "XFYFX+F+YFXFY-F-XFYF",
         "YFXFY-F-XFYFX+F+YFXFY", "", "", "", "", "",
        30, 40, 4, 2, 90, 0, 13);
        break;
    case 13:
        init_L_Sys(&ls[13], "zhuanqiang_X", "F+F+F+F", "F+F-F-FF+F+F-F", "",
         "", "", "", "", "", "",
        80, 90, 4, 1, 90, 0, 3.5);
        break;
    case 14:
        init_L_Sys(&ls[14], "sanjiaoraosanjiao", "X", "FFF", "--FXF++FXF++FXF--",
         "", "", "", "", "", "",
        200, 10, 6, 2, -60, 0, 1.7);
        break;
    case 15:
        init_L_Sys(&ls[15], "yibimigong", "X", "", "-YF+XFX+FY-", "+XF-YFY-FX+",
         "", "", "", "", "",
        50, 30, 6, 2, -90, 0, 10);
    case 16:
        init_L_Sys(&ls[16], "shu", "X", "FF", "F[+X]F[-X]+X", "", "", "", "", "", "",
        200, 10, 10, 2, 30, 90, 0.35);
    case 17:
        init_L_Sys(&ls[17], "duichengdeshu", "X", "FF", "F[+X][-X]FX", "", "",
        "", "", "", "",
        200, 10, 10, 2, 30, 90, 0.35);
        break;
    default:
        break;
    }
    return;

}

void freeMemory(L_Sys *LS)  /* 释放内存 */
{
    free((*LS).name);
    (*LS).name = NULL;
    free((*LS).startStr);
    (*LS).startStr = NULL;
    free((*LS).replaceF);
    (*LS).replaceF = NULL;
    free((*LS).replaceX);
    (*LS).replaceX = NULL;
    free((*LS).replaceY);
    (*LS).replaceY = NULL;
    free((*LS).replaceS);
    (*LS).replaceS = NULL;
    free((*LS).replaceG);
    (*LS).replaceG = NULL;
    free((*LS).replaceK);
    (*LS).replaceK = NULL;
    free((*LS).replaceL);
    (*LS).replaceL = NULL;
    free((*LS).replaceH);
    (*LS).replaceH = NULL;
}

void fileCopy(FILE *dest, FILE *src) /* 复制文件函数 */
{
    char ch;
    fseek(src, 0, SEEK_SET);
    ch = fgetc(src);
    while(ch != EOF) {
        fputc(ch, dest);
        ch = fgetc(src);
    }
}

void fractal(int curr_string)  /* 核心功能函数 */
{
    int i, j, k, size, depth, len;
    char a[2], ch;
    double Delta;
    FILE *result, *tmp;
    point stack[stacksize];
    point *p;
    point bef, aft;

    tmp = fopen("B.txt","w+");
    if(tmp == NULL) return;
    init(curr_string);
    p = stack;
    fputs(ls[curr_string].startStr, tmp);
    depth = ls[curr_string].depth;
    len =  ls[curr_string].length;
    for(i = 0; i < depth; i++) {
        result = fopen("A.txt","w+");
        if(result == NULL) return;

        fseek(tmp, 0, SEEK_SET);
        ch = fgetc(tmp);
        while(ch != EOF) {      /* F X Y S G K L H*/
            if(ch == 'F') {
                fputs(ls[curr_string].replaceF, result);
            } else if (ch == 'X') {
                fputs(ls[curr_string].replaceX, result);
            } else if (ch == 'Y') {
                fputs(ls[curr_string].replaceY, result);
            } else if (ch == 'S') {
                fputs(ls[curr_string].replaceS, result);
            } else if (ch == 'G') {
                fputs(ls[curr_string].replaceG, result);
            } else if (ch == 'K') {
                fputs(ls[curr_string].replaceK, result);
            } else if (ch == 'L') {
                fputs(ls[curr_string].replaceL, result);
            } else if (ch == 'H') {
                fputs(ls[curr_string].replaceH, result);
            } else {
                fputc(ch, result);
            }
            ch = fgetc(tmp);
        }
       fseek(tmp, 0, SEEK_SET);
       fileCopy(tmp, result);
       fclose(result);
    }
    bef.x = ls[curr_string].StartX;
    bef.y = ls[curr_string].StartY;

    bef.delta = PI * (ls[curr_string].angle)/180;
    Delta = PI * (ls[curr_string].angle)/180;   /* 转换为弧度制 */

    result = fopen("A.txt","r");
    fseek(result, 0, SEEK_SET);
    ch = fgetc(result);
    while(ch != EOF) {

        switch(ch) {
        case 'F':
        case 'X':
        case 'Y':
        case 'S':
        case 'G':
        case 'K':
        case 'L':
        case 'H':
            aft.x = bef.x + len * cos(bef.delta);
            aft.y = bef.y - len * sin(bef.delta);
            aft.delta = bef.delta;
            line(bef.x, 400 - bef.y, aft.x, 400 - aft.y);

            bef.x = aft.x;
            bef.y = aft.y;
            bef.delta = aft.delta;
            break;
        case '+':
            bef.delta += Delta;
            break;
        case '-':
            bef.delta -= Delta;
            break;
        case '[':
            *(p++) = bef;
            break;
        case ']':
            bef = *(--p);
            break;
        default:
            break;
        }
        ch = fgetc(result);
    }
    fclose(tmp);
    fclose(result);
    freeMemory(&ls[curr_string]);
}

int main(void)
{
    char ch;
    int n, gdriver = DETECT, gmode;
    wu:
    printf("xiecao:0  shusan:1  hualei:2  shuzhi1:3  shuzhi2:4\n");   /* 说明 */
    printf("korch:5  pugongying:6  guanmucong:7  kaihuadecao:8  guanmucong2:9\n");
    printf("yangliu:10  Juliet:11  zhuanqiang:12  zhuanqiang_X:13  sanjiaoraosanjiao:14\n");
    printf("yibimigong:15  shu:16  duichengdeshu:17\n");
    printf("guanmucong2:9\n");
    printf("continue?(Y/N)\n");
    ch = getchar();
    if(ch == 'n' || ch == 'N')
        return 0;
    else {
        printf("please input a non-negative number to choose which image you what to see(0 <= n <= 17 ): ");
        scanf("%d", &n);

        initgraph(&gdriver, &gmode,"C:\\Win-TC\\BGI");  /*图形系统初始化*/
        setcolor(GREEN);  /* 设置画笔的颜色 */
        fractal(n);
        getch();
        closegraph();  /*关闭图形系统*/
        getchar();
        goto wu;
    }
    return 0;
}
ryan_jianjian
关注
  • 4
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
fractal-noise-js:分形噪声函数
05-14
分形噪声 分形噪声函数旨在与任何噪声生成算法一起使用。 Deno模块： ://deno.land/x/fractal_noise NPM包装： 例子 这些图像都是使用width: 888且height: 111值噪声生成的。 makeCylinderSurface ( width , height , valueNoise3D , { frequency : 0.04 , octaves : 2 } ) makeCylinderSurface ( width , height , valueNoise3D , { frequency : 0.06 , octaves : 8 } ) makeLine ( width , valueNoise1D ) // (Replicated across y-axis) makeLine ( height , valueNoise1D ,
经典的分形算法
热门推荐
栖客
11-13 1万+
转载自：http://www.douban.com/note/230496472/ 被誉为大自然的几何学的分形（Fractal）理论，是现代数学的一个新分支，但其本质却是一种新的世界观和方法论。它与动力系统的混沌理论交叉结合，相辅相成。它承认世界的局部可能在一定条件下，在某一方面（形态，结构，信息，功能，时间，能量等）表现出与整体的相似性，它承认空间维数的变化既可以是离散的也可以是连续的，因而拓
计算机图形学--分形算法
12-13
东南大学 计算机图形学 作业一 分形算法，opengl实现！！
分形算法 分形树 很炫的
03-21
用VC实现的树的分形算法，从树开始生长到落叶
分形算法与程序设计——Visual Basic实现.rar
08-14
分形算法与程序设计——Visual Basic实现
code_分形算法_分型代码_
09-29
写了一些分型的代码，包括树形、星形等，还包括图案
分形几何算法和实现(C语言)
weixin_33995481的博客
11-20 1387
初识分形 1、分形的含义： 英文单词Fractal，它是由美籍法国数学家曼德勃罗（Benoit Mandelbrot）创造出来的。其含义是不规则的、破碎的、分数的。曼德勃罗是想用此词来描述自然界中传统欧几里得几何学所不能描述的一大类复杂无规的几何对象。 2、分形的几何特征： 自相似性：自相似，便是局部与整体的相似。 自仿射性：自仿射性是自相似性的一种拓展。如果，将自相似性看成是局部到整体...
绘制谢尔宾斯基三角形
m0_62599633的博客
06-18 546
import turtle import math turtle.speed(100) ''' 通过连接 3 个点的方式绘制三角形 pos是元组的元组((x1,y1),(x2,y2),(x3,y3)) ''' def draw\_triangle(pos): turtle.penup() # 移到第一个点 turtle.goto(pos[0]) turtle.pendown() # 连接 3 个点 for i in [1, ...
Python海龟绘图——分形、递归与递归算法(上)
hz_zhangrl的博客
06-01 2077
本篇介绍了分形概念、分形理论，递归与递归算法，用分形和递归函数，用Python的turtle绘制分形曲线：包括多阶科赫(Koch)曲线，科赫(Koch)雪花。用Python的turtle绘制分形树：简单的分形二叉树，并进行树干、树枝粗细变化，使分形树更像树的“树干、树枝粗细变化的分形二叉树”，但仍因为分形的自相似性而完全对称，比较呆板。 扰动，那就更像自然的树。
分形算法小记
weixin_34297704的博客
12-09 309
2019独角兽企业重金招聘Python工程师标准>>> ...
图像分割分形算法
08-11
图像分割算法--分形算法，包括完整的matlab代码，以及包含代码的算法的相关论文。以及用于测试的图像
分形算法：Self-similarity of complex networks
05-26
分型算法 Self-similarity of complex networks Nature 443
opengl L系统递归算法实现分形树
12-18
opengl，L系统递归算法实现分形树,一个不错的例子，可以作为初学者参考使用
opengl 做的很漂亮的一棵树，用分形算法实现 含代码
11-05
opengl 做的很漂亮的一棵树，用分形算法实现 含代码
分形维数结构算法
03-27
用来区别盒维数法，属于一个新的分形维数算法，专门用来处理一维随机时间序列，该方法依托动力学结构特征，比盒维数法的计算精度高，具有很强的应用性。
sontroo.rar_分形几何_列文森杜宾_列文森算法
07-14
列文森-杜宾算法,用于语音的线性预测控制中,也可以用于谱包络,,
ijua050.rar_分形几何_蚁群算法_鲁棒优化
07-14
此蚁群算法专门用于求解tsp问题,优化效率和鲁棒性都非常好,,
mdtlabtheoryspinoff.zip_matlab 图论_分形几何
07-15
公司分拆问题 聚类算法与图论算法 matlab 的实现,不错的
serial__fitdl.rar_分形几何
07-15
求解函数最大值的遗传算法Matlab源代码 不错的 很好
matlab分形几何书籍
最新发布
08-27
关于Matlab分形几何方面的书籍，我推荐以下几本： 1. 《Matlab分形几何及其应用》 作者：颜先明 这本书详细介绍了Matlab编程语言以及分形几何的基本概念和原理，包括分形维度、分形生成算法以及分形图形的应用等。书中通过大量的实例和案例，展示了如何使用Matlab来实现分形几何的算法，并通过图形界面进行可视化展示。 2. 《Matlab分形几何实例精讲》 作者：徐琴 该书主要包括了常见的分形几何图形的生成算法和实现方法，同时介绍了Matlab的基本语法和编程技巧。书中所涉及的内容包括分形树、分形曲线、分形图像等，每个章节均有详细的Matlab代码和效果图，读者可以通过实践进行学习和理解。 3. 《现代分形几何导论》 作者：萨沃洛夫 这本书是比较全面的分形几何方面的教材，其中讲述了基本的分形几何概念和原理，以及分形维度、分形生成算法、分形函数等内容。虽然没有专门介绍Matlab编程，但书中的理论部分可以帮助我们更好地理解分形几何的基本概念，为在Matlab中实现分形算法打下基础。 这些书籍对于想了解和学习Matlab分形几何的人来说都是不错的选择，通过阅读和实践，可以帮助读者理解分形几何的基本概念和算法，并掌握在Matlab中实现分形图形的方法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值