OpenGL进阶(七)-康托尔集 谢尔宾斯基地毯 Koch雪花

最新推荐文章于 2021-12-23 15:00:21 发布
最新推荐文章于 2021-12-23 15:00:21 发布
阅读量7.1k 收藏 11
点赞数 2
分类专栏： 计算机图形学 OpenGL进阶
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/silangquan/article/details/8450025
版权

这一篇关于分形图像，当然只是入门。

分形通常被定义为“一个粗糙或零碎的几何形状，可以分成数个部分，且每一部分都（至少近似地）是整体缩小后的形状”，即具有自相似的性质。分形有几种类型，可以分别依据表现出的精确自相似性、半自相似性和统计自相似性来定义。虽然分形是一个数学构造，它们同样可以在自然界中被找到，这使得它们被划入艺术作品的范畴。

之前有做过一个镂垫的程序,今天要做的是康托集，谢尔宾斯基地毯和Koch雪花。

源码下载

一维康托集

       康托尔集是由不断去掉线段的中间三分之一而得出。首先从区间[0, 1]中去掉中间的三分之一(1/3, 2/3)，留下两条线段：[0, 1/3] ∪ [2/3, 1]。然后，把这两条线段的中间三分之一都去掉，留下四条线段：[0, 1/9] ∪ [2/9, 1/3] ∪ [2/3, 7/9] ∪ [8/9, 1]。把这个过程一直进行下去。

      看程序实现：

void cantuo1(GLfloat *a, GLfloat *b)
{
     glBegin(GL_LINES);
    glVertex3fv(a);
    glVertex3fv(b);
    glEnd();
}

void divide_cantuo1(GLfloat *a, GLfloat *b, int m)
{
    cantuo1(a,b);
    GLfloat mid[2][3];
    if(m>0)
       {

        /* compute 1/3points */
        mid[0][0]=a[0]+(b[0]-a[0])/3.0;
        mid[0][1]=(a[1]+b[1])/2.0+0.5;
        mid[0][2]=(a[2]+b[2])/2.0;
        mid[1][0]=b[0]-(b[0]-a[0])/3.0;
        mid[1][1]=(a[1]+b[1])/2.0+0.5;
        mid[1][2]=(a[2]+b[2])/2.0;
        a[1]+=0.5;
        b[1]+=0.5;
        /* create 2 part  by subdivision */
        divide_cantuo1(mid[1],b, m-1);
        divide_cantuo1(a,mid[0], m-1);
    }
}

divide_cantuo1中，首先将ab直线绘制出来，然后计算出1/3和2/3处的点坐标（y方向要移动0.5个单位），然后在分别绘制起点到1/3处和2/3处到终点的曲线。

cantuo1就是画线函数。

渲染出来看一下：

void renderGL()
{
    GLfloat a[2][3]={{-3.0, 0.0, 0.0},{3.0, 0, 0}};
    // Clear the color and depth buffers.
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
    // We don't want to modify the projection matrix. */
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity( );
    // Move down the z-axis.
    glTranslatef( 0.0, -2.0, -5.0 );
    glClear(GL_COLOR_BUFFER_BIT);  /* clear the window */
    glLineWidth(4.0);
    divide_cantuo1(a[0],a[1],5);
    SDL_GL_SwapBuffers( );
}


最后的效果是这样：



谢尔宾斯基地毯

       谢尔宾斯基地毯的构造与谢尔宾斯基三角形相似，区别仅在于谢尔宾斯基地毯是以正方形而非等边三角形为基础的。将一个实心正方形划分为的9个小正方形，去掉中间的小正方形，再对余下的小正方形重复这一操作便能得到谢尔宾斯基地毯。

     看代码：

void cantuo2(GLfloat *a, GLfloat *b,GLfloat *c,GLfloat *d )
{
    static int i=0;
    glBegin(GL_QUADS);
    glColor3fv(colors[i++%4]);
    glVertex3fv(a);
    glVertex3fv(b);
    glVertex3fv(c);
    glVertex3fv(d);
    glEnd();
}

