给女神画一张一笔肖像画！

草祭祀

小草觊觎女神已久，一直想给女神送一份精致的创意礼物。
于是灵光一现，决定要做一张一笔肖像画！
待处理图片：

先扔掉颜色信息黑白化：

1. IplImage* origin0=cvLoadImage("pp.jpg",0);
   
2. cvSaveImage("D:\\gray.jpg", origin0);

复制代码

直接载入一张黑白图片就可以了。
然后我们对图片进行摆动矩阵二值化：

1. double ratio=origin0->width>origin0->height?origin0->width/(double)(1<<(bits-2)):origin0->height/(double)(1<<(bits-2));
   
2.         IplImage* origin=cvCreateImage(cvSize(origin0->width/ratio,origin0->height/ratio),8,1);
   
3.         cvResize(origin0,origin);
   
4.         IplImage* tempi=cvCloneImage(origin);
   
5.         IplImage* tempi2=cvCloneImage(origin);
   
6.         int c=3;
   
7.         double gray=256/(double)(1<<(2*c));
   
8.         for (int x=0;x<origin->width;x++)
   
9.         {
   
10.                 for (int y=0;y<origin->height;y++)
    
11.                 {
    
12.                         unsigned char g=origin->imageData[y*origin->widthStep+x];
    
13.                         tempi->imageData[y*tempi->widthStep+x]=g/gray>ditherMatrix(x%(1<<(c-1)),y%(1<<(c-1)),c-1)?(char)(unsigned char)255:(char)(unsigned char)0;
    
14.                 }
    
15.         }

复制代码

什么叫做摆动矩阵呢，简单说就是一种打印时候用的二值化算法。一些打印机的颜色是由色点的密度组成的，白点越密，就看上去越亮，黑点越密，看上去越暗。
摆动矩阵代码：

1. int dither[4]={0,2,3,1};
   
2. int ditherMatrix(unsigned int x,unsigned int y,int c)
   
3. {
   
4.         if(c>0)
   
5.                 return 4*ditherMatrix(x,y,c-1)+dither[(x>>(c))%2+(y>>(c))%2*2];
   
6.         else
   
7.                 return dither[(x>>(c))%2+(y>>(c))%2*2];
   
8. }

复制代码

摆动矩阵使用的一种自相似的矩阵结构，要处理的图像每个像素的灰度如果大于摆动矩阵对应的值，则输出白点，如果小于则输出黑点。
一阶阵只有四个数字。
0 3
2 1
二阶阵有16个。
0 12 3 15
8 4 11 7
2 14 1 13
10 6 9 5
二阶阵是在一阶阵边长扩展一倍之后，四角的四方块加上一阶阵的四倍。
三阶阵就有64个了，以此类推。
  0  96  24 120   6 102  30 126
64  32  88  56  70  38  94  62
16 112   8 104  22 118  14 110
80  48  72  40  86  54  78  46
  4 100  28 124   2  98  26 122
68  36  92  60  66  34  90  58
20 116  12 108  18 114  10 106
84  52  76  44  82  50  74  42
三阶阵四角每4*4的块是由二阶阵加常数得到的的。
摆动矩阵尽可能利用黑和白两种颜色还原了图像的亮感和边缘，阶数小的时候，还原边缘比较锋利，阶数大的时候，还原亮感比较好。
一般取3阶或者4阶。

下面我要开始介绍希尔伯特曲线了。
希尔伯特曲线是一种分形曲线，可以一条线遍历一个空间。、

生成希尔伯特曲线：

1. 
   
2. CvPoint2D32f hil[4]={cvPoint2D32f(-0.5,-0.5),cvPoint2D32f(-0.5,0.5),cvPoint2D32f(0.5,0.5),cvPoint2D32f(0.5,-0.5)};
   
3. vector<CvPoint> vP;
   
4. 
   
5. void hilbert(IplImage* img,CvPoint c,int order,int character,bool z)
   
6. {
   
7.         if(order==2)
   
8.         {
   
9.                 vP.push_back(cvPoint(c.x,c.y));
   
10.         }
    
11.         else
    
12.         {
    
13.                 if(order==4)
    
14.                 {
    
15.                         int x=c.x/order+img->width/2;
    
16.                         int y=c.y/order+img->height/2;
    
17.                         if(x>=0&&x<img->width&&y>=0&&y<img->height)
    
18.                         {
    
19.                                 if(img->imageData[(int)(y*img->widthStep+x)]==(char)(unsigned char)(z?255:0))
    
20.                                 {
    
21.                                         switch(character)
    
22.                                         {
    
23.                                         case 0:
    
24.                                                 hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,3,z);
    
25.                                                 hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,0,z);
    
26.                                                 hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,0,z);
    
27.                                                 hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,1,z);
    
28.                                                 break;
    
29.                                         case 1:
    
30.                                                 hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,2,z);
    
31.                                                 hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,1,z);
    
