Баг в коде Reaction Diffusion Gray-Scott model

#include <gl/glut.h>
#include <iostream> 
using namespace std;
 
const int imSiz=300; // размер картинки
 
float grid[imSiz+2][imSiz+2][2]={0};  // основной массив
float next[imSiz+2][imSiz+2][2]={0}; // буферный массив
bool render_complete=0;
float
Da=1.0,
Db=0.5,
k=0.062,
f=0.085;
 
 
//==============================================
//==============================================
//рисуем пиксели с окрасом
void drawPixelArray() 
{
    glClear(GL_COLOR_BUFFER_BIT);
    glBegin(GL_POINTS);
    for(int i = 1; i < imSiz+1; i++)
    {
        for (int j = 1; j < imSiz+1; j++)
        {
            float a=grid[i][j][1];
            glColor3f(a, a, a);
            glVertex2i(i,j);
        }
    }
    glEnd();
    render_complete=1;
}
//рисуем пиксели с окрасом
//==============================================
//==============================================
 
 
 
 
//==============================================
//==============================================
//====расчет  новой концетрации 
void conectratCorrection()
{
 
//------------------------------------------
//очистка буфера next
for(int i = 1; i < imSiz+1; i++)
{
    for (int j = 1; j < imSiz+1; j++)
    {
    next[i][j][0]=0;
    next[i][j][1]=0;
    }
}
//очистка буфера next
//------------------------------------------
 
 
 
//------------------------------------------
//свертка массива greed с ядром 3 на 3, лапласиан    
for(int i = 1; i < imSiz+1; i++)
{
    for (int j = 1; j < imSiz+1; j++)
    {
    float sumA=
    grid[i][j][0]*-1.0+
    grid[i-1][j][0]*0.2+
    grid[i+1][j][0]*0.2+
    grid[i][j+1][0]*0.2+
    grid[i][j-1][0]*0.2+
    grid[i-1][j-1][0]*0.05+
    grid[i+1][j-1][0]*0.05+
    grid[i+1][j+1][0]*0.05+
    grid[i-1][j+1][0]*0.05;
 
    float sumB=
    grid[i][j][1]*-1.0+
    grid[i-1][j][1]*0.2+
    grid[i+1][j][1]*0.2+
    grid[i][j+1][1]*0.2+
    grid[i][j-1][1]*0.2+
    grid[i-1][j-1][1]*0.05+
    grid[i+1][j-1][1]*0.05+
    grid[i+1][j+1][1]*0.05+
    grid[i-1][j+1][1]*0.05; 
 
    float a=grid[i][j][0];
    float b=grid[i][j][1];
    //next[i][j][0]=a+(Da*sumA)-(a*b*b)+(f*(1.0-a));
    //next[i][j][1]=b+(Db*sumB)+(a*b*b)-((k+f)*b);
    next[i][j][0]=(Da*sumA)-(a*b*b)+(f*(1.0-a));
    next[i][j][1]=(Db*sumB)+(a*b*b)-((k+f)*b);
    }
}
//свертка массива greed с ядром 3 на 3, лапласиан
//------------------------------------------
 
 
//------------------------------------------
//сумма старых значений  grid и новых next.
for(int i = 1; i < imSiz+1; i++)
{
    for (int j = 1; j < imSiz+1; j++)
    {
        grid[i][j][0]+=next[i][j][0];
        grid[i][j][1]+=next[i][j][1];
    }
}
 
//сумма старых значений  grid и новых next.
//------------------------------------------
drawPixelArray(); 
}
//====расчет  новой концетрации
//==============================================
//==============================================
 
 
//==============================================
//==============================================
//нарисовать квадрат 10 пикселей веществом B
void genArr()
{
for(int i = 0; i < imSiz+2; i++)
{
    for (int j = 0; j < imSiz+2; j++)
    {
        if(i>120 && i<180 && j>120 && j<180)
        {
            grid[i][j][0]=1;
            grid[i][j][1]=1;
        }
        else
        {
            grid[i][j][0]=1;
            grid[i][j][1]=0;
        }
    }
}
//drawPixelArray();
conectratCorrection();
}
//нарисовать квадрат 10 пикселей веществом B
//==============================================
//==============================================
 
 
 