void divide_cantuo2(GLfloat *a, GLfloat *b,GLfloat *c,GLfloat *d,int m)
{
    GLfloat mid[12][3];
    if(m>0)
       {
        // compute 12 points
        mid[0][0]=a[0]+(b[0]-a[0])/3.0;
        mid[0][1]=a[1]+(b[1]-a[1])/3.0;
        mid[0][2]=0.0;

        mid[1][0]=a[0]+2.0*(b[0]-a[0])/3.0;
        mid[1][1]=a[1]+2.0*(b[1]-a[1])/3.0;
        mid[1][2]=0.0;


        mid[2][0]=d[0]+1.0*(a[0]-d[0])/3.0;
        mid[2][1]=d[1]+2.0*(a[1]-d[1])/3.0;
        mid[2][2]=0.0;

        mid[3][0]=a[0]+(b[0]-a[0])/3.0;
        mid[3][1]=d[1]+2.0*(a[1]-d[1])/3.0;
        mid[3][2]=0.0;

        mid[4][0]=a[0]+2.0*(b[0]-a[0])/3.0;
        mid[4][1]=d[1]+2.0*(a[1]-d[1])/3.0;
        mid[4][2]=0.0;

        mid[5][0]=c[0]+2.0*(b[0]-c[0])/3.0;
        mid[5][1]=c[1]+2.0*(a[1]-d[1])/3.0;
        mid[5][2]=0.0;

        mid[6][0]=d[0]+(a[0]-d[0])/3.0;
        mid[6][1]=d[1]+(a[1]-d[1])/3.0;
        mid[6][2]=0.0;

        mid[7][0]=a[0]+(b[0]-a[0])/3.0;
        mid[7][1]=d[1]+(a[1]-d[1])/3.0;
        mid[7][2]=0.0;

        mid[8][0]=a[0]+2.0*(b[0]-a[0])/3.0;
        mid[8][1]=d[1]+(a[1]-d[1])/3.0;
        mid[8][2]=0.0;

        mid[9][0]=c[0]+2.0*(b[0]-c[0])/3.0;
        mid[9][1]=d[1]+(a[1]-d[1])/3.0;
        mid[9][2]=0.0;

        mid[10][0]=a[0]+(b[0]-a[0])/3.0;
        mid[10][1]=d[1]+(c[1]-d[1])/3.0;
        mid[10][2]=0.0;

        mid[11][0]=a[0]+2.0*(b[0]-a[0])/3.0;
        mid[11][1]=d[1]+2.0*(c[1]-d[1])/3.0;
        mid[11][2]=0.0;
        /* create 9 part  by subdivision */
        divide_cantuo2(a,mid[0],mid[3],mid[2], m-1);
        divide_cantuo2(mid[0],mid[1],mid[4],mid[3],m-1);
        divide_cantuo2(mid[1],b,mid[5],mid[4],m-1);
        divide_cantuo2(mid[2],mid[3],mid[7],mid[6],m-1);
        //divide_cantuo2(mid[3],mid[4],mid[8],mid[7],m-1);
        divide_cantuo2(mid[4],mid[5],mid[9],mid[8],m-1);
        divide_cantuo2(mid[6],mid[7],mid[10],d,m-1);
        divide_cantuo2(mid[7],mid[8],mid[11],mid[10],m-1);
        divide_cantuo2(mid[8],mid[9],c,mid[11],m-1);
        printf("m:%d\n",m);
    }
    else
    cantuo2(a,b,c,d);
}

这次divide_cantuo2函数需要找的是12个点，建议在纸上面画一下。

cantuo2就是画矩形。

渲染一下：

void renderGL()
{
    GLfloat a[4][3]={{-3.0, 3.0, 0.0},{3.0, 3.0, 0},{3.0, -3.0, 0.0},{-3.0, -3.0, 0}};
    // Clear the color and depth buffers.
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
    // We don't want to modify the projection matrix. */
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity( );
    // Move down the z-axis.
    glTranslatef( 0.0, 0.0, -6.0 );
    glClear(GL_COLOR_BUFFER_BIT);  /* clear the window */
    divide_cantuo2(a[0],a[1],a[2],a[3],2);
    SDL_GL_SwapBuffers( );
}


