`
白井黒子
  • 浏览: 4264 次
  • 性别: Icon_minigender_2
最近访客 更多访客>>
lymzyc
社区版块
存档分类
最新评论

Julia 集合。

cjulia 
阅读更多
前一篇说了 Mandelbrot 集合，与之类似。
下面做了个示例，附件内有 vc6 工程。 



#include <windows.h>
#include <tchar.h>

#define JULIA_ITER 2000

#define JULIA_COLORS 128

#define JULIA_VW 400
#define JULIA_VH 300 // JULIA_VW * .75

#define JULIA_CW JULIA_VW / 2
#define JULIA_CH JULIA_VH / 2

#define JULIA_L -2.50
#define JULIA_T +1.35

#define JULIA_W +3.60
#define JULIA_H -2.70

typedef struct {
	double r;
	double i;
} complex;

typedef struct {
	void *hwnd;
	int l;
	int t;
	int r;
	int b;
	RECT rect;
} region;

struct {
	struct {
		void *himg;
		void *pixs;
		int w;
		int h;
	} simg;
	int iter;
	double setx;
	double sety;
	double setw;
	double seth;
	int cunt;
	complex lamd;
	unsigned int (__stdcall *proc)(void*);
} sdata;

struct {
	int x;
	int y;
	double w;
	double h;
	int move;
} scoor;

unsigned int palet[] = {
	0xff000086, 0xff01018c, 0xff040491, 0xff070797, 0xff0c0c9c, 0xff1212a1, 0xff1919a7, 0xff2020ac,
	0xff2929b1, 0xff3333b6, 0xff3d3dbb, 0xff4747bf, 0xff5252c4, 0xff5e5ec8, 0xff6a6acc, 0xff7676d1,
	0xff8181d4, 0xff8d8dd8, 0xff9999dc, 0xffa5a5df, 0xffb0b0e2, 0xffbbbbe5, 0xffc5c5e8, 0xffcfcfea,
	0xffd8d8ec, 0xffe1e1ee, 0xffe8e8f0, 0xffefeff2, 0xfff5f5f3, 0xfffafaf4, 0xfffdfdf5, 0xfffffff5,
	0xfffffff5, 0xfffffff4, 0xfffffff2, 0xfffffeee, 0xfffffee9, 0xfffffde4, 0xfffffcdd, 0xfffffcd6,
	0xffffface, 0xfffff9c4, 0xfffff8bb, 0xfffff6b0, 0xfffff5a6, 0xfffff39b, 0xfffff190, 0xffffef84,
	0xffffed79, 0xffffeb6d, 0xffffe862, 0xffffe557, 0xffffe34c, 0xffffe041, 0xffffdc37, 0xffffd92e,
	0xffffd625, 0xffffd21d, 0xffffce16, 0xffffca0f, 0xffffc60a, 0xffffc205, 0xffffbd02, 0xffffb900,
	0xffffb400, 0xffffaf00, 0xfffea900, 0xfffea400, 0xfffd9d00, 0xfffc9700, 0xfffb9000, 0xfff98900,
	0xfff88200, 0xfff67a00, 0xfff47300, 0xfff16b00, 0xffef6400, 0xffec5c00, 0xffe95500, 0xffe64d00,
	0xffe34600, 0xffe03f00, 0xffdc3800, 0xffd93100, 0xffd52b00, 0xffd12400, 0xffcd1f00, 0xffc81900,
	0xffc41400, 0xffbf0f00, 0xffba0b00, 0xffb60800, 0xffb00500, 0xffab0300, 0xffa60100, 0xffa10000,
	0xff9b0000, 0xff950000, 0xff8f0001, 0xff890002, 0xff830004, 0xff7d0006, 0xff760008, 0xff70000a,
	0xff69000d, 0xff630010, 0xff5c0014, 0xff560017, 0xff4f001b, 0xff49001f, 0xff430024, 0xff3d0028,
	0xff37002d, 0xff310032, 0xff2b0037, 0xff26003c, 0xff210042, 0xff1c0047, 0xff17004d, 0xff130052,
	0xff0f0058, 0xff0c005e, 0xff090063, 0xff060069, 0xff04006f, 0xff020075, 0xff01007b, 0xff000080,
};

unsigned int templ[] = { WS_MINIMIZEBOX | WS_SYSMENU, WS_EX_DLGMODALFRAME, 0, 0, 0, 0, };

__declspec(naked) double __cdecl sqrt(double x) {
	__asm fld	qword ptr [esp+4]
	__asm fsqrt
	__asm ret
}

double complex_abs(complex *a) {
	return sqrt(a->r * a->r + a->i * a->i);
}

void complex_sub(complex *a, complex *b, complex *o) {
	o->i = a->i - b->i;
	o->r = a->r - b->r;
}

void complex_mul(complex *a, complex *b, complex *o) {
	double r = a->r * b->r - a->i * b->i;

	o->i = a->i * b->r + a->r * b->i;
	o->r = r;
}

unsigned int __stdcall julia_thread_proc(region *rptr) {
	int x, y, i;
	complex c, z, t;
	unsigned char *pixs;
	void *hwnd = rptr->hwnd;

	c.r = -.9;
	c.i = +.0;

	t.r = sdata.setx;
	t.i = sdata.sety;

	complex_mul(&c, &t, &c);

	for (y = rptr->t; y < rptr->b; ++y) {
		pixs = (unsigned char*)sdata.simg.pixs + y * sdata.simg.w + rptr->l;

		for (x = rptr->l; x < rptr->r; ++x) {
			i = 0;

			z.r = (x - sdata.lamd.r / sdata.setw) / (sdata.simg.w / sdata.setw / 4.0);
			z.i = (y - sdata.lamd.i / sdata.seth) / (sdata.simg.h / sdata.seth / 3.0);

			while (i++ < sdata.iter - 1 && complex_abs(&z) < 2.0) {
				complex_mul(&z, &z, &z);
				complex_sub(&z, &c, &z);
			}

			*pixs++ = (i == sdata.iter) ? JULIA_COLORS : (i % JULIA_COLORS);
		}

		if (!(y % 20)) InvalidateRect(hwnd, &rptr->rect, 1);
	}

	InvalidateRect(hwnd, 0, 1);

	free(rptr);

	--sdata.cunt;

	return 0;
}

unsigned int __stdcall mandelbrot_thread_proc(region *rptr) {
	int x, y, i;
	complex c, z, t, n;
	unsigned char *pixs;
	void *hwnd = rptr->hwnd;

	n.r = -.9;
	n.i = +.0;

	for (y = rptr->t; y < rptr->b; ++y) {
		pixs = (unsigned char*)sdata.simg.pixs + y * sdata.simg.w + rptr->l;

		for (x = rptr->l; x < rptr->r; ++x) {
			i = 0;

			t.r = sdata.setx + x * (sdata.setw / sdata.simg.w);
			t.i = sdata.sety + y * (sdata.seth / sdata.simg.h);

			complex_mul(&n, &t, &c);

			z.r = .0;
			z.i = .0;

			while (i++ < sdata.iter - 1 && complex_abs(&z) < 2.0) {
				complex_mul(&z, &z, &z);
				complex_sub(&z, &c, &z);
			}

			*pixs++ = (i == sdata.iter) ? JULIA_COLORS : (i % JULIA_COLORS);
		}

		if (!(y % 20)) InvalidateRect(hwnd, &rptr->rect, 1);
	}

	InvalidateRect(hwnd, 0, 1);

	free(rptr);

	--sdata.cunt;

	return 0;
}

void julia_create_image(int w, int h) {
	void *hmdc;
	BITMAPINFO *bmif = calloc(sizeof(char), sizeof(BITMAPINFOHEADER) + sizeof(int) * 256);

	sdata.simg.w = w;
	sdata.simg.h = h;

	bmif->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	bmif->bmiHeader.biWidth = w;
	bmif->bmiHeader.biHeight = -h;
	bmif->bmiHeader.biPlanes = 1;
	bmif->bmiHeader.biBitCount = 8;

	for (w = 0; w < JULIA_COLORS; ++w) *(int*)(bmif->bmiColors + w) = palet[w];

	hmdc = CreateCompatibleDC(0);

	sdata.simg.himg = CreateDIBSection(hmdc, bmif, DIB_RGB_COLORS, &sdata.simg.pixs, 0, 0);

	DeleteDC(hmdc);

	free(bmif);
}

void julia_update(void *hwnd) {
	int x, y;
	double n;
	void *hthr;
	region *rptr;

	n = (double)JULIA_VW / sdata.simg.w;

	for (y = 0; y < sdata.simg.h; y = y + JULIA_CH)
		for (x = 0; x < sdata.simg.w; x = x + JULIA_CW) {
			rptr = calloc(1, sizeof(region));

			rptr->hwnd = hwnd;
			rptr->l = x;
			rptr->t = y;
			rptr->r = JULIA_CW <= sdata.simg.w - x ? x + JULIA_CW : sdata.simg.w;
			rptr->b = JULIA_CH <= sdata.simg.h - y ? y + JULIA_CH : sdata.simg.h;

			SetRect(&rptr->rect, (int)(rptr->l * n), (int)(rptr->t * n), (int)(rptr->r * n), (int)(rptr->b * n));

			hthr = CreateThread(0, 0, sdata.proc, rptr, 0, 0);

			CloseHandle(hthr);

			if (hthr) ++sdata.cunt;
		}
}

void julia_draw_image(void *htdc) {
	void *himg, *hmdc;

	hmdc = CreateCompatibleDC(0);
	himg = SelectObject(hmdc, sdata.simg.himg);

	SetStretchBltMode(htdc, HALFTONE);

	StretchBlt(htdc, 0, 0, JULIA_VW, JULIA_VH, hmdc, 0, 0, sdata.simg.w, sdata.simg.h, SRCCOPY);

	SelectObject(hmdc, himg);

	DeleteDC(hmdc);
}

void julia_rbuttonup(void *hwnd) {
	if (sdata.cunt) return;

	if (scoor.move) return;

	sdata.setx = JULIA_L;
	sdata.sety = JULIA_T;

	sdata.setw = JULIA_W;
	sdata.seth = JULIA_H;

	sdata.iter = 50;
	sdata.proc = mandelbrot_thread_proc;

	julia_update(hwnd);
}

void julia_activate(void *hwnd, int code) {
	if (WA_INACTIVE != code) return;

	SetCapture(0);

	scoor.move = 0;

	InvalidateRect(hwnd, 0, 1);
}

void julia_initdialog(void *hwnd) {
	RECT rect = { 0, 0, JULIA_VW, JULIA_VH, };

	AdjustWindowRect(&rect, WS_CAPTION, 0);
	OffsetRect(&rect, -rect.left, -rect.top);

	MoveWindow(hwnd,
		(GetSystemMetrics(SM_CXSCREEN) - rect.right) / 2,
		(GetSystemMetrics(SM_CYSCREEN) - rect.bottom) / 2, rect.right, rect.bottom, 1);

	julia_create_image(800, 600);
	julia_rbuttonup(hwnd);
}

void julia_lbuttondown(void *hwnd, int x, int y) {
	if (sdata.cunt) return;

	scoor.x = x;
	scoor.y = y;
	scoor.w = .0;
	scoor.h = .0;

	SetCapture(hwnd);

	scoor.move = 1;
}

void julia_lbuttonup(void *hwnd) {
	if (sdata.cunt) return;

	if (!scoor.move) return;

	SetCapture(0);

	scoor.move = 0;

	if (julia_thread_proc == sdata.proc) {
		if (.0 >= scoor.w || .0 >= scoor.h) return;

		sdata.lamd.r = sdata.lamd.r - (scoor.x - scoor.w) * sdata.simg.w / JULIA_VW * sdata.setw;
		sdata.lamd.i = sdata.lamd.i - (scoor.y - scoor.h) * sdata.simg.h / JULIA_VH * sdata.seth;

		sdata.setw = sdata.setw / JULIA_VW * (scoor.w * 2.0);
		sdata.seth = sdata.seth / JULIA_VH * (scoor.h * 2.0);
	} else {
		sdata.setx = JULIA_L + JULIA_W * ((double)scoor.x / JULIA_VW);
		sdata.sety = JULIA_T + JULIA_H * ((double)scoor.y / JULIA_VH);

		sdata.setw = 1.0;
		sdata.seth = 1.0;

		sdata.lamd.r = sdata.simg.w / 2.0;
		sdata.lamd.i = sdata.simg.h / 2.0;

		sdata.iter = JULIA_ITER;
		sdata.proc = julia_thread_proc;
	}

	julia_update(hwnd);
}

void julia_mousemove(void *hwnd, int code, int x, int y) {
	if (!scoor.move) return;

	x = abs(x - scoor.x);
	y = abs(y - scoor.y);

	if (x < y) {
		scoor.w = y / .75;
		scoor.h = y;
	} else {
		scoor.w = x;
		scoor.h = x * .75;
	}

	InvalidateRect(hwnd, 0, 1);
}

void julia_paint(void *hwnd) {
	PAINTSTRUCT ps;
	int l, t, r, b;
	RECT rect = { 0, 0, JULIA_VW, JULIA_VH, };
	void *himg, *hmdc, *hwdc = BeginPaint(hwnd, &ps);

	hmdc = CreateCompatibleDC(0);
	himg = SelectObject(hmdc, CreateCompatibleBitmap(hwdc, JULIA_VW, JULIA_VH));

	FillRect(hmdc, &rect, GetSysColorBrush(COLOR_3DFACE));

	julia_draw_image(hmdc);

	if (scoor.move) {
		l = (int)(scoor.x - scoor.w);
		t = (int)(scoor.y - scoor.h);
		r = (int)(scoor.x + scoor.w);
		b = (int)(scoor.y + scoor.h);

		SetROP2(hmdc, R2_NOT);

		MoveToEx(hmdc, l, t, 0);

		LineTo(hmdc, r, t);
		LineTo(hmdc, r, b);
		LineTo(hmdc, l, b);
		LineTo(hmdc, l, t);
	}

	BitBlt(hwdc, 0, 0, rect.right, rect.bottom, hmdc, 0, 0, SRCCOPY);

	DeleteObject(SelectObject(hmdc, himg));

	DeleteDC(hmdc);

	EndPaint(hwnd, &ps);
}

int __stdcall julia_proc(void *hwnd, unsigned int umsg, unsigned int wprm, long lprm) {
	switch (umsg) {
		case WM_ACTIVATE: julia_activate(hwnd, wprm); break;

		case WM_ERASEBKGND: break;

		case WM_INITDIALOG: julia_initdialog(hwnd); break;

		case WM_LBUTTONDOWN: julia_lbuttondown(hwnd, (short)lprm, lprm >> 16); break;

		case WM_LBUTTONUP: julia_lbuttonup(hwnd); break;

		case WM_MOUSEMOVE: julia_mousemove(hwnd, wprm, (short)lprm, lprm >> 16); break;

		case WM_PAINT: julia_paint(hwnd); break;

		case WM_RBUTTONUP: julia_rbuttonup(hwnd); break;

		case WM_SYSCOMMAND: if (SC_CLOSE == wprm) EndDialog(hwnd, 0); // break;

		default: return 0;
	}

	return 1;
}

void julia() {
	ExitProcess(DialogBoxIndirectParam(GetModuleHandle(0), (void*)templ, 0, julia_proc, 0));
}


  • 大小: 96 KB
  • 大小: 717.5 KB
分享到：
Mandelbrot 集合。
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Julia集合CPU和GPU方法的分析比较.pdf

    Julia 集合 CPU 和 GPU 方法的分析比较 本文对 Julia 集合 CPU 和 GPU 方法进行了分析比较，讨论了这两种方法的实现方式、优缺点和应用场景。 CPU 实现方式 CPU 实现方式是通过一个名为 `kern el` 的函数来实现 ...

    julia分形集的绘制

    **Julia集合与分形** Julia集合是复数领域中的一个数学概念，它在混沌理论和分形几何中占有重要地位。分形是具有自相似性质的几何形状，即使在无限放大后仍然能保持其细节特征。Julia集合是由法国数学家朱利安·...

    Julia曲线 OPENCV

    1. **定义Julia集合**: 首先，需要选择一个复数函数，例如z_{n+1} = z_n^2 + c，其中z_n是当前迭代的复数，c是一个固定的复数值，表示Julia集合的特性。 2. **创建图像矩阵**: 使用OpenCV，可以创建一个二维的灰度...

    ch3_4.julia.rar_Julia C

    描述中提到“Python语言编写的OpenGL程序 julia集合”，表明这个项目可能包含了一个使用Python来实现的OpenGL图形渲染程序，用于绘制Julia集合。标签 "julia_c" 进一步确认了Julia与C的融合是关键点。压缩包中的...

    Mandelbrot集和Julia集的图像绘制

    Mandelbrot集合和Julia集合是分形几何中的两个著名例子，它们在计算机图形学领域有着广泛的应用，尤其在艺术、科学可视化以及数学教育中。这两个集合都是通过复数运算来定义的，并且通常使用迭代算法来生成复杂的、...

    julia,mandelbrot,分形树的matlab程序~

    标题中的“julia, mandelbrot, 分形树的matlab程序”表明这是一个关于使用MATLAB编程实现Julia集合、Mandelbrot集以及分形树的项目。MATLAB是一种广泛使用的数值计算和可视化软件，非常适合进行复杂数学图形的绘制，...

    e语言-易语言Julia集图片

    "易语言Julia集图片"项目是基于易语言实现的一个示例程序，它使用位图操作支持库来绘制Julia集合的图像。Julia集合是复数平面上的一种分形图案，通常由复数迭代函数系统生成，具有丰富的几何结构和无限的细节。 在...

    swift-用Swift绘制漂亮的Julia分形图

    在本篇中，我们将深入探讨如何使用Swift来绘制惊艳的Julia集合分形图。Julia集合是一种复杂的数学概念，它源于复数域中的迭代函数系统，常用于创建视觉上引人入胜的艺术作品。 首先，我们需要了解Julia集合的基本...

    关于mandelbrot集和julia集的bmp图的做法

    Mandelbrot集合和Julia集合是复杂分析领域中的两个著名概念，它们在数学和计算机图形学中都有着广泛的应用。这两个集合是通过迭代复数函数来定义的，它们的美丽和复杂性吸引了无数数学爱好者和艺术家。 Mandelbrot...

    Julia-IFS VC++ 实现（修改 可运行）

    **Julia集合与迭代函数系统（IFS）** Julia集合是一种在复平面上由复数迭代函数生成的分形图形。这些集合通常与混沌理论和动态系统相关联，展现出复杂而美丽的几何结构。它们的名字来源于法国数学家Gaston Julia，...

    c++画分形之Julia集

    **C++绘制分形——Julia集合** 分形是一种在数学和艺术中具有广泛应用的几何形状，它们展现出自相似性和无限细节。其中，Julia集合是复平面上的一个点集，与著名的Mandelbrot集合有密切关系。本文将深入探讨如何...

    Julia曲线绘制demo

    2. 迭代算法：编写一个迭代函数，根据给定的Julia集合参数，对复平面上的每一个点进行迭代计算。 3. 图像像素映射：将复平面上的点与图像的像素对应起来，决定哪些点属于Julia曲线，并赋予相应的颜色。 GPU版本的...

    fenxingjihe.rar_Julia C_分形混沌_分形游戏_混沌

    在本压缩包文件"fenxingjihe.rar"中，包含了一系列与分形几何、混沌理论以及Julia集合相关的编程资源。这些概念都是数学和计算机科学领域的重要知识点，尤其是在图形生成和复杂系统研究方面。 首先，让我们来深入...

    易语言Julia集图片

    在编程实现Julia集的过程中，首先需要理解Julia集合的数学定义：给定一个复数常数c和一个复数函数f(z)=z^2+c，如果对于某个复数z，其在无限次迭代过程中不发散，那么z就属于该Julia集。编程时，我们需要用到二维数组...

    Julia集 IFS 实现 VC++（修改后的可运行）

    标题 "Julia集 IFS 实现 VC++（修改后的可运行）" 提及的是一个使用Visual C++（VC++）编程环境实现的Julia集合（Julia Set）迭代函数系统（IFS）程序。这个程序是基于《分形程序设计》一书第四章中的代码4.02进行的...

    Julia-Mandelbrot-Set

    **Julia集合与Mandelbrot集合** Julia集合与Mandelbrot集合是复数领域中的两个著名数学对象，属于分形几何的范畴。它们是由法国数学家Benoît Mandelbrot在20世纪70年代研究迭代函数系统时发现的。这两个集合的名字...

    毕业设计MATLAB_函数生成Mandelbrot集和Julia集分形.zip

    **Julia集**与此类似，但每个点c对应一个不同的Julia集合。对于固定的复数c，我们迭代函数z(n+1) = z(n)^2 + c，但这次是从任意初始复数z(0)开始。如果这个序列不发散，点z(0)就属于该Julia集。Julia集的形状取决于...

    fractalviewer_source

    在C#编程语言中，我们可以利用其强大的数学计算能力和图形处理库来实现Julia集合和Mandelbrot集合的绘制。"fractalviewer_source"项目正是这样一个专注于展示这两种分形的源代码实现，提供了图形的放大和缩小功能，...

Magicbox
Global site tag (gtag.js) - Google Analytics