//==============================================
//==============================================
//проверяет готов ли рендер, если да то обновляет экран и запуск таймера
void TimerFunction(int value)
{
    if(render_complete) 
    {
        glutSwapBuffers();
        render_complete=0;
        glutTimerFunc(33, TimerFunction, 1);
        cout << "New frame"<<endl;
        conectratCorrection();
    }
    else
    {
        cout << "Frame lost!----------"<<endl;
    }
}
//проверяет готов ли рендер, если да то обновляет экран и запуск таймера
//==============================================
//==============================================
 
 
void setupGL() 
{
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0, imSiz , imSiz, 0, -1, 1);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glClearColor(0, 0, 0, 0);
    glPointSize(1);
    genArr();
}
 
int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowSize(imSiz, imSiz); 
    glutInitWindowPosition(500, 200);
    glutCreateWindow("Reaction Diffusion Gray-Scott model");
    setupGL();
    glutTimerFunc(33, TimerFunction, 1);
    glutMainLoop();
    return 0;
}

#include <gl/glut.h>
#include <iostream> 
using namespace std;
#include <stdlib.h>
#include <math.h>
#include <iomanip>
 
const int imSiz=300; // размер картинки
 
typedef float(ArrType)[imSiz+2][imSiz+2][2];
ArrType nextArr;   // буферный массив
ArrType grid;  // основной массив
 
ArrType *gridPtr = &grid,  
        *nextArrPtr = &nextArr;   
 
 
 
float ColorArr[imSiz+2][imSiz+2][3]; //  массив для окраса
 
bool render_complete = 0;
 
float dA = 1.0;
float dB = 0.5;
float k = 0.062f;
float feed = 0.055f;
 
int counter;
int FramesPass=50;
 
void swap()
{
    ArrType *temp = gridPtr;
    gridPtr = nextArrPtr;
    nextArrPtr = temp;
}
 
 
float constrain(float x,float a,float b)
{
    if(x<a){return a;}
    if(x>b){return b;}
    return x;
}
 
 
 
float laplaceA(int x,int y) {
  float sumA = 0;
  sumA += grid[x][y][0] * -1;
  sumA += grid[x - 1][y][0] * 0.2f;
  sumA += grid[x + 1][y][0] * 0.2f;
  sumA += grid[x][y + 1][0] * 0.2f;
  sumA += grid[x][y - 1][0] * 0.2f;
  sumA += grid[x - 1][y - 1][0] * 0.05f;
  sumA += grid[x + 1][y - 1][0] * 0.05f;
  sumA += grid[x + 1][y + 1][0] * 0.05f;
  sumA += grid[x - 1][y + 1][0] * 0.05f;
  return sumA;
}
 
float laplaceB(int x, int y) {
  float sumB = 0;
  sumB += grid[x][y][1] * -1.0f;
  sumB += grid[x - 1][y][1] * 0.2f;
  sumB += grid[x + 1][y][1] * 0.2f;
  sumB += grid[x][y + 1][1] * 0.2f;
  sumB += grid[x][y - 1][1] * 0.2f;
  sumB += grid[x - 1][y - 1][1] * 0.05f;
  sumB += grid[x + 1][y - 1][1] * 0.05f;
  sumB += grid[x + 1][y + 1][1] * 0.05f;
  sumB += grid[x - 1][y + 1][1] * 0.05f;
  return sumB;
}
 
 
 
 
 
//==============================================
//рисует пиксели
void drawPixelArray() 
{
    glClear(GL_COLOR_BUFFER_BIT);
    glBegin(GL_POINTS);
    for(int x = 1; x < imSiz+1; x++)
    {
        for (int y = 1; y < imSiz+1; y++)
        {
            glColor3f(ColorArr[x][y][0], ColorArr[x][y][1], ColorArr[x][y][2]);
            glVertex2i(x,y);
        }
    }
    glEnd();
}
//рисует пиксели
//==============================================
 
 
 
 
 
//==============================================
//число от 0 до 1 преобразует в цвет RGB
void ColoringAlgorithm()
{
    for(int x = 1; x < imSiz+1; x++)
    {
        for (int y = 1; y < imSiz+1; y++)
        {
            float color=nextArr[x][y][0]-nextArr[x][y][1];
            color=constrain(color, 0.0f, 1.0f); // наверно на всякий случай тут constrain
            ColorArr[x][y][0]=0.5+0.4*sin(15.1*color+1.6);
            ColorArr[x][y][1]=0.5+0.4*sin(13.1*color+0.4);
            ColorArr[x][y][2]=0.5+0.45*sin(14.2*color-1.5);
        }
    }
    drawPixelArray();
}
//число от 0 до 1 преобразует в цвет RGB
//==============================================
 
 
 
 
 