当然，可以改变迭代次数和绘制的颜色。




Koch雪花

给定线段AB，科赫曲线可以由以下步骤生成：
将线段分成三等份（AC,CD,DB）
以CD为底，向外（内外随意）画一个等边三角形DMC
将线段CD移去
分别对AC,CM,MD,DB重复1~3。
科赫雪花是以等边三角形三边生成的科赫曲线组成的。。每条科赫曲线的长度是无限大，它是连续而无处可微的曲线。

代码实现：

void Koch(GLfloat *a, GLfloat *b)
{
    static int i=0;
    glBegin(GL_LINES);
    glColor3fv(colors[i++%4]);
    glVertex3fv(a);
    glVertex3fv(b);
    glEnd();
}

void divideKoch(GLfloat *a, GLfloat *b,int m)
{
    float length= sqrt(pow(a[0] - b[0],2) + pow(a[1] - b[1],2))/3;
    printf("length:%f\n",length);
    GLfloat mid[3][3];
    if(m>0)
       {
        // compute 3 points
        mid[0][0]=a[0]+(b[0]-a[0])/3.0;
        mid[0][1]=a[1]+(b[1]-a[1])/3.0;
        mid[0][2]=0.0;

        mid[1][0]=b[0]-(b[0]-a[0])/3.0;
        mid[1][1]=b[1]-(b[1]-a[1])/3.0;
        mid[1][2]=0.0;
        double alpha = 0.0;
        if (b[1]>= a[1])
		{
			alpha = atan((double) (b[1]-a[1]) / (b[0]-a[0]));
			if (b[0]>a[0])
			{
				mid[2][0] = mid[0][0] + length * cos(alpha + PI / 3);
				mid[2][1] = mid[0][1] + length  * sin(alpha + PI / 3);
			}
			else
			{
				mid[2][0] = mid[0][0] - length * cos(alpha + PI / 3);
				mid[2][1] = mid[0][1] - length * sin(alpha + PI / 3);
			}
		}
		else
		{
			alpha = atan((double) (a[1] - b[1]) / (b[0] - a[0]) );
			if (b[0]>a[0])
			{
				mid[2][0] = mid[1][0] - length * cos(alpha + PI / 3);
				mid[2][1] = mid[1][1] + length * sin(alpha + PI / 3);
			}
			else
			{
				mid[2][0] = mid[1][0] + length * cos(alpha + PI / 3);
				mid[2][1] = mid[1][1] - length * sin(alpha + PI / 3);
			}
		}

        /* create 9 part  by subdivision */
        divideKoch(a,mid[0], m-1);
        divideKoch(mid[0],mid[2],m-1);
        divideKoch(mid[2],mid[1],m-1);
        divideKoch(mid[1],b,m-1);
        printf("m:%d\n",m);
    }
    else
    Koch(a,b);
}

divideKoch只是对一条直线进行分形。思路就是找到线的1/3，2/3处点的坐标，还有中间生成的等边三角形的一个顶点，然后对生成的每一条边都进行迭代。

渲染一个雪花：

void renderGL()
{
    //Define a triangle in space
    GLfloat a[3][3]={{-3.0, 0.0, 0.0},{3.0, 0.0, 0},{0.0, 5.196, 0.0}};
    // Clear the color and depth buffers.
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
    // We don't want to modify the projection matrix. */
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity( );
    // Move down the z-axis.
    glTranslatef( 0.0, -2.0, -9.0 );
    glClear(GL_COLOR_BUFFER_BIT);  /* clear the window */
    //Koch(a[0],a[1]);
    divideKoch(a[1],a[0],6);
    divideKoch(a[2],a[1],6);
    divideKoch(a[0],a[2],6);
    SDL_GL_SwapBuffers( );
}

