Процедурная генерация леса

#include <gl/glut.h>
#include <iostream> 
#include <iomanip>
#include <math.h>
#include <stdlib.h>
using namespace std;
 
const int imSiz=300; // размер картинки
const int arSiz=100; // размер квадратного массива
int rnd=12; //число сид генератора
 
 
float pts[arSiz+2][arSiz+2][2]={0}; //хранит 2д вектора рисуемых точек
bool pix[arSiz+2][arSiz+2]={0}; //хранит состояния пикселей есть/нет
bool buf[arSiz+2][arSiz+2]={0}; //буферный массив хранит результат свертки
 
 
//функция возвращает значение заряда от точки
float charge(float x,float x1,float y,float y1,float a,float b)
{
return a*exp(-b*((x-x1)*(x-x1)+(y-y1)*(y-y1)));
}
 
 
 
bool render_complete=0; //флаг завершения рендера
int iter=0; //подсчет итераций
bool BufNeRavenPix=1; //флаг остановки итераций если картнка не меняеться
 
//========================================================
//рисует квадраты
void DrawPixelArray()
{
    glClear(GL_COLOR_BUFFER_BIT);
    glBegin(GL_POINTS);
    for(int x = 1; x < arSiz+1; x++)
    {
        for (int y =1; y < arSiz+1; y++)
        {
            float color;
            if(pix[x][y])
            {
                color=1.0f;
            }
            else
            {
                color=0.0f;
            }
            glColor3f(color, color, color);
            glVertex2f(pts[x][y][0],pts[x][y][1]);
        }
    }
    glEnd();
    render_complete=1;
}
//рисует квадраты
//========================================================
 
 
 
 
 
 
//========================================================
//клеточный автомат, ядро свертки 3 на 3
void Conv3x3() 
{
    for(int x = 1; x < arSiz+1; x++)
    {
        for (int y = 1; y < arSiz+1; y++)
        {
            int sum=
            pix[x-1][y+1]+
            pix[x][y+1]+
            pix[x+1][y+1]+
            
            pix[x-1][y]+
            pix[x+1][y]+
 
            pix[x-1][y-1]+
            pix[x][y-1]+
            pix[x+1][y-1];
 
            if(sum>4)
            {
                buf[x][y]=1;
            }
            else if(sum<4)
            {
                buf[x][y]=0;
            }
            else if(sum==4)
            {
                buf[x][y]=pix[x][y];
            }
        }
    }
    //остановка итераций если состояния пикселей в buf равны  состояниям в pix
    //копируем buf в pix
    BufNeRavenPix=1;
    for(int x = 1; x < arSiz+1; x++)
    {
        for (int y = 1; y < arSiz+1; y++)
        {
            if (pix[x][y]!=buf[x][y] && BufNeRavenPix)
            {
                //cout <<"BufNeRavenPix--------"<<endl;
                BufNeRavenPix=0;
            }
            pix[x][y]=buf[x][y];
        }
    }
 
    if(!BufNeRavenPix)
    {
        DrawPixelArray();
    }
    else
    {
        cout <<"Image not changed, STOP"<<endl;
    }
}
//клеточный автомат, ядро свертки 3 на 3
//========================================================
 
 
//========================================================
// копируем строки и столбцы для зацикливания XY области для свертки 3 на 3.
void CopyRowColumn() 
{
    //копируем строки
    for(int y = 1; y < arSiz+1; y++)
    {
        pix[arSiz+1][y]=pix[1][y];
        pix[0][y]=pix[arSiz][y];
    }
    //копируем строки
 
 
    //копируем столбцы
    for(int x = 0; x < arSiz+2; x++)
    {
        pix[x][arSiz+1]=pix[x][1];
        pix[x][0]=pix[x][arSiz];
    }
    //копируем столбцы
    if(iter==0)
    {
        DrawPixelArray(); //нулевая итерация пропуск свертки
    }
    else
    {
        Conv3x3();
    }
 
}
// копируем строки и столбцы для зацикливания XY области для свертки 3 на 3.
//========================================================
 
 
//========================================================
//расчет заряда в центре каждого пикселя
void  StartGenArr()
{
srand(rnd); //установка числа сид генератора
    for(int x = 1; x < arSiz+1; x++)
    {
        for (int y = 1; y < arSiz+1; y++)
        {
        //сумма заряодов всех точек
        float sum=
        charge(pts[x][y][0],-0.22f,pts[x][y][1],-0.31f,1.0f,10.0f)+
        charge(pts[x][y][0], 0.28f,pts[x][y][1],-0.57f,1.0f,24.0f)+ 
        charge(pts[x][y][0], 0.51f,pts[x][y][1],-0.14f,1.0f,27.0f)+
        charge(pts[x][y][0],-0.23f,pts[x][y][1], 0.64f,1.0f,18.0f)+
        charge(pts[x][y][0],-0.61f,pts[x][y][1],-0.6f, 1.0f,22.0f)+
        charge(pts[x][y][0], 0.48f,pts[x][y][1], 0.63f,1.0f,27.0f)+
        charge(pts[x][y][0], 0.12f,pts[x][y][1], 0.17f,1.0f,20.0f);
        //-------
            if(sum>1.0f)
            {
                pix[x][y]=1;
            }
            else if((double)rand()/RAND_MAX>sum)
            {
                pix[x][y]=0;
            }
            else
            {
                pix[x][y]=1;
            }   
        //-----------
        }
    }
CopyRowColumn();
//DrawPixelArray();
}
//========================================================
 
 
 
//========================================================
//находит 2д вектора рисуемых квадратов
void FindPtsCoord() 
{
float dx=2.0f/(arSiz-1);
float dy=2.0f/(arSiz-1);
float x0=-1.0f;
float y0=-1.0f;
    for(int x = 1; x < arSiz+1; x++)
    {
 
        for (int y = 1; y < arSiz+1; y++)
        {
            pts[x][y][0]=x0; 
            pts[x][y][1]=y0; 
            if(y0<1.0)
            {
                y0=y0+dy;
            }
            else
            {
                y0=-1.0f;
            }
        }
 
        if(x0<1.0)
        {
            x0=x0+dx;
        }
        else
        {
            x0=-1.0f;
        }
    }
StartGenArr();
}
//находит 2д вектора рисуемых квадратов
//========================================================
 
 
 
 
//=========================================================
//таймер  проверяет готов ли рендер, если да то обновляет экран и запуск таймера
void TimerFunction(int value)
{
    if(render_complete) 
    {
        glutSwapBuffers();
        render_complete=0;  
        cout << "iter="<<iter<<endl;
        iter++;
        glutTimerFunc(16, TimerFunction, 1);
        CopyRowColumn();
    }
}
//таймер  проверяет готов ли рендер, если да то обновляет экран и запуск таймера
//=========================================================
 
 
void SetupGL() 
{
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f);
    glScalef(0.99f,0.99f,1.0f);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glClearColor(0, 0, 0, 0);
    glPointSize(float(imSiz)/(arSiz+arSiz*1));
}
 
int main(int argc, char** argv) 
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowSize(imSiz, imSiz); 
    glutInitWindowPosition(500, 200);
    glutCreateWindow("Forest gen");
    SetupGL();
    FindPtsCoord();
    glutTimerFunc(30, TimerFunction, 1);
    glutMainLoop();
    return 0;
}

        charge(pts[x][y][0],-0.22f,pts[x][y][1],-0.31f,1.0f,10.0f)+
        charge(pts[x][y][0], 0.28f,pts[x][y][1],-0.57f,1.0f,24.0f)+