32.                                                 hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,1,z);
    
33.                                                 hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,0,z);
    
34.                                                 break;
    
35.                                         case 2:
    
36.                                                 hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,1,z);
    
37.                                                 hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,2,z);
    
38.                                                 hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,2,z);
    
39.                                                 hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,3,z);
    
40.                                                 break;
    
41.                                         case 3:
    
42.                                                 hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,0,z);
    
43.                                                 hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,3,z);
    
44.                                                 hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,3,z);
    
45.                                                 hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,2,z);
    
46.                                                 break;
    
47.                                         }
    
48.                                 }
    
49.                                 else
    
50.                                 {
    
51.                                         switch(character)
    
52.                                         {
    
53.                                         case 0:
    
54.                                                 hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,3,z);
    
55.                                                 hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,1,z);
    
56.                                                 break;
    
57.                                         case 1:
    
58.                                                 hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,2,z);
    
59.                                                 hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,0,z);
    
60.                                                 break;
    
61.                                         case 2:
    
62.                                                 hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,1,z);
    
63.                                                 hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,3,z);
    
64.                                                 break;
    
65.                                         case 3:
    
66.                                                 hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,0,z);
    
67.                                                 hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,2,z);
    
68.                                                 break;
    
69.                                         }
    
70.                                 }
    
71.                         }
    
72.                         else
    
73.                         {
    
74.                                 switch(character)
    
75.                                 {
    
76.                                 case 0:
    
77.                                         hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,3,z);
    
78.                                         hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,1,z);
    
79.                                         break;
    
80.                                 case 1:
    
81.                                         hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,2,z);
    
82.                                         hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,0,z);
    
83.                                         break;
    
84.                                 case 2:
    
85.                                         hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,1,z);
    
86.                                         hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,3,z);
    
87.                                         break;
    
88.                                 case 3:
    
89.                                         hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,0,z);
    
90.                                         hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,2,z);
    
91.                                         break;
    
92.                                 }
    
93.                         }
    
94.                 }
    
95.                 else
    
96.                 {
    
97.                         switch(character)
    
98.                         {
    
99.                         case 0:
    
100.                                 hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,3,z);
     
101.                                 hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,0,z);
     
102.                                 hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,0,z);
     
103.                                 hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,1,z);
     
104.                                 break;
     
105.                         case 1:
     
106.                                 hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,2,z);
     
107.                                 hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,1,z);
     
108.                                 hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,1,z);
     
109.                                 hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,0,z);
     
110.                                 break;
     
111.                         case 2:
     
112.                                 hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,1,z);
     
113.                                 hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,2,z);
     
114.                                 hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,2,z);
     
115.                                 hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,3,z);
     
116.                                 break;
     
117.                         case 3:
     
118.                                 hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,0,z);
     
119.                                 hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,3,z);
     
120.                                 hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,3,z);
     
121.                                 hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,2,z);
     
122.                                 break;
     
123.                         }
     
124.                 }
     
125.         }
     
126. }
     
127. IplImage* image2;
     
128. void hilbertD(IplImage* ori,IplImage* image,int order)
     
129. {
     
130.         image2=cvCloneImage(image);
     
131.         vP.clear();
     
132.         hilbert(ori,cvPoint(0,0),order,0,0);
     
133.         for (int i=0;i<vP.size()-1;i++)
     
134.         {
     
135.                 cvLine(image2,cvPoint(vP[i].x+image->width/2,vP[i].y+image->height/2),cvPoint(vP[i+1].x+image->width/2,vP[i+1].y+image->height/2),cvScalarAll(255),1);
     
136.         }
     
137.         cvSaveImage("reverse.jpg",image2);
     
138.         cvZero(image);
     
139.         vP.clear();
     
140.         hilbert(ori,cvPoint(0,0),order,0,1);
     
141.         for (int i=0;i<vP.size()-1;i++)
     
142.         {
     
143.                 cvLine(image,cvPoint(vP[i].x+image->width/2,vP[i].y+image->height/2),cvPoint(vP[i+1].x+image->width/2,vP[i+1].y+image->height/2),cvScalarAll(255),1);
     
144.         }
     
145. }

复制代码

这里我们把曲线改一下，对于白点，我们让曲线象元走三条边，对于黑点，让曲线只走一条边。
注意啦！

请点开图片，并且用实际效果浏览！否则失真会相当严重。
最好离远点看，会很有效果。
于是得到效果：

大功告成！

下面放个高清无码的...女神照...



下面放送所有源码：

1. // maze.cpp : 定义控制台应用程序的入口点。
   
2. //
   
3. 
   
4. #include "stdafx.h"
   
5. #include "JHCap.h"
   
6. #include "opencv/cv.h"
   
7. #include "opencv/cxcore.h"
   
8. #include "opencv/highgui.h"
   
9. #include <math.h>
   
10. #include <iostream>
    
11. #include <vector>
    
