Why數學圖像生成工具

時間 2019-11-05

標籤數學圖像生成工具欄目應用數學简体版

原文原文鏈接

該軟件可以以給定的數學公式及算法生成各類絢爛的數學圖像.軟件中有兩種生成圖像的方法：html

（1）經過一種我自定義的腳本語言生成：ios

軟件中定義一套簡單易學的腳本語言,用於描述數學表達式.使用時須要先要將數學表達式寫成該腳本的形式,解析腳本代碼以生成相應的圖像.c++

（2）使用軟件中內置的算法：算法

軟件中含有近百種數學圖像生成的算法，如Mandelbrot,JuliaSets之類的分形算法。數組

軟件的開發語言是C++,開發環境是VS2008,渲染使用的是D3D9。關於數學圖形圖像的QQ交流羣: 367752815app

軟件下載地址:less

1.0版本 http://files.cnblogs.com/WhyEngine/WhyMathImageViewer_1_0.zipide

1.1版本 http://files.cnblogs.com/WhyEngine/WhyMathImage_1_1.zip函數

[一]基本功能

首先介紹下該軟件的基本功能，這是一款與圖像有關的軟件，因此圖像加載顯示功能是必需的，軟件支持的圖像格式有：png，jpg，dds，bmp，tga，ppm。用戶能夠將文件直接拖入窗體內以打開圖像，也能夠經過菜單項或快捷方式Ctrl+F選擇文件加載。下圖爲軟件界面：工具

在窗體的兩邊有UI界面，用戶能夠按快捷鍵U來開關UI界面。

（1.1）圖像顏色通道

先看下左則的UI，打開圖像後，能夠經過UI選擇RGBA的各個通道以顯示圖像，或經過快捷鍵R,G,B,A,I來選擇通道模式：

R通道圖像：

G通道圖像：

B通道圖像：

反色圖像：

（1.2）圖像濾波方式

有兩種圖像濾波方式：（1）線性採樣（2）點採樣。經過下圖能夠看出兩者的區別：

（1.3）圖像大小設置：

鼠標滾輪用於控制圖像的縮放。圖像縮放時，是以鼠標所指的位置當作中心進行縮放的。

鼠標右鍵拖動能夠控制圖像的位置。

以下圖爲縮小並拖動後的圖像：

還有兩個按鈕，其快捷鍵爲F，O。分別表示使圖像最合適的大小顯示，和使圖像以原始大小顯示。

最後鍵盤F11用於控制界面的全屏切換。

[二]經過腳本生成圖像

以前我寫過一套數學圖形可視化的工具,能夠將數學表達式以圖形的形式顯示出來.這兩套軟件使用的腳本解析方式是同樣的,即兩個軟件使用相同的腳本解析模塊.關於詳細語法介紹請看:數學圖形可視化工具的腳本語法.我已經將該腳本解析模塊的代碼開源.這裏腳本的後綴名爲txt,主要是方便用記事本打開.目前我寫了幾十個腳本,放置在"Why數學圖像生成工具_1_0\Scripts"目錄下.腳本文件的加載方式與圖像加載同樣,便可以經過菜單項選擇文件打開,又能夠直接將文件拖入程序窗體內自動加載.

(2.1)函數名

下面是個人腳本語言中的全部函數名:

（1）單目運算函數，形如a = log(b)

"positive", // 取正，基本上沒什麼用，至關於(+a)
"negative", // 取負
"abs", // 求絕對值
"floor", // 整數位
"ceil", // 整數位+1
"sign", // 返回-1.0或1.0
"sgn", // 返回-1.0或0.0或1.0
"is_zero", // 返回0.0或1.0
"rand", // 返回一個隨機的浮點數
"rand_int", // 返回一個隨機整數
"round", // 四捨五入
"reciprocal", // 倒數

"sqrt", // 開根號
"exp", //
"log", // 求對數
"ln", // log == ln
"log10",
"lg", // log10 = lg
"log2",

"sin", // 正弦函數
"cos", // 餘弦函數
"asin", // 反正弦函數
"acos", // 反餘弦函數
"arcsin", // 反正弦函數
"arccos", // 反餘弦函數