结果：



关于分形，这里只是一个很小很小的开始，还有很多的分形图像比如门格海绵，分形地形，分形云彩等等。可以参考：http://zh.wikipedia.org/wiki/%E5%88%86%E5%BD%A2

拳四郎
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Koch雪花算法：绘制美丽的科赫雪花
HackLogic的博客
09-07 133
Koch雪花算法是一种迷人的算法，可以绘制出美丽而复杂的分形图形。在本文中，我们使用Java编程语言实现了Koch雪花算法，并通过递归调用绘制出了令人惊叹的科赫雪花。通过调整级别和参数，你可以探索不同形状和大小的科赫雪花。在本文中，我们将使用Java编程语言来实现Koch雪花算法，并绘制出令人惊叹的科赫雪花。算法的基本思想是将线段分成三个相等长度的部分，然后以中间部分为底边，构造一个等边三角形。变量的值，你可以控制雪花的级别。级别越高，绘制的雪花越复杂。方法连接三个子雪花的顶点，完成整个雪花的绘制。
[OpenGL] 动态积雪效果
(ง •̀_•́)ง
04-10 2900
默认 动态生成积雪 对于游戏中模拟雪天而言，除了天上飘落的雪花外，我们通常还希望能够在一个现成的场景地图上，生成场景物体被积雪覆盖的效果。让美术为每个场景物件单独做雪效果的材质可以得到比较细腻的效果，但这会成倍地增加美术制作成本。一个比较的常见的思路是，直接将雪的贴图从上往下“叠加”到场景物体上，通过这样的方式，就能快速地让场景中的物体都被雪覆盖。 ...
OpenGL画一个雪花
YuTsingLeen
11-10 2546
void display(void) { //这是我们自己的绘图函数，我们在这里进行具体地绘制。 } int main(int argc, char** argv)//main函数 { glutInit(&argc, argv); //对GLUT进行初始化,必须一开始就初始化 glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE); //设置显示方式，参数之后再解释 glutInitWindowPosition(100, 100
一个3D下雪 效果
weixin_30426879的博客
05-01 175
http://2354919152419616925-a-1802744773732722657-s-sites.googlegroups.com/site/chinachenaa/3d/dandelion3d.swf?attredirects=0&auth=ANoY7co200-aTq4U_qMh7K4Ourbrw_Duga69cTNqXl0Y2zDArs8kd1YjuSIuYxM6...
opengl 雪花代码
10-28
使用基本语言绘制出炫酷的雪花~ 效果好看，代码易读
OpenGL 分形入门
12-29
在"Contuo2"、"Contuo"和"Koch"这些文件中，很可能是包含了使用OpenGL实现的康托集和Koch雪花的示例代码或者相关教程。通过学习这些示例，你可以更好地理解如何利用OpenGL来创建和展示分形图形，同时也可以深入了解...
谢尔宾斯基海绵：生成谢尔宾斯基海绵。-matlab开发
06-01
谢尔宾斯基地毯是康托尔套装的二维版本，从一个正方形开始。 正方形被分成九个大小相等的正方形，中间的正方形在第一次迭代时被移除。 然后剩下的八个方格各分成九个方格，中间的方格再次被移除以进行第二次迭代。 ...
Menger-Sponge
03-31
Menger-Sponge
无需选择公理的康托尔-伯恩斯坦-施罗德定理Coq的形式证明
03-02
无需选择公理的康托尔-伯恩斯坦-施罗德定理Coq的形式证明
2009-2017试卷及答案合集1
08-03
11. 一致连续性和一致收敛：( )f x 在[0,) 上一致连续，随着n的增加，()0f xn，证明函数序列的一致收敛性，需要用到一致连续性和康托尔-魏尔斯特拉斯定理。 12. 填空题：包括二重积分的计算、函数的性质、切...
雪花——OpenGL
12-08
OpenGL编程示例，制作雪花飘落效果，有键盘和鼠标控制。
中国电子学会图形化四级编程题：绘制雪花
老马的程序人生
10-16 2040
「青少年编程竞赛交流群」已成立（适合6至18周岁的青少年），公众号后台回复【Scratch】或【Python】，即可进入。如果加入了之前的社群不需要重复加入。 我们将有关编程题目的教学视频已经发布到抖音号21252972100，小马老师上，大家可以关注一下。 绘制雪花 观察下边的图形，编写程序把它画出来（45°的标注是提示，不用绘制）。 1. 准备工作 （1）隐藏小猫角色； （2）白色背景； 2. 功能实现 用画笔相关积木绘制雪花，注意不得使用图章。雪花枝干和枝桠的边长、画笔的粗细没有限制，但要画出如.
递归科赫雪花
m0_55946825的博客
12-23 467
逐行分析一下科赫雪花 import turtle def koch(size, n): #定义一个函数，（参数，变量） if n==0: #条件分支， turtle.fd(size) #当n=0时，执行画笔向前移动size距离。 else: #n!0时， for angle in [0,60,-120,60]..
C语言实现康托尔集cantor set(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
02-26 1383
C语言实现最大堆max_heap康托尔集 _cantor_set结构体实现了以下几个接口康托尔集cantor set完整源码（定义，实现，main函数测试） 康托尔集 _cantor_set结构体 typedef struct _cantor_set { double start; /**< start of interval */ double end; /**< end of interval */ struct _
【OpenGL】Shader实例分析（七）- 雪花飘落效果
weixin_33895475的博客
05-11 516
转发请保持地址：http://blog.csdn.net/stalendp/article/details/40624603 研究了一个雪花飘落效果。感觉挺不错的。分享给大家，效果例如以下： 代码例如以下： Shader "shadertoy/Flakes" { // https://www.shadertoy.com/view/4d2Xzc Properties...
分形与混沌（一）
ric1988210的博客
11-11 7088
分形与混沌（一） 分形概述 分形（英语：fractal，源自拉丁语：frāctus，有“零碎”、“破裂”之意），又称碎形、残形，通常被定义为“一个粗糙或零碎的几何形状，可以分成数个部分，且每一部分都（至少近似地）是整体缩小后的形状”即具有自相似的性质。 分形在数学中是一种抽象的物体，用于描述自然界中存在的事物。而人工实现的分形通常在放大后能展现出相似的形状，因此分形也被称为扩展对称或展开对称。如果...
雪花分形图(递归算法)
proTiger的专栏
04-08 8077
很奇妙的分形图,佩服作者的想象力,我是在理解的基础上借鉴,Button做的很烂,呵呵!很喜欢递归算法,我一定要原创一个给你们看看! //KochSnowflake.javaimport java.awt.*;import java.awt.event.*;import javax.swing.*;public class KochSnowflake extends JApplet im
matlab康托尔集
最新发布
04-14
康托尔集是数学中的一个经典例子，它是一种具有非常特殊性质的集合。康托尔集最早由德国数学家Georg Cantor于1874年提出，被认为是无限集合中最简单和最基本的例子之一。 康托尔集的定义是通过迭代的方式构造的。首先，我们从一个单位区间[0, 1]开始。然后，将该区间分成三等分，去掉中间的1/3部分，得到两个子区间[0, 1/3]和[2/3, 1]。接下来，对每个子区间再进行同样的操作，即将其分成三等分，去掉中间的1/3部分。如此反复进行下去，我们可以得到康托尔集。 康托尔集具有以下特点： 1. 康托尔集是一个闭集，即包含了所有的端点。 2. 康托尔集是无限集合，其中的元素个数与实数集一样多。 3. 康托尔集是不可数的，即无法与自然数集一一对应。 4. 康托尔集是完全不连通的，即其中任意两点之间都存在至少一个间隙。 康托尔集在数学和计算机科学中有广泛的应用，例如在拓扑学、测度论、分形几何等领域。在MATLAB中，可以使用迭代的方式生成康托尔集，并进行可视化展示。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值