12. #include <random>
    
13. #include <time.h>
    
14. extern "C"{
    
15. #include "kdtree.h"
    
16. };
    
17. #pragma comment(lib,"cv210.lib")
    
18. #pragma comment(lib,"cxcore210.lib")
    
19. #pragma comment(lib,"highgui210.lib")
    
20. #pragma comment(lib,"JHCap2.lib")
    
21. using namespace std;
    
22. #include <stdio.h>
    
23. #include <time.h>
    
24. IplImage* img;
    
25. int block=1;
    
26. #define bits 10
    
27. #define WIDTH (1<<(bits-1))
    
28. #define HEIGHT (1<<(bits-1))
    
29. 
    
30. enum {N=1,E=4,S=2,W=8};
    
31. int DX[9];
    
32. int DY[9];
    
33. int OPPOSITE[9];
    
34. int grid[WIDTH][HEIGHT];
    
35. int shuffle_array(int *array, int size)
    
36. {
    
37.         int i;
    
38. 
    
39.         for( i=0; i<(size - 1); i++) {
    
40.                 int r = i + (rand() % (size - i));
    
41.                 int temp = array[i];
    
42.                 array[i] = array[r];
    
43.                 array[r] = temp;
    
44.         }
    
45.         return 1;
    
46. }
    
47. bool check_valid(int x,int y, int grid[WIDTH][HEIGHT])
    
48. {
    
49.         if(x>=0&&x<WIDTH&&y>=0&&y<HEIGHT)
    
50.                 return grid[x][y];
    
51.         else
    
52.                 return 1;
    
53. }
    
54. int carve_passage_from(int cx, int cy, int grid[WIDTH][HEIGHT])
    
55. {
    
56. 
    
57.         int dx, dy, nx, ny;
    
58.         int directions[4] = {N, E, S, W};
    
59. 
    
60.         //shuffle the direction array
    
61.         shuffle_array(directions, 4);
    
62.         int i;
    
63.         /*
    
64.         for(i = 0; i < 4; i++) {
    
65.                 printf("Direction: %d\n", directions[i]);
    
66.         }*/
    
67.         //iterates through the direction then test if the cell in that direction is valid and
    
68.         //within the bounds of the maze
    
69.         for(i = 0; i < 4; i++) {
    
70.                 dx = DX[directions[i]];
    
71.                 dy = DY[directions[i]];
    
72.         //        printf("Check direction=x:y - %d=%d:%d\n", directions[i], dx, dy);
    
73.                 // check if the cell is valid
    
74.                 nx = cx + dx;
    
75.                 ny = cy + dy;
    
76.                 // check if we are on valid grid
    
77.                 if ( ((nx < WIDTH) & (nx >= 0)) & ((ny < HEIGHT) & (ny >= 0)) ) {
    
78.                         //check if grid is not visited
    
79.                         if (grid[nx][ny] == 0) {
    
80.                                 grid[cx][cy] = (int)((int)grid[cx][cy] | (int)directions[i]);
    
81.                                 grid[nx][ny] = (int)((int)grid[nx][ny] | (int)OPPOSITE[directions[i]]);
    
82.                                 carve_passage_from(nx, ny, grid);
    
83.                         }
    
84.                 }
    
85. 
    
86.         }
    
87.         return 1;
    
88. }
    
89. void block_a(IplImage* image,int i, int j,bool b,CvScalar c=cvScalarAll(255))
    
90. {
    
91.         cvRectangle(image,cvPoint(i*block,j*block),cvPoint(i*block+block-1,j*block+block-1),cvScalar(b?c.val[0]:0,b?c.val[1]:0,b?c.val[2]:0),-1);
    
92. }
    
93. bool search4(IplImage* image,int cx,int cy,IplImage* temp)
    
94. {
    
95.         int xP=temp->width-cx,xM=cx,yP=temp->height-cy,yM=cy;
    
96.         for (int x=cx;x<temp->width;x++)
    
97.         {
    
98.                 if(temp->imageData[cy*temp->widthStep+x]==(char)(unsigned char)255&&image->imageData[cy*image->widthStep+x]==(char)(unsigned char)0)
    
99.                 {
    
100.                         xP=x-cx;
     
101.                         break;
     
102.                 }
     
103.         }
     
104.         for (int x=cx;x>=0;x--)
     
105.         {
     
106.                 if(temp->imageData[cy*temp->widthStep+x]==(char)(unsigned char)255&&image->imageData[cy*image->widthStep+x]==(char)(unsigned char)0)
     
107.                 {
     
108.                         xM=cx-x;
     
109.                         break;
     
110.                 }
     
111.         }
     
112.         for (int y=cy;y<temp->height;y++)
     
113.         {
     
114.                 if(temp->imageData[y*temp->widthStep+cx]==(char)(unsigned char)255&&image->imageData[y*image->widthStep+cx]==(char)(unsigned char)0)
     
115.                 {
     
116.                         yP=y-cy;
     
117.                         break;
     
118.                 }
     
119.         }
     
120.         for (int y=cy;y>=0;y--)
     
121.         {
     
122.                 if(temp->imageData[y*temp->widthStep+cx]==(char)(unsigned char)255&&image->imageData[y*image->widthStep+cx]==(char)(unsigned char)0)
     
123.                 {
     
124.                         yM=cy-y;
     
125.                         break;
     
126.                 }
     
127.         }
     
128.         return xP%2&&xM%2&&yP%2&&yM%2;
     
129. }
     