"tan", // 正切函數
"cot", // 餘切函數
"ctg", // 餘切函數
"atan", // 反正切函數
"acot", // 反餘切函數
"actg", // 反餘切函數
"arctan", // 反正切函數
"arccot", // 反餘切函數
"arcctg", // 反餘切函數

"sec", // 正割函數
"csc", // 餘割函數
"asec", // 反正割函數
"acsc", // 反餘割函數
"arcsec", // 反正割函數
"arccsc", // 反餘割函數

"sinh", // 雙曲正弦函數
"cosh", // 雙曲餘弦函數
"tanh", // 雙曲正切函數
"coth", // 雙曲餘切函數

"sh", // 雙曲正弦函數
"ch", // 雙曲餘弦函數
"th", // 雙曲正切函數
"cth", // 雙曲餘切函數

"sech", // 雙曲正割(等同於sch)
"sch", // 雙曲正割
"csch", // 雙曲餘割(等同於xh)
"xh", // 雙曲餘割

"factorial", // 階乘
"erf", // 偏差函數
"float_to_color", // 將浮點數轉化爲0-255的顏色數

（2）雙目運算函數，形如a = add(b, c)

"add", 相加
"sub", 相減
"multiply", 相乘
"divide", 相除

"max", // 返回兩數較大的一個
"min", // 返回兩數較小的一個
"mod", // 求餘
"pow", // 求冪
"log_ax", // 對數
"pow_sign", // 用於對負數的求冪,至關於pow(abs(a), b)

"correction_gamma",// gamma校訂函數
"correction_pow", // pow校訂函數
"correction_sin", // sin校訂函數

"atan2", // 正切
"rand2", // 返回兩數之間的一個隨機浮點數
"rand_int2", // 返回兩數之間的一個隨機整數

"and_bool" // 與,返回0或1.0
"or_bool", // 或,返回0或1.0
"xor_bool" // 異或,返回0或1.0
"and_byte" // 與,返回0到255.0的一個數
"or_byte", // 或,返回0到255.0的一個數
"xor_byte" // 異或,返回0到255.0的一個數
"and_word" // 與,返回0到65535.0的一個數
"or_word", // 或,返回0到65535.0的一個數
"xor_word" // 異或,返回0到65535.0的一個數

"greater", // 返回0或1.0
"greater_equal", // 返回0或1.0
"less", // 返回0或1.0
"less_equal", // 返回0或1.0
"equal", // 返回0或1.0

(3)三目運算符函數形如lerp(a, b, r)

"lerp", // 線性插值
"clamp", // 限定數值的範圍
"limit", // 限定數值的範圍,與clamp同樣
"in_range", // 數值是否範圍內,返回0或1.0
"gray", // 顏色的灰度化
"add3", // 相加
"min3", // 三個之中取最小
"max3", // 三個之中取最大
"average3", // 三數平均值
"if", // 若是第一個數不爲0則取第二個數,不然取第三個數
"if_else", // 與if等價

(4)函數四目運算符形如average4(a, b, c, d)

"add4", // 相加
"min4", // 四個之中取最小
"max4", // 四個之中取最大
"average4", // 四數平均值

(5)函數數組運算符(輸入實數數組,輸出一個浮點數,如求最大值,最小值,數組加和等)

"array_add", // 相加
"array_min", // 數組之中取最小
"array_max", // 數組之中取最大
"array_ave", // 數組平均值

(6)函數數組運算符(輸入實數數組,輸出也是實數數組,如求數組左移,數組右移,前向累加等)

"array_move_right",// 數組右移
"array_move_left", // 數組左移
"array_cumulate", // 數組累加
"array_difference",// 數組差,b[n] = a[n + params] - a[n]

(7)函數數組運算符(輸入兩個浮點數,輸出實數數組)
"array_lerp", // 將數組中的數值變爲等差數列
"array_rand", // 將數組中的數值變爲隨機浮點數
"array_rand_int", // 將數組中的數值變爲隨機整數
"array_set_all_values",// 將數組設置爲統一值

(8)函數數組運算符(輸入實數數組和一個浮點數,輸出一個浮點數)
"array_get_value" // 獲取數組的某一個值