//===================================================
//расчет  новой концетрации 
void NewConectration()
{
    ArrType &grid = *gridPtr; 
    ArrType &nextArr = *nextArrPtr;
//копирование строки и стольбцов, нужно для правильности свертки
    for(int y = 0; y < imSiz+2; y++)
    {
        grid[imSiz+1][y][0]=grid[1][y][0]; // строка 1 в строку imSiz+1
        grid[0][y][0]=grid[imSiz][y][0]; 
        grid[imSiz+1][y][1]=grid[1][y][1]; 
        grid[0][y][1]=grid[imSiz][y][1]; 
        //cout<<setw(5)<<fixed<<setprecision(1)<<grid[1][y][0];
    }
 
 
////ОТЛАДКА---------------------------------
////показать весь массив
//cout<< "\n";
//cout<< "\n";
//for(int x = 0; x < imSiz+2; x++)
//{
//  for (int y = 0; y < imSiz+2; y++)
//  {
//  cout<<setw(5)<<fixed<<setprecision(1)<<grid[x][y][0];
//  }
//  cout<< "\n";
//}
////показать весь массив
////ОТЛАДКА---------------------------------
 
 
//копирование столбцов
    for(int x = 0; x < imSiz+2; x++)
    {
        grid[x][imSiz+1][0]=grid[x][1][0];
        grid[x][imSiz+1][1]=grid[x][1][1];
        grid[x][0][0]=grid[x][imSiz][0];
        grid[x][0][1]=grid[x][imSiz][1];
 
    }
//копирование строки и стольбцов, нужно для правильности свертки
    //cout<< "\n";
    //cout<< "\n";
////ОТЛАДКА---------------------------------
////показать весь массив
//for(int x = 0; x < imSiz+2; x++)
//{
//  for (int y = 0; y < imSiz+2; y++)
//  {
//  cout<<setw(5)<<fixed<<setprecision(1)<<grid[x][y][0];
//  }
//  cout<< "\n";
//}
////показать весь массив
////ОТЛАДКА---------------------------------
 
 
 
//свертка ядром 3х3
    for(int x = 1; x < imSiz+1; x++)
    {
        for (int y = 1; y < imSiz+1; y++)
        {
            float a = grid[x][y][0];
            float b = grid[x][y][1];
            nextArr[x][y][0] = a + dA * laplaceA(x, y) - a * b * b + feed * (1 - a);
            nextArr[x][y][1] = b + dB * laplaceB(x, y) + a * b * b - (k + feed) * b;
            nextArr[x][y][0] = constrain(nextArr[x][y][0], 0.0f, 1.0f);
            nextArr[x][y][1] = constrain(nextArr[x][y][1], 0.0f, 1.0f);
        }
    }
 
    counter++;
    if(counter==FramesPass) // пропуск окраса N кадров,ускорение дифузии
    {
        ColoringAlgorithm();
    }
    swap();
////====непонятное копирование одного массива в другой с буферным 
////он же в  оригинальном коде "swap" , без этого не пашет
//float temp0,temp1;
//  for(int x = 1; x < imSiz+1; x++)
//  {
//      for (int y = 1; y < imSiz+1; y++)
//      {
//          temp0=grid[x][y][0];
//          temp1=grid[x][y][1];
//          grid[x][y][0]=nextArr[x][y][0];
//          grid[x][y][1]=nextArr[x][y][1];
//          nextArr[x][y][0]=temp0;
//          nextArr[x][y][1]=temp1;
//      }
//  }
////====непонятное копирование одного массива в другой с буферным 
////он же в  оригинальном коде "swap" , без этого не пашет
 
// пропуск окраса N кадров,ускорение дифузии 
    if(counter==FramesPass) 
    {
        counter=0;
        glutSwapBuffers();
        cout << "FramesPass="<<FramesPass<<endl;
        //NewConectration();
    }
NewConectration();
// пропуск окраса N кадров,ускорение дифузии
}
//расчет  новой концетрации 
//===================================================
 
 
 
 
 