130. bool mark_path(IplImage* image,int cx,int cy,int targetx,int targety,bool grid2[WIDTH*2+1][HEIGHT*2+1],bool temp[WIDTH*2+1][HEIGHT*2+1])
     
131. {
     
132.         int dx, dy, nx, ny;
     
133.         int directions[4] = {N, E, S, W};
     
134.         for(int i = 0; i < 4; i++) {
     
135.                 dx = DX[directions[i]];
     
136.                 dy = DY[directions[i]];
     
137.                 nx = cx + dx;
     
138.                 ny = cy + dy;
     
139.                 if(temp[nx][ny]==0&&grid2[nx][ny]==1)
     
140.                 {
     
141.                         temp[nx][ny]=1;
     
142.                         if(nx==targetx&&ny==targety)
     
143.                         {
     
144.                                 block_a(image,nx,ny,1,cvScalar(0,255,0));
     
145.                                 return 1;
     
146.                         }
     
147.                         if(mark_path(image,nx,ny,targetx,targety,grid2,temp))
     
148.                         {
     
149.                                 block_a(image,nx,ny,1,cvScalar(0,255,0));
     
150.                                 return 1;
     
151.                         }
     
152.                 }
     
153.         }
     
154.         return 0;
     
155. }
     
156. CvPoint main_role;
     
157. void init()
     
158. {
     
159.         OPPOSITE[N] = S;
     
160.         OPPOSITE[E] = W;
     
161.         OPPOSITE[S] = N;
     
162.         OPPOSITE[W] = E;
     
163. 
     
164.         DX[N] = 0;
     
165.         DX[E] = 1;
     
166.         DX[S] = 0;
     
167.         DX[W] = -1;
     
168. 
     
169.         DY[N] = -1;
     
170.         DY[E] = 0;
     
171.         DY[S] = 1;
     
172.         DY[W] = 0;
     
173.         memset(&grid[0], 0, sizeof(grid));
     
174. }
     
175. IplImage* maze,*maze_origin;
     