(2.2)腳本編輯

按下鍵盤F5或經過菜單選項能夠打開腳本編輯對話框:

這個對話框與數學圖形可視化的工具的基本上徹底同樣.

有一點須要注意的是:腳本中的數據都是以浮點數進行處理的.最後腳本中的r,g,b,a分別表示圖像中的紅色,綠色,藍色,透明度這四個通道.而且其數值應該是0到1.0之間.而不像常規圖像處理中用整數表示的0到255之間.當腳本中的數值爲1.0時,至關於常規圖像中的255.

(2.3)圖像實例

先給你們舉個腳本生成圖像的簡單例子:

# 肯定圖像大小爲512*512
pixels = W:512 H:512

# 建立數組u爲X軸方向
u = from 0 to (2*PI) W

# 建立數組v爲Y軸方向
v = from (-PI*0.5) to (PI*0.5) H

x = cos(v)*sin(u)
y = sin(v)
z = cos(v)*cos(u)

# rgb分別表示圖像中對應像素的紅色,綠色,藍色通道
r = (x+1.0)/2
g = (y+1.0)/2
b = (z+1.0)/2

其生成的圖像以下:

其實這個腳本代碼與數學圖形可視化的工具是能夠通用的,看下它的3D圖形:

再舉個複雜點的圖像例子:

pixels = W:1024 H:1024

x = from 0 to 1023 W
y = from 0 to 1023 H

r = and_byte((x+y), y)
g = and_byte((255 + x - y), x)
b = and_byte((255 - x - y), y)
b = and_byte(b, x)

r = r/255
g = g/255
b = b/255

而後是一幅讓人眼花的圖像,但生成它的數學公式很簡單.

pixels = W:1024 H:1024

x = from 0 to (16*PI) W
y = from 0 to (16*PI) H

r = sin(x+y)
g = sin(x-y)
b = sin(x*y)

r = r*0.5 + 0.5
g = g*0.5 + 0.5
b = b*0.5 + 0.5

下面是兩幅使用sin和tan函數而生成的圖像

[三]數學圖像生成算法

不得不認可個人腳本功能還不夠強大,只能實現些比較基礎的圖像,像循環迭代這樣的算法目前還沒辦法實現.爲了彌補這一不足,我將一些數學圖像生成算法內置到該軟件中.

(3.1)Tweetable Mathematical Art

網上有不少經過算法生成數學圖像,尤爲是與分形學相關的方面.我收集了近百種數學圖像生成的算法,都寫入該軟件中.其中大部份算法來自:http://codegolf.stackexchange.com/questions/35569/tweetable-mathematical-art.它是Kyle McCormick 在 StackExchange 上發起了一個叫作 Tweetable Mathematical Art 的比賽，參賽者須要用三條代碼來生成一張圖片。具體地說，參賽者須要用 C++ 語言編寫 RD 、 GR 、 BL 三個函數，每一個函數都不能超過 140 個字符。每一個函數都會接到 i 和 j 兩個整型參數（0 ≤ i, j ≤ 1023），而後須要返回一個 0 到 255 之間的整數，表示位於 (i, j) 的像素點的顏色值。參賽者編寫的代碼會被插進下面這段程序當中，最終會生成一個大小爲 1024×1024 的圖片。

// NOTE: compile with g++ filename.cpp -std=c++11
 
#include <iostream>
#include <cmath>
#include <cstdlib>
#define DIM 1024
#define DM1 (DIM-1)
#define _sq(x) ((x)*(x)) // square
#define _cb(x) abs((x)*(x)*(x)) // absolute value of cube
#define _cr(x) (unsigned char)(pow((x),1.0/3.0)) // cube root
 
unsigned char GR(int,int);
unsigned char BL(int,int);
 
unsigned char RD(int i,int j){
   // YOUR CODE HERE
}
unsigned char GR(int i,int j){
   // YOUR CODE HERE
}
unsigned char BL(int i,int j){
   // YOUR CODE HERE
}
 