//===================================================
//нарисовать примерно прямоугольник в центре массива веществом B
void FillRectangleArea()
{
    for(int x = 0; x < imSiz+2; x++)
    {
        for (int y = 0; y < imSiz+2; y++)
        {
            if(x>110 && x<180 && y>110 && y<180)
            {
                grid[x][y][0]=1.0;
                grid[x][y][1]=1.0;
            }
            else
            {
                grid[x][y][0]=1.0;
                grid[x][y][1]=0.0;
            }
        }
    }
    NewConectration();
}
//нарисовать прямоугольник в центре массива веществом B
//===================================================
 
 
void setupGL() 
{
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0, imSiz , imSiz, 0, -1, 1);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glClearColor(0, 0, 0, 0);
    glPointSize(1);
    FillRectangleArea();
}
 
int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowSize(imSiz, imSiz); 
    glutInitWindowPosition(500, 200);
    glutCreateWindow("Reaction Diffusion Gray-Scott model");
    setupGL();
    glutMainLoop();
    return 0;
}

#include <iostream>
 
template <typename T>
void swap1 (T *a, T *b)
{
    T temp_a = *a;
    *a = *b;
    *b = temp_a;
}
 
int main(int argc, char ** argv)
{
    const int size = 5;
    int a[size] = { 1, 2, 3, 4, 5 };
    int b[size] = { 5, 4, 3, 2, 1 };
 
    int *pa = a, *pb = b;
 
    swap1(&pa, &pb);
 
    for (int i = 0; i < size; ++i)
        std::cout << pa[i] << ' ';
    std::cout << std::endl;
    for (int i = 0; i < size; ++i)
        std::cout << pb[i] << ' ';
 
 
    return 0;
}

#include <iostream>
using namespace std;
 
template <typename T>
void swap1 (T *a, T *b)
{
    T temp_a = *a;
    *a = *b;
    *b = temp_a;
}
 
int main(int argc, char ** argv)
{
    int a(5), b(6);
    int *pa = &a;
    int *pb = &b;
 
    cout << *pa << " " << *pb << endl;
        swap1 (&pa, &pb);
        cout << *pa << " " << *pb << endl;
 
    return 0;
}

int iterNoRender=1;//сколько итераций без рендера пропускать,

float t1=2.08f; // корректирует сумму элементов свертки к единице.
float t2=1.25f; // корректирует сумму элементов свертки к единице.

#include <gl/glut.h>
//#include <iostream> 
//using namespace std;
//#include <iomanip>
 
const int imSiz=300; // размер картинки
int iterNoRender=3;//сколько итераций без рендера пропускать,
                    //ускорение анимации 
 
float smallConcentration=0.7f;  
float noiseLim=0.00001f; // плотность  положения рандом точек начальной концентрации
float setConcentrationUp=1.0f; // концентрации растворов
float setConcentrationDn=0.7f; //
 
 
float con3x3w[3][3]=
{
{0.05f, 0.07f, 0.05f},
{0.07f, 0.0f,  0.07f},
{0.05f, 0.07f, 0.05f}
};
//дефалт
//{0.05f, 0.07f, 0.05f},
//{0.07f, 0.0f,  0.07f},
//{0.05f, 0.07f, 0.05f}
 
 
float con5x5w[5][5]=
{
{0.01f, 0.02f, 0.03f, 0.02f, 0.01f},
{0.02f, 0.0f,  0.0f,  0.0f,  0.02f},
{0.03f, 0.0f,  0.0f,  0.0f,  0.03f},
{0.02f, 0.0f,  0.0f,  0.0f,  0.02f},
{0.01f, 0.02f, 0.03f, 0.02f, 0.01f}
};
 
//дефалт
//{0.01f, 0.02f, 0.03f, 0.02f, 0.01f},
//{0.02f, 0.0f,  0.0f,  0.0f,  0.02f},
//{0.03f, 0.0f,  0.0f,  0.0f,  0.03f},
//{0.02f, 0.0f,  0.0f,  0.0f,  0.02f},
//{0.01f, 0.02f, 0.03f, 0.02f, 0.01f}
 
int rnd=10; //сид рандома
int counter;
 