176. int generate(IplImage* image=0) {
     
177.         int x,y;
     
178.         /** Seed the random generator **/
     
179.         srand((unsigned int)time((time_t *)NULL));
     
180. 
     
181. 
     
182.         if(!image)
     
183.                 carve_passage_from(0,0,grid);
     
184.         /** Display the grid **/
     
185.         /*
     
186.         printf(" ");
     
187.         for(x = 0; x < (WIDTH * 2); x++) {
     
188.                 printf("_");
     
189.         }
     
190.         printf("\n");
     
191. 
     
192.         for(y = 0; y < HEIGHT; y++) {
     
193.                 printf("|");
     
194.                 for(x = 0; x < WIDTH; x++) {
     
195.                         printf( ((grid[x][y] & S) !=  0)?" ":"_");
     
196.                         if((grid[x][y] & E) != 0){
     
197.                                 printf((( (grid[x][y] | grid[x + 1][y]) & S) != 0) ?" ":"_");
     
198.                         } else {
     
199.                                 printf("|");
     
200.                         }
     
201.                 }
     
202.                 printf("\n");
     
203.         }*/
     
204.         bool grid2[WIDTH*2+1][HEIGHT*2+1];
     
205.         bool temp[WIDTH*2+1][HEIGHT*2+1];
     
206.         memset(&temp[0], 0, sizeof(temp));
     
207.         for (int i=0;i<WIDTH*2+1;i++)
     
208.         {
     
209.                 block_a(img,i,0,0);
     
210.                 grid2[i][0]=0;
     
211.         }
     
212.         for (int j=0;j<HEIGHT;j++)
     
213.         {
     
214.                 block_a(img,0,j*2+1,0);
     
215.                 block_a(img,0,j*2+2,0);
     
216.                 grid2[0][j*2+1]=0;
     
217.                 for (int i=0;i<WIDTH;i++)
     
218.                 {
     
219.                         if((grid[i][j]&E)!=0&&(grid[i][j]&S)==0)
     
220.                         {
     
221.                                 block_a(img,i*2+1,j*2+1,1);
     
222.                                 block_a(img,i*2+1,j*2+2,0);
     
223.                                 block_a(img,i*2+2,j*2+1,1);
     
224.                                 block_a(img,i*2+2,j*2+2,0);
     
225.                                 grid2[i*2+1][j*2+1]=1;
     
226.                                 grid2[i*2+1][j*2+2]=0;
     
227.                                 grid2[i*2+2][j*2+1]=1;
     
228.                                 grid2[i*2+2][j*2+2]=0;
     
229.                         }
     
230.                         else if((grid[i][j]&E)==0&&(grid[i][j]&S)!=0)
     
231.                         {
     
232.                                 block_a(img,i*2+1,j*2+1,1);
     
233.                                 block_a(img,i*2+1,j*2+2,1);
     
234.                                 block_a(img,i*2+2,j*2+1,0);
     
235.                                 block_a(img,i*2+2,j*2+2,0);
     
236.                                 grid2[i*2+1][j*2+1]=1;
     
237.                                 grid2[i*2+1][j*2+2]=1;
     
238.                                 grid2[i*2+2][j*2+1]=0;
     
239.                                 grid2[i*2+2][j*2+2]=0;
     
240.                         }
     
241.                         else if((grid[i][j]&E)!=0&&(grid[i][j]&S)!=0)
     
242.                         {
     
243.                                 block_a(img,i*2+1,j*2+1,1);
     
244.                                 block_a(img,i*2+1,j*2+2,1);
     
245.                                 block_a(img,i*2+2,j*2+1,1);
     
246.                                 block_a(img,i*2+2,j*2+2,0);
     
247.                                 grid2[i*2+1][j*2+1]=1;
     
248.                                 grid2[i*2+1][j*2+2]=1;
     
249.                                 grid2[i*2+2][j*2+1]=1;
     
250.                                 grid2[i*2+2][j*2+2]=0;
     
251.                         }
     
252.                         else
     
253.                         {
     
254.                                 block_a(img,i*2+1,j*2+1,1);
     
255.                                 block_a(img,i*2+1,j*2+2,0);
     
256.                                 block_a(img,i*2+2,j*2+1,0);
     
257.                                 block_a(img,i*2+2,j*2+2,0);
     
258.                                 grid2[i*2+1][j*2+1]=1;
     
259.                                 grid2[i*2+1][j*2+2]=0;
     
260.                                 grid2[i*2+2][j*2+1]=0;
     
261.                                 grid2[i*2+2][j*2+2]=0;
     
262.                         }
     
263.                 }
     
264.         }
     
265.         for (int i=0;i<HEIGHT*2+1;i++)
     
266.         {
     
267.                 block_a(img,WIDTH*2,i,0);
     
268.         }
     
269.         block_a(img,1,0,1);
     
270.         grid2[1][0]=1;
     
271.         block_a(img,WIDTH*2-1,0,1);
     
272.         grid2[WIDTH*2-1][HEIGHT*2]=1;
     
273.         IplImage* img2=cvCloneImage(img);
     
274.         main_role=cvPoint(1,0);
     
275.         cvSaveImage("maze_origin.bmp",img);
     
276.         maze_origin=cvCloneImage(img);
     
277.         if(!image)
     
278.                 mark_path(img,1,0,WIDTH*2-1,0,grid2,temp);
     
279.         else
     
280.         {
     
281.                 for (int i=0;i<image->width;i++)
     
282.                 {
     
283.                         for (int j=0;j<image->height;j++)
     
284.                         {
     
285.                                 unsigned char z=image->imageData[j*image->widthStep+i];
     
286.                                 if(z==255)
     
287.                                 {
     
288.                                         block_a(img,i,j,1,cvScalar(255));
     
289.                                 }
     
290.                         }
     
291.                 }
     
292.                 block_a(img,1,0,1,cvScalar(255));
     
293.                 block_a(img,WIDTH*2-1,0,1,cvScalar(255));
     
294.         }
     
295.         if(!image)
     
296.         {
     
297.                 while(1)       
     
298.                 {
     
299.                         cvCopyImage(img,img2);
     
300.                         cvRectangle(img2,cvPoint(main_role.x*block,main_role.y*block),cvPoint(main_role.x*block+block-1,main_role.y*block+block-1),cvScalar(0,0,255),-1);
     
301.                         cvRectangle(img,cvPoint(main_role.x*block,main_role.y*block),cvPoint(main_role.x*block+block-1,main_role.y*block+block-1),cvScalar(255,0,0),-1);
     
302.                         cvShowImage("maze",img2);
     
303.                         char c=cvWaitKey(0);
     
304.                         switch(c)
     
305.                         {
     
306.                         case 'a':
     
307.                                 if(grid2[main_role.x-1][main_role.y]&&main_role.x>0)
     
308.                                         main_role.x--;
     
309.                                 break;
     
310.                         case 'd':
     
311.                                 if(grid2[main_role.x+1][main_role.y]&&main_role.x<WIDTH*2+1)
     
312.                                         main_role.x++;
     
313.                                 break;
     
314.                         case 's':
     
315.                                 if(grid2[main_role.x][main_role.y+1]&&main_role.y<HEIGHT*2+1)
     
316.                                         main_role.y++;
     
317.                                 break;
     
318.                         case 'w':
     
319.                                 if(grid2[main_role.x][main_role.y-1]&&main_role.y>0)
     
320.                                         main_role.y--;
     
321.                                 break;
     
322.                         }
     
323.                         if(c=='q')
     
324.                                 break;
     
325.                 }
     
326.         }
     
327.         else
     
328.         {
     
329.                 cvSaveImage("maze.bmp",img);
     
330.                 maze=cvCloneImage(img);
     
331.         }
     
332.         return 1;
     
333. }
     