void pixel_write(int,int);
FILE *fp;
int main(){
    fp = fopen("MathPic.ppm","wb");
    fprintf(fp, "P6\n%d %d\n255\n", DIM, DIM);
    for(int j=0;j<DIM;j++)
        for(int i=0;i<DIM;i++)
            pixel_write(i,j);
    fclose(fp);
    return 0;
}
void pixel_write(int i, int j){
    static unsigned char color[3];
    color[0] = RD(i,j)&255;
    color[1] = GR(i,j)&255;
    color[2] = BL(i,j)&255;
    fwrite(color, 1, 3, fp);
}

這代碼寫得很棒,給我一種重劍無鋒,大道至簡的感受.參賽者只要將本身的代碼寫入這三個函數便可生成一幅圖像文件:

unsigned char RD(int i,int j){
   // YOUR CODE HERE
}
unsigned char GR(int i,int j){
   // YOUR CODE HERE
}
unsigned char BL(int i,int j){
   // YOUR CODE HERE
}

因爲它要求每一個函數都不能超過140個字符,因此不少參賽者在其代碼中大量使用宏來過份地簡化,於是其可讀性差了點.而我花了幾天時間基本上將其全部代碼翻寫了一遍.

(3.2)圖像內置算法基類

個人代碼中爲每一種圖像生成算法建立一個類對象,全部算法類繼承自同一個基類:

#ifndef _IPixelEquation_H_
#define _IPixelEquation_H_

// --------------------------------------------------------------------------------------

#include <cmath>
#include <cstdlib>
#include <cstring>
#include <cfloat>

// --------------------------------------------------------------------------------------

#define PI                      3.14159265f
#define EPSILON                 0.000001f
#define PARAMS_COUNT            4
#define RADIAN_VS_DEGREE        57.2957795130824f               // 180 / PI
#define DEGREE_VS_RADIAN        0.01745329251994f               // PI / 180

// 經過R,G,B生成一整數表示顏色
#define MAKE_RGB(r,g,b)         ( (b) | ((g) << 8) | ((r) << 16) | 0xff000000 )

// 經過R,G,B,A生成一整數表示顏色
#define MAKE_ARGB(a,r,g,b)      ( (b) | ((g) << 8) | ((r) << 16) | ((a) << 24) )

#define FLOAT_1_TO_BYTE(x)      ( (x) < 0.0f ? 0 : (((x) > 1.0f) ? 255 : (unsigned int)((x) * 255)) )
#define FLOAT_255_TO_BYTE(x)    ( (x) < 0.0f ? 0 : (((x) > 255.0f) ? 255 : (unsigned int)(x)) )
#define BYTE_TO_FLOAT_1(x)      ( (x) * 0.00392156862745f )           // x / 255

#define _sq(x)                  ((x)*(x))           // square
#define _cb(x)                  fabsf((x)*(x)*(x))  // absolute value of cube
#define _cr(x)                  powf((x),1.0f/3.0f) // cube root

// --------------------------------------------------------------------------------------

class IPixelEquation
{
public:
    IPixelEquation()
    {
        m_width = 1024;
        m_height = 1024;

        memset(m_params, 0, sizeof(m_params));
    }

    unsigned int            GetWidth() const
    {
        return m_width;
    }

    unsigned int            GetHeight() const
    {
        return m_height;
    }

    // 設置參數值
    virtual void            SetParamValue(unsigned int index, float v)
    {
        if (index < PARAMS_COUNT)
        {
            m_params[index] = v;
        }
    }

    // 獲取參數值
    float                   GetParamValue(unsigned int index) const
    {
        if (index < PARAMS_COUNT)
        {
            return m_params[index];
        }
        else
        {
            return 0.0f;
        }
    }

    // 返回參數表示的意義
    virtual const char*     GetParamName(unsigned int index) const
    {
        return 0;
    }

    // 參數的取值範圍屬性
    virtual void            GetParamProperties(unsigned int index, float& _min, float& _max, float& _step)
    {
        _min = -1.0f;
        _max = 1.0f;
        _step = 0.001f;
    }

    // 恢復默認參數
    virtual void            ResetDefaultParams() {}

    // 返回數學圖像名
    virtual const char*     GetName() const = 0;