float arr[imSiz+4][imSiz+4]={0};  // основной массив
//float arr[7][7]=
//{
//{0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,},
//{0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,},
//{0.0f, 0.0f, 1.0f, 2.0f, 3.0f, 0.0f, 0.0f,},
//{0.0f, 0.0f, 4.0f, 5.0f, 6.0f, 0.0f, 0.0f,},
//{0.0f, 0.0f, 7.0f, 8.0f, 9.0f, 0.0f, 0.0f,},
//{0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,},
//{0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,},
//};
 
 
float buf[imSiz+4][imSiz+4]={0}; // буферный массив
short int  im2,im1,ip1,ip2,jm2,jm1,jp1,jp2;
//float arrVal,arrMin,arrMax,arrMaxMinDelta,randNoise,sum,sumAct, sumInh;;
 
 
void copyRowColumn(); //обьявление функции
bool render_complete=0;
 
 
 
//=========================================
//рисует пиксели
void drawPixelArray()
{ 
    glClear(GL_COLOR_BUFFER_BIT);
    glBegin(GL_POINTS);
    for(int x = 2; x<imSiz+2; x++)
    {
        for (int y = 2; y <imSiz+2; y++)
        {
            float a=arr[x][y];
            glColor3f(a, a, a);     
            glVertex2i(x,y);
        }
    }
    glEnd();
    //render_complete=1;
}
//рисует пиксели
//=========================================
 
 
 
 
//=========================================
//нормализаия концентрации в диапазон от 0 до 1
void conectratNormalization()
{
//поиск макс мин значений в массиве arr
float arrMin=100;
float arrMax=-100;
    for(int x = 2; x < imSiz+2; x++)
    {
        for (int y = 2; y <imSiz+2; y++)
        {
            float a=arr[x][y];
            if(a>arrMax)
            {
                arrMax=a;
            }
            if(a<arrMin)
            {
                arrMin=a;
            }
        }
    }
//поиск макс мин значений в массиве arr
 
 
//нормализация значений в массиве arr
float arrMaxMinDelta=arrMax-arrMin;
    for(int x = 2; x< imSiz+2; x++)
    {
        for (int y= 2; y <imSiz+2; y++)
        {
            arr[x][y]=(arr[x][y]-arrMin)/arrMaxMinDelta;
        }
    }
//нормализация значений в массиве arr
 
//пропуск iterNoRender интераций без рендера, ускорение анимации 
counter++; // подсчет кол-ва итераций
    if(counter==iterNoRender) 
    {
        drawPixelArray();
        render_complete=1;
        counter=0;
        //cout << "Render complete frames passed="<<FramesPass<<endl;
    }
    else
    {
        if(counter<iterNoRender)
        {
            copyRowColumn();
        }
    }
//пропуск iterNoRender интераций без рендера, ускорение анимации 
//drawPixelArray();
}
//нормализаия концентрации в диапазон от 0 до 1
//=========================================
 
 
 
 
 