334. int dither[4]={0,2,3,1};
     
335. int ditherMatrix(unsigned int x,unsigned int y,int c)
     
336. {
     
337.         if(c>0)
     
338.                 return 4*ditherMatrix(x,y,c-1)+dither[(x>>(c))%2+(y>>(c))%2*2];
     
339.         else
     
340.                 return dither[(x>>(c))%2+(y>>(c))%2*2];
     
341. }
     
342. CvPoint2D32f hil[4]={cvPoint2D32f(-0.5,-0.5),cvPoint2D32f(-0.5,0.5),cvPoint2D32f(0.5,0.5),cvPoint2D32f(0.5,-0.5)};
     
343. vector<CvPoint> vP;
     
344. 
     
345. void hilbert(IplImage* img,CvPoint c,int order,int character,bool z)
     
346. {
     
347.         if(order==2)
     
348.         {
     
349.                 vP.push_back(cvPoint(c.x,c.y));
     
350.         }
     
351.         else
     
352.         {
     
353.                 if(order==4)
     
354.                 {
     
355.                         int x=c.x/order+img->width/2;
     
356.                         int y=c.y/order+img->height/2;
     
357.                         if(x>=0&&x<img->width&&y>=0&&y<img->height)
     
358.                         {
     
359.                                 if(img->imageData[(int)(y*img->widthStep+x)]==(char)(unsigned char)(z?255:0))
     
360.                                 {
     
361.                                         switch(character)
     
362.                                         {
     
363.                                         case 0:
     
364.                                                 hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,3,z);
     
365.                                                 hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,0,z);
     
366.                                                 hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,0,z);
     
367.                                                 hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,1,z);
     
368.                                                 break;
     
369.                                         case 1:
     
370.                                                 hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,2,z);
     
371.                                                 hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,1,z);
     
372.                                                 hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,1,z);
     
373.                                                 hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,0,z);
     
374.                                                 break;
     
375.                                         case 2:
     
376.                                                 hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,1,z);
     
377.                                                 hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,2,z);
     
378.                                                 hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,2,z);
     
379.                                                 hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,3,z);
     
380.                                                 break;
     
381.                                         case 3:
     
382.                                                 hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,0,z);
     
383.                                                 hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,3,z);
     
384.                                                 hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,3,z);
     
385.                                                 hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,2,z);
     
386.                                                 break;
     
387.                                         }
     
388.                                 }
     
389.                                 else
     
390.                                 {
     
391.                                         switch(character)
     
392.                                         {
     
393.                                         case 0:
     
394.                                                 hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,3,z);
     
395.                                                 hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,1,z);
     
396.                                                 break;
     
397.                                         case 1:
     
398.                                                 hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,2,z);
     
399.                                                 hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,0,z);
     
400.                                                 break;
     
401.                                         case 2:
     
402.                                                 hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,1,z);
     
403.                                                 hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,3,z);
     
404.                                                 break;
     
405.                                         case 3:
     
406.                                                 hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,0,z);
     
407.                                                 hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,2,z);
     
408.                                                 break;
     
409.                                         }
     
410.                                 }
     
411.                         }
     
412.                         else
     
413.                         {
     
414.                                 switch(character)
     
415.                                 {
     
416.                                 case 0:
     
417.                                         hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,3,z);
     
418.                                         hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,1,z);
     
419.                                         break;
     
420.                                 case 1:
     
421.                                         hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,2,z);
     
422.                                         hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,0,z);
     
423.                                         break;
     
424.                                 case 2:
     
425.                                         hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,1,z);
     
426.                                         hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,3,z);
     
427.                                         break;
     
428.                                 case 3:
     
429.                                         hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,0,z);
     
430.                                         hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,2,z);
     
431.                                         break;
     
432.                                 }
     
433.                         }
     
434.                 }
     
435.                 else
     
436.                 {
     
437.                         switch(character)
     
438.                         {
     
439.                         case 0:
     
440.                                 hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,3,z);
     
441.                                 hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,0,z);
     
442.                                 hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,0,z);
     
443.                                 hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,1,z);
     
444.                                 break;
     
445.                         case 1:
     
446.                                 hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,2,z);
     
447.                                 hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,1,z);
     
448.                                 hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,1,z);
     
449.                                 hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,0,z);
     