    // 計算圖像像素顏色
    virtual unsigned int    CalculatePixel(unsigned int x, unsigned int y) = 0;

protected:
    unsigned int m_width;
    unsigned int m_height;

    float m_params[PARAMS_COUNT];   // 參數設置
};

每個算法類中須要實現各自的unsigned int CalculatePixel(unsigned int x, unsigned int y)函數,以計算圖像像素顏色.下面代碼中每一行就表示一個數學圖像算法類,我目前共寫了81個:

 1 #include "PixelEquation\PixelZero.h"
 2 #include "PixelEquation\PixelRGB.h"
 3 #include "PixelEquation\PixelNewtonFractal.h"
 4 #include "PixelEquation\PixelColorPoint.h"
 5 #include "PixelEquation\PixelOilPainting.h"
 6 #include "PixelEquation\PixelMandelbrotMartin.h"
 7 #include "PixelEquation\PixelMandelbrotKasten.h"
 8 #include "PixelEquation\PixelMandelbrotLehman.h"
 9 #include "PixelEquation\PixelLaserLight.h"
10 #include "PixelEquation\PixelLatticeCloth.h"
11 #include "PixelEquation\PixelIceFrost.h"
12 #include "PixelEquation\PixelFeigenbaumLogistic.h"
13 #include "PixelEquation\PixelCrossTarget.h"
14 #include "PixelEquation\PixelAndAddOr.h"
15 #include "PixelEquation\PixelReflectedWaves.h"
16 #include "PixelEquation\PixelColorful.h"
17 #include "PixelEquation\PixelDiabolical.h"
18 #include "PixelEquation\PixelConstructionPapers.h"
19 #include "PixelEquation\PixelCrossOnHill.h"
20 #include "PixelEquation\PixelActionPainting.h"
21 #include "PixelEquation\PixelStarryNight.h"
22 #include "PixelEquation\PixelHilbertColor.h"
23 #include "PixelEquation\PixelSharpEdges.h"
24 #include "PixelEquation\PixelRaycasterSphere.h"
25 #include "PixelEquation\PixelPalette.h"
26 #include "PixelEquation\PixelBeHappy.h"
27 #include "PixelEquation\PixelCellularAutomata.h"
28 #include "PixelEquation\PixelSchwefel.h"
29 #include "PixelEquation\PixelSierpinskiCarpets1.h"
30 #include "PixelEquation\PixelSierpinskiCarpets2.h"
31 #include "PixelEquation\PixelSierpinskiCarpets3.h"
32 #include "PixelEquation\PixelSierpinskiTriangle.h"
33 #include "PixelEquation\PixelWavyChessboard.h"
34 #include "PixelEquation\PixelBelousovZhabotinsky.h"
35 #include "PixelEquation\PixelStripes.h"
36 #include "PixelEquation\PixelSineStripes.h"
37 #include "PixelEquation\PixelNonlinearStripes.h"
38 #include "PixelEquation\PixelWaveStripes.h"
39 #include "PixelEquation\PixelBlurStripes.h"
40 #include "PixelEquation\PixelZebraStripes.h"
41 #include "PixelEquation\PixelMistakeStripes.h"
42 #include "PixelEquation\PixelStackOverflow.h"
43 #include "PixelEquation\PixelPlaidTrip.h"
44 #include "PixelEquation\PixelCameron1.h"
45 #include "PixelEquation\PixelCameron2.h"
46 #include "PixelEquation\PixelTablecloths.h"
47 #include "PixelEquation\PixelSwirlyPointy1.h"
48 #include "PixelEquation\PixelSwirlyPointy2.h"
49 #include "PixelEquation\PixelJuliaSets1.h"
50 #include "PixelEquation\PixelJuliaSets2.h"
51 #include "PixelEquation\PixelFaubiguy.h"
52 #include "PixelEquation\PixelSierpinskiPentagon.h"
53 #include "PixelEquation\PixelBuddhabrot.h"
54 #include "PixelEquation\PixelSheetMusic.h"
55 #include "PixelEquation\PixelVoronoiDiagrams.h"
56 #include "PixelEquation\PixelLyapunovFractal1.h"
57 #include "PixelEquation\PixelLyapunovFractal2.h"
58 #include "PixelEquation\PixelUnicorns.h"
59 #include "PixelEquation\PixelColouredVinyl.h"
60 #include "PixelEquation\PixelVinyl.h"
61 #include "PixelEquation\PixelSpiral.h"
62 #include "PixelEquation\PixelJoukowsky.h"
63 #include "PixelEquation\PixelXOR.h"
64 #include "PixelEquation\PixelSierpinskiSplash.h"
65 #include "PixelEquation\PixelGroovy.h"
66 #include "PixelEquation\PixelCool.h"
67 #include "PixelEquation\PixelGameScreen.h"
68 #include "PixelEquation\PixelUmberFerrule.h"
69 #include "PixelEquation\PixelPlanetaryPainter.h"
70 #include "PixelEquation\PixelPowAnd.h"
71 #include "PixelEquation\PixelHilbertRed.h"
72 #include "PixelEquation\PixelRaycasterSprite.h"
73 #include "PixelEquation\PixelPowFTW.h"
74 #include "PixelEquation\PixelBinaryFlash.h"
75 #include "PixelEquation\PixelTriangularLimbo.h"
76 #include "PixelEquation\PixelAmericanFlag.h"
77 #include "PixelEquation\PixelPurple.h"
78 #include "PixelEquation\PixelChristmasStars.h"
79 #include "PixelEquation\PixelSpotlight.h"
80 #include "PixelEquation\PixelMagnifierBall.h"
81 #include "PixelEquation\PixelWhat.h"