//=========================================================
//коррекция концентрации на малую величину smallConcentration 
void conectratCorrection()
{
    for(int i = 2; i <imSiz+2; i++)
    {
        for (int j = 2; j <imSiz+2; j++)
        {
//подсчет адресов массивов заранее
 
im2=i-2;
im1=i-1;
ip1=i+1;
ip2=i+2;
 
jm2=j-2;
jm1=j-1;
jp1=j+1;
jp2=j+2;
//подсчет адресов массивов заранее
 
//средняя сумма 8 элементов вокруг текущего
//по описанию в книге малый радиус это активатор Act.
//ядро свертки 3 на 3
float t1=2.08f; // корректирует сумму элементов свертки к единице.
float sum=
(
arr[im1][jp1]*con3x3w[0][0] +arr[i][jp1]*con3x3w[0][1]  +arr[ip1][jp1]*con3x3w[0][2]
+arr[im1][j]*con3x3w[1][0]                                  +arr[ip1][j]*con3x3w[1][2]
+arr[im1][jm1]*con3x3w[2][0]    +arr[i][jm1]*con3x3w[2][1]  +arr[ip1][jm1]*con3x3w[2][2]
);
float sumAct=t1*sum;
//ядро свертки 3 на 3
 
//средняя сумма 24 элементов вокруг текущего
//по описанию в книге больший радиус это ингибитор Inh.
//ядро свертки 5 на 5
float t2=1.25f; // корректирует сумму элементов свертки к единице.
float sumInh=t2*
(sum // сумма от ядра 3 на 3
+arr[im2][jp2]*con5x5w[0][0] +arr[im1][jp2]*con5x5w[0][1]   +arr[i][jp2]*con5x5w[0][2]  +arr[ip1][jp2]*con5x5w[0][3]        +arr[ip2][jp2]*con5x5w[0][4]
+arr[im2][jp1]*con5x5w[1][0]                                                                                                    +arr[ip2][jp1]*con5x5w[1][4]
+arr[im2][j]  *con5x5w[2][0]                                                                                                    +arr[ip2][j]  *con5x5w[2][4]
+arr[im2][jm1]*con5x5w[3][0]                                                                                                    +arr[ip2][jm1]*con5x5w[3][4]
+arr[im2][jm2]*con5x5w[4][0] +arr[im1][jm2]*con5x5w[4][1]   +arr[i][jm2]*con5x5w[4][2]   +arr[ip1][jm2]*con5x5w[4][3]       +arr[ip2][jm2]*con5x5w[4][4]
);
//ядро свертки 5 на 5
 
//корекция концентрации
            if(sumAct>sumInh)
            {
                buf[i][j]=smallConcentration; 
            }
            else
            {
                buf[i][j]=-smallConcentration; 
            }
        }
    }
//корекция концентрации
 
//обновляем концентрации прибавляя buf к arr
    for(int x = 2; x < imSiz+2; x++)
    {
        for (int y = 2; y < imSiz+2; y++)
        {
                arr[x][y]+=buf[x][y];
        }
    }
//обновляем концентрации прибавляя buf к arr
 
conectratNormalization();
//drawPixelArray();
//glutSwapBuffers();
}
//коррекция концентрации на малую величину smallConcentration 
//=========================================================
 
 
 
 
//================================================
//копируем столбцы и строки для ускорения свертки и правильности свертки
void copyRowColumn() 
{
    //копируем строки
    for(int y = 2; y < imSiz+2; y++)
    {
        arr[imSiz+2][y]=arr[2][y];
        arr[imSiz+3][y]=arr[3][y];
        arr[0][y]=arr[imSiz][y];
        arr[1][y]=arr[imSiz+1][y];
    }
    //копируем строки
 
    //копирование столбцов
    for(int x = 0; x < imSiz+4; x++)
    {
        arr[x][imSiz+2]=arr[x][2];
        arr[x][imSiz+3]=arr[x][3];
        arr[x][0]=arr[x][imSiz];
        arr[x][1]=arr[x][imSiz+1];
    }
    //копирование столбцов
//drawPixelArray();
//glutSwapBuffers();
conectratCorrection();
}
//копируем столбцы и строки для ускорения свертки 
//============================================
 
 
 
 
//============================================
//стартовая генерация концентраций
void genArr()
{
srand(rnd); //число сид генератора
    //записываем всем элментам рандом кроме отступ 2 строки и столбца
    for(int i = 2; i < imSiz+2; i++)
    {
        for (int j = 2; j < imSiz+2; j++)
        {
            float rnd=(float)rand()/RAND_MAX;
            if(rnd<noiseLim)
            {
                arr[i][j]=setConcentrationUp;
            }
            else
            {
                arr[i][j]=setConcentrationDn;
            }
        //cout<<setw(5)<<fixed<<setprecision(0)<<arr[i][j];
        }
        //cout<< "\n";
    }
    //записываем всем элментам рандом кроме отступ 2 строки и столбца
copyRowColumn();
}
//стартовая генерация концентраций
//============================================
 
 
//==============================================
//таймер  проверяет готов ли рендер, если да то обновляет экран и запуск таймера
void TimerFunction(int value)
{
    if(render_complete) 
    {
        glutSwapBuffers();
        render_complete=0;
        glutTimerFunc(30, TimerFunction, 1);
        //cout << "New frame----------"<<endl;
        copyRowColumn();
    }
    else
    {
        //cout << "Frame lost!----------"<<endl;
        //glutTimerFunc(16, TimerFunction, 1);
        
    }
}
//таймер  проверяет готов ли рендер, если да то обновляет экран и запуск таймера
//==============================================
 
void setupGL() 
{
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0, imSiz , imSiz, 0, -1, 1);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glClearColor(0, 0, 0, 0);
    glPointSize(1.0);
}
 
int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowSize(imSiz, imSiz); 
    glutInitWindowPosition(500, 200);
    glutCreateWindow("Reaction Diffusion");
    setupGL();
    genArr();
    glutTimerFunc(33, TimerFunction, 1);
    glutMainLoop();
    return 0;
}