450.                                 break;
     
451.                         case 2:
     
452.                                 hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,1,z);
     
453.                                 hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,2,z);
     
454.                                 hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,2,z);
     
455.                                 hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,3,z);
     
456.                                 break;
     
457.                         case 3:
     
458.                                 hilbert(img,cvPoint(hil[0].x*order/2+c.x,hil[0].y*order/2+c.y),order/2,0,z);
     
459.                                 hilbert(img,cvPoint(hil[3].x*order/2+c.x,hil[3].y*order/2+c.y),order/2,3,z);
     
460.                                 hilbert(img,cvPoint(hil[2].x*order/2+c.x,hil[2].y*order/2+c.y),order/2,3,z);
     
461.                                 hilbert(img,cvPoint(hil[1].x*order/2+c.x,hil[1].y*order/2+c.y),order/2,2,z);
     
462.                                 break;
     
463.                         }
     
464.                 }
     
465.         }
     
466.        
     
467. }
     
468. bool check_va(IplImage* image, int x,int y)
     
469. {
     
470.         return x>=0&&x<image->width&&y>=0&&y<image->height;
     
471. }
     
472. unsigned char check_value(IplImage* image,int x,int y)
     
473. {
     
474.         return image->imageData[y*image->widthStep+x];
     
475. }
     
476. /*
     
477. int check_in(IplImage* image,int x,int y)
     
478. {
     
479.         int now=-1,left=-1,right=-1,up=-1,down=-1;
     
480.         if(check_va(image,x,y))
     
481.         {
     
482.                 now=check_value(image,x,y);
     
483.         }
     
484.         if(check_va(image,x-1,y))
     
485.         {
     
486.                 left=check_value(image,x-1,y);
     
487.         }
     
488.         if(check_va(image,x+1,y))
     
489.         {
     
490.                 right=check_value(image,x+1,y);
     
491.         }
     
492.         if(check_va(image,x,y-1))
     
493.         {
     
494.                 up=check_value(image,x,y-1);
     
495.         }
     
496.         if(check_va(image,x,y+1))
     
497.         {
     
498.                 down=check_value(image,x,y+1);
     
499.         }
     
500.         int r=0;
     
501.         if(left==255)
     
502.         {
     
503.                 r=r|W;
     
504.         }
     
505.         if(right)
     
506.         {
     
507.                 r=r|E;
     
508.         }
     
509.         if(up==255)
     
510.         {
     
511.                 r=r|N;
     
512.         }
     
513.         if(down==255)
     
514.         {
     
515.                 r=r|S;
     
516.         }
     
517.         if(now==255)
     
518.                 return r;
     
519.         else
     
520.                 return 0;
     
521. }*/
     
522. IplImage* image2;
     
523. void hilbertD(IplImage* ori,IplImage* image,int order)//,int grid[WIDTH][HEIGHT])
     
524. {
     
525.         image2=cvCloneImage(image);
     
526.         vP.clear();
     
527.         hilbert(ori,cvPoint(0,0),order,0,0);
     
528.         for (int i=0;i<vP.size()-1;i++)
     
529.         {
     
530.                 cvLine(image2,cvPoint(vP[i].x+image->width/2,vP[i].y+image->height/2),cvPoint(vP[i+1].x+image->width/2,vP[i+1].y+image->height/2),cvScalarAll(255),1);
     
531.         }
     
532.         cvSaveImage("reverse.jpg",image2);
     
533.         cvZero(image);
     
534.         vP.clear();
     
535.         hilbert(ori,cvPoint(0,0),order,0,1);
     
536.         for (int i=0;i<vP.size()-1;i++)
     
537.         {
     
538.                 cvLine(image,cvPoint(vP[i].x+image->width/2,vP[i].y+image->height/2),cvPoint(vP[i+1].x+image->width/2,vP[i+1].y+image->height/2),cvScalarAll(255),1);
     
539.         }
     
540.         /*
     
541.         for (int i=0;i<WIDTH;i++)
     
542.         {
     
543.                 for (int j=0;j<HEIGHT;j++)
     
544.                 {
     
545.                         int x=i*2+1;
     
546.                         int y=j*2+1;
     
547.                         grid[i][j]=check_in(image,x,y);
     
548.                         if(grid[i][j]!=0)
     
549.                                 carve_passage_from(i,j,grid);
     
550.                 }
     
551.         }*/
     
552. }
     