(3.3)圖像內置算法舉例

在窗體右側的UI界面中,有一個選擇列表,能夠選擇內置的算法以生成圖像.

若是你在自定義類的CalculatePixel函數中什麼也不作,將會生成一個全黑色的圖像.

class CPixelZero : public IPixelEquation
{
public:
    const char*     GetName() const
    {
        return "Black";
    }

    unsigned int    CalculatePixel(unsigned int x, unsigned int y)
    {
        return 0;
    }
};

以下爲生成一個彩色三角形集的圖像算法:

class CPixelColorful : public IPixelEquation
{
public:
    const char*     GetName() const
    {
        return "Colorful Triangle";
    }

    unsigned int    CalculatePixel(unsigned int i, unsigned int j)
    {
        unsigned int r = (i+j)/4%256;
        unsigned int g = (i+2*j)/4%256;
        unsigned int b = (2*i+j)/4%256;
        return MAKE_RGB(r,g,b);
    }
};

下面是一個比較藝術的圖像:

 1 /*
 2 unsigned char RD(int i,int j){
 3 #define r(n)(rand()%n)
 4 static char c[1024][1024];return!c[i][j]?c[i][j]=!r(999)?r(256):RD((i+r(2))%1024,(j+r(2))%1024):c[i][j];
 5 }
 6 
 7 unsigned char GR(int i,int j){
 8 static char c[1024][1024];return!c[i][j]?c[i][j]=!r(999)?r(256):GR((i+r(2))%1024,(j+r(2))%1024):c[i][j];
 9 }
10 
11 unsigned char BL(int i,int j){
12 static char c[1024][1024];return!c[i][j]?c[i][j]=!r(999)?r(256):BL((i+r(2))%1024,(j+r(2))%1024):c[i][j];
13 }
14 }
15 */
16 
17 // --------------------------------------------------------------------------------------
18 
19 #define r(n)(rand()%n)
20 
21 unsigned int    CPixelOilPainting::CalculateRed(unsigned int i, unsigned int j)
22 {
23     static char c[1024][1024];
24     return !c[i][j]?c[i][j]=!r(999)?r(256):CalculateRed((i+r(2))%1024,(j+r(2))%1024):c[i][j];
25 }
26 
27 unsigned int    CPixelOilPainting::CalculateGreen(unsigned int i, unsigned int j)
28 {
29     static char c[1024][1024];
30     return !c[i][j]?c[i][j]=!r(999)?r(256):CalculateGreen((i+r(2))%1024,(j+r(2))%1024):c[i][j];
31 }
32 
33 unsigned int    CPixelOilPainting::CalculateBlue(unsigned int i, unsigned int j)
34 {
35     static char c[1024][1024];
36     return !c[i][j]?c[i][j]=!r(999)?r(256):CalculateBlue((i+r(2))%1024,(j+r(2))%1024):c[i][j];
37 }
38 
39 unsigned int    CPixelOilPainting::CalculatePixel(unsigned int x, unsigned int y)
40 {
41     unsigned int r = CalculateRed(x, y);
42     unsigned int g = CalculateGreen(x, y);
43     unsigned int b = CalculateBlue(x, y);
44     r &= 0xff;
45     g &= 0xff;
46     b &= 0xff;
47     return MAKE_RGB(r,g,b);
48 }