553. /*
     
554. void merge(IplImage* image,char* name)
     
555. {
     
556.         IplImage** imag=new IplImage*[bits-8];
     
557.         IplImage* total=cvCreateImage(cvSize(256*(bits-7),256),8,image->nChannels);
     
558.         imag[0]=cvCreateImage(cvSize(image->width/2,image->height/2),8,image->nChannels);
     
559.         cvResize(image,imag[0]);
     
560.         for (int i=1;i<bits-8;i++)
     
561.         {
     
562.                 imag[i]=cvCreateImage(cvSize(imag[i-1]->width/2,imag[i-1]->height/2),8,image->nChannels);
     
563.                 cvResize(imag[i-1],imag[i]);
     
564.         }
     
565.         for (int x=-128;x<128;x++)
     
566.         {
     
567.                 for (int y=-128;y<128;y++)
     
568.                 {
     
569.                         int x0=x+image->width/2;
     
570.                         int y0=y+image->height/2;
     
571.                         int xt=x+128;
     
572.                         int yt=y+128;
     
573.                         for(int k=0;k<3;k++)
     
574.                                 total->imageData[yt*total->widthStep+xt*image->nChannels+k]=image->imageData[image->widthStep*y0+x0*image->nChannels+k];
     
575.                 }
     
576.         }
     
577.         for (int i=0;i<bits-8;i++)
     
578.         {
     
579.                 for (int x=-128;x<128;x++)
     
580.                 {
     
581.                         for (int y=-128;y<128;y++)
     
582.                         {
     
583.                                 int x0=x+imag[i]->width/2;
     
584.                                 int y0=y+imag[i]->height/2;
     
585.                                 int xt=x+i*256+128+256;
     
586.                                 int yt=y+128;
     
587.                                 for(int k=0;k<3;k++)
     
588.                                         total->imageData[yt*total->widthStep+xt*image->nChannels+k]=imag[i]->imageData[imag[i]->widthStep*y0+x0*image->nChannels+k];
     
589.                         }
     
590.                 }
     
591.         }
     
592.         cvSaveImage(name,total);
     
593.         cvReleaseImage(&total);
     
594.         for (int i=0;i<bits-8;i++)
     
595.         {
     
596.                 cvReleaseImage(&imag[i]);
     
597.         }
     
598. }*/
     
599. int _tmain(int argc, _TCHAR* argv[])
     
600. {
     
601.         init();
     
602.         IplImage* hill=cvCreateImage(cvSize((1<<bits),(1<<bits)),8,1);
     
603.         IplImage* origin0=cvLoadImage("m.bmp",0);
     
604.         cvSaveImage("D:\\gray.jpg", origin0);
     
605.         double ratio=origin0->width>origin0->height?origin0->width/(double)(1<<(bits-2)):origin0->height/(double)(1<<(bits-2));
     
606.         IplImage* origin=cvCreateImage(cvSize(origin0->width/ratio,origin0->height/ratio),8,1);
     
607.         cvResize(origin0,origin);
     
608.         IplImage* tempi=cvCloneImage(origin);
     
609.         IplImage* tempi2=cvCloneImage(origin);
     
610.         int c=3;
     
611.         double gray=256/(double)(1<<(2*c));
     
612.         for (int x=0;x<origin->width;x++)
     
613.         {
     
614.                 for (int y=0;y<origin->height;y++)
     
615.                 {
     
616.                         unsigned char g=origin->imageData[y*origin->widthStep+x];
     
617.                         tempi->imageData[y*tempi->widthStep+x]=g/gray>ditherMatrix(x%(1<<(c-1)),y%(1<<(c-1)),c-1)?(char)(unsigned char)255:(char)(unsigned char)0;
     
618.                 }
     
619.         }
     
620.         cvSaveImage("D:\\bw.jpg", tempi);
     
621.         cvShowImage("origin",origin);
     
622.         cvShowImage("origin",tempi);
     
623.         hilbertD(tempi,hill,(1<<bits));
     
624.         cvSaveImage("D:\\hilbert.png", hill);
     
625.         cvShowImage("hilbert",hill);
     
626. //        cvSaveImage("hilbert.bmp",hill);
     
627.         cvWaitKey(0);
     
628.         /*
     
629.         img=cvCreateImage(cvSize(block*(WIDTH*2+1),block*(HEIGHT*2+1)),8,3);
     
630.         generate(hill);
     
631.         merge(image2,"hibertD.jpg");
     
632.         merge(maze,"mazeD.jpg");
     
633.         merge(maze_origin,"maze_originD.jpg");
     
634.        
     
635.         */
     
636.           return 0;
     
637. }
     
638. 
     

复制代码

顺便提一句...

论坛的图片分辨率还是小垃圾一个...无法看清分形图案的全貌，所以有任何朋友需要高清女神图像...q我。
qq：1174686650
验证问题忽略掉。


原创帖，转载请注明出处。

maxims

好神奇的东西…先收了！

血阳

果然女神是进步的动力源泉233333

沧海笑1122

太厉害了吧！点开实际效果，方识庐山真面目！！！赞，期待后续帖子和应用。
顺便说一句，有python版的吗

小猪会轮滑

求系列教程 让小白长知识

darkorigin

高手，流弊啊

csgtli

太主深了!!!!!

野子yz

嘿嘿嘿嘿嘿嘿嘿嘿嘿嘿嘿嘿

suoma

硬件是什么？