View Code

再發一個複雜點的JuliaSets分形圖:

 1 // --------------------------------------------------------------------------------------
 2 
 3 #include "PixelJuliaSets1.h"
 4 
 5 // --------------------------------------------------------------------------------------
 6 
 7 /*
 8 unsigned short red_fn(int i, int j){
 9 #define D(x) (x-DIM/2.)/(DIM/2.)
10 float x=D(i),y=D(j),X,Y,n=0;while(n++<200&&(X=x*x)+(Y=y*y)<4){x=X-Y+.36237;y=2*x*y+.32;}return log(n)*256;}
11 
12 unsigned short green_fn(int i, int j){
13 float x=D(i),y=D(j),X,Y,n=0;while(n++<200&&(x*x+y*y)<4){X=x;Y=y;x=X*X-Y*Y+-.7;y=2*X*Y+.27015;}return log(n)*128;}
14 
15 unsigned short blue_fn(int i, int j){
16 float x=D(i),y=D(j),X,Y,n=0;while(n++<600&&(x*x+y*y)<4){X=x;Y=y;x=X*X-Y*Y+.36237;y=2*X*Y+.32;}return log(n)*128;}
17 */
18 
19 // --------------------------------------------------------------------------------------
20 
21 #define DIM 1024
22 #define D(x) (x-512.0f)/512.0f
23 
24 float    CPixelJuliaSets1::CalculateRed(float i, float j)
25 {
26     float x=D(i),y=D(j);
27     float X=x*x;
28     float Y=y*y;
29     int n=0;
30     while(n<200 && (X+Y<4))
31     {
32         x=X-Y+0.36237f;
33         y=2*x*y+0.32f;
34 
35         X=x*x;
36         Y=y*y;
37 
38         n++;
39     }
40     
41     return logf((float)n)*256.0f;
42 }
43 
44 float    CPixelJuliaSets1::CalculateGreen(float i, float j)
45 {    
46     float x=D(i),y=D(j);
47     float X;
48     float Y;
49     int n=0;
50     while(n<200 && (x*x+y*y)<4)
51     {
52         X=x;
53         Y=y;
54 
55         x=X*X-Y*Y-0.7f;
56         y=2*X*Y+0.27015f;
57 
58         n++;
59     }
60 
61     return logf((float)n)*128.0f;
62 }
63 
64 float    CPixelJuliaSets1::CalculateBlue(float i, float j)
65 {
66     float x=D(i),y=D(j);
67     float X;
68     float Y;
69     int n=0;
70     while(n<600&&(x*x+y*y)<4)
71     {
72         X=x;
73         Y=y;
74 
75         x=X*X-Y*Y+0.36237f;
76         y=2*X*Y+0.32f;
77 
78         n++;
79     }
80     
81     return logf((float)n)*128.0f;
82 }
83 
84 unsigned int    CPixelJuliaSets1::CalculatePixel(unsigned int x, unsigned int y)
85 {
86     float i = (float)x;
87     float j = (float)y;
88 
89     unsigned int r = (unsigned int)CalculateRed(i, j);
90     unsigned int g = (unsigned int)CalculateGreen(i, j);
91     unsigned int b = (unsigned int)CalculateBlue(i, j);
92 
93     r &= 0xff;
94     g &= 0xff;
95     b &= 0xff;
96 
97     return MAKE_RGB(r,g,b);
98 }