// Wypełnianie konturowe algorytmem Smitha
//----------------------------------------

#include <SDL.h>
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <stack>

using namespace std;

// Rozmiar okienka
const int W_W = 640;
const int W_H = 480;

// Aby zmniejszyć ilość przekazywanych argumentów
// do funkcji, wspólne zmienne tworzymy jako globalne
SDL_Window * w;   // Okno
SDL_Surface * s;  // Powierzchnia graficzna okna
stack<int> q;     // Stos
int xs,ys,xe,ye;  // Prostokąt obcinający
Uint32 cc,fc;     // Kolory konturu i wypełnienia

// Funkcja odczytuje kolor piksela na pozycji x,y
//------------------------------------------------
Uint32 ReadPixel(int x, int y)
{
  // Obliczamy adres piksela
  Uint32 * addr = (Uint32 *)s->pixels + x + y * s->w;

  Uint32 color = *addr;
  // Zwracamy kod koloru piksela
  return color & ((s->format->Amask)^-1);
}

// Funkcja zapisuje piksel na pozycji x,y
//---------------------------------------
void WritePixel(int x, int y, Uint32 color)
{
  Uint32 * addr;

  // Obliczamy adres piksela
  addr = (Uint32 *)s->pixels + x + y * s->w;

  // Zapisujemy kolor piksela
  * addr = color;
}

// Funkcja zwraca kod koloru piksela dla danej powierzchni graficznej
//-------------------------------------------------------------------
Uint32 PixelColor(Uint8 r,  Uint8 g,  Uint8 b)
{
  Uint32 color;

  // Obliczamy kod piksela
  color  = (r << s->format->Rshift) & (s->format->Rmask);
  color |= (g << s->format->Gshift) & (s->format->Gmask);
  color |= (b << s->format->Bshift) & (s->format->Bmask);
  return color;
}

// Funkcja znajduje segment
//-------------------------
int FindBSegment(int x, int y)
{
  int x2;

  x2 = x;  // x2 reprezentuje koniec segmentu
  do
    x--;   // próbujemy rozszerzyć segment w lewo
  while((x >= xs) && (ReadPixel(x,y) != cc));
  x++;
  do
    x2++;  // próbujemy rozszerzyć segment w prawo
  while((x2 <= xe) && (ReadPixel(x2,y) != cc));
  q.push(x); q.push(y); q.push(x2-x); // segment na stos
  return x2 + 1;
}

// Funkcja wyszukuje segmenty
//---------------------------
void SearchBSegment(int x, int y, int len)
{
  int x2;
  Uint32 pc;

  x2 = x + len - 1;  // koniec segmentu
  while(x <= x2)     // skanujemy segment
  {
    pc = ReadPixel(x,y);
    if(pc == fc)
    {
      x += 2;
      continue;
    }
    if(pc == cc)
    {
      x++;
      continue;
    }
    x = FindBSegment(x,y);
  }
}

// Rysuje segment w kolorze fc
//----------------------------
void DrawSegment(int x, int y, int len)
{
  Uint32 * addr = (Uint32 *)s->pixels + x + y * s->w;
  while(len--) *(addr++) = fc;
}

// Wypełnianie konturowe
//----------------------
void BoundaryFill(int x, int y)
{
  int len;

  // Obliczamy aktualny prostokąt obcinający
  xs = s->clip_rect.x;
  ys = s->clip_rect.y;
  xe = xs + s->clip_rect.w - 1;
  ye = ys + s->clip_rect.h - 1;

  // Znajdujemy pierwszy segment i umieszczamy go na stosie
  FindBSegment(x,y);
  while(!q.empty())
  {
     // Pobieramy segment ze stosu w odwrotnej kolejności
     len = q.top(); q.pop();
     y   = q.top(); q.pop();
     x   = q.top(); q.pop();

     // Wypełniamy segment kolorem fb
     DrawSegment(x,y,len);

     // Znajdujemy segmenty powyżej i poniżej i umieszczamy je na stosie
     if(y > ys) SearchBSegment(x,y-1,len);
     if(y < ye) SearchBSegment(x,y+1,len);
  }
}

int main(int argc, char* args[])
{
   // Inicjujemy SDL
  if(SDL_Init(SDL_INIT_VIDEO))
  {
    cout << "SDL_Init Error: " << SDL_GetError() << endl;
    return 1;
  }

  // Tworzymy okno
  w = SDL_CreateWindow("Powierzchnia graficzna", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, W_W, W_H, 0);
  if(!w)
  {
    cout << "SDL_CreateWindow Error: " << SDL_GetError() << endl;
    SDL_Quit();
    return 2;
  }

  // Tworzymy powierzchnię graficzną okna
  s = SDL_GetWindowSurface(w);

  // Tworzymy programowy kontekst graficzny
  SDL_Renderer * r = SDL_CreateSoftwareRenderer(s);
  if(!r)
  {
     cout << "SDL_CreateSoftwareRenderer Error: " << SDL_GetError() << endl;
     SDL_DestroyWindow(w);
     SDL_Quit();
     return 3;
  }

  SDL_Rect rect;
  rect.w = W_W / 8;
  rect.h = W_H / 8;

  // Inicjujemy generator pseudolosowy
  srand(time(NULL));

  // Rysujemy po 16 prostokątów przy każdej krawędzi okna
  SDL_LockSurface(s);
  SDL_SetRenderDrawColor(r,255,255,255,255);
  for(int i = 0; i < 16; i++)
  {
    rect.x = rand() % (W_W / 8);
    rect.y = rand() % W_H;
    SDL_RenderDrawRect(r,&rect);
  }
  for(int i = 0; i < 16; i++)
  {
    rect.x = rand() % W_W;
    rect.y = rand() % (W_H / 8);
    SDL_RenderDrawRect(r,&rect);
  }
  for(int i = 0; i < 16; i++)
  {
    rect.x = W_W - rand() % (W_W / 8);
    rect.y = rand() % W_H;
    SDL_RenderDrawRect(r,&rect);
  }
  for(int i = 0; i < 16; i++)
  {
    rect.x = rand() % W_W;
    rect.y = W_H - rand() % (W_H / 8);
    SDL_RenderDrawRect(r,&rect);
  }

  // Ustalamy kolory konturu i wypełnienia
  cc = PixelColor(255,255,255); // Kontur biały
  fc = PixelColor(0,127,0);     // Wypełnienie zielone dla odmiany

  // Wypełniamy od środka
  BoundaryFill(W_W/2,W_H/2);

  SDL_UnlockSurface(s);

  // Uaktualniamy okno na ekranie
  SDL_UpdateWindowSurface(w);

  // Czekamy na zamknięcie okna
  SDL_Event event;
  while(1)
  {
    // Sprawdzamy, czy użytkownik zamyka program
    if(SDL_PollEvent(&event) && event.type == SDL_QUIT) break;
  }

  // Usuwamy kontekst graficzny
  SDL_DestroyRenderer(r);

  // Usuwamy okno
  SDL_DestroyWindow(w);

  // Kończymy pracę z SDL2
  SDL_Quit();

  return 0;
}

// Wypełnianie powodziowe algorytmem Smitha
//-----------------------------------------

#include <SDL.h>
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <stack>

using namespace std;

// Rozmiar okienka
const int W_W = 640;
const int W_H = 480;

// Aby zmniejszyć ilość przekazywanych argumentów
// do funkcji, wspólne zmienne tworzymy jako globalne
SDL_Window * w;   // Okno
SDL_Surface * s;  // Powierzchnia graficzna okna
stack<int> q;     // Stos
int xs,ys,xe,ye;  // Prostokąt obcinający
Uint32 rc,fc;     // Kolory ziarna i wypełnienia

// Funkcja odczytuje kolor piksela na pozycji x,y
//------------------------------------------------
Uint32 ReadPixel(int x, int y)
{
  // Obliczamy adres piksela
  Uint32 * addr = (Uint32 *)s->pixels + x + y * s->w;

  Uint32 color = *addr;
  // Zwracamy kod koloru piksela
  return color & ((s->format->Amask)^-1);
}

// Funkcja zapisuje piksel na pozycji x,y
//---------------------------------------
void WritePixel(int x, int y, Uint32 color)
{
  Uint32 * addr;

  // Obliczamy adres piksela
  addr = (Uint32 *)s->pixels + x + y * s->w;

  // Zapisujemy kolor piksela
  * addr = color;
}

// Funkcja zwraca kod koloru piksela dla danej powierzchni graficznej
//-------------------------------------------------------------------
Uint32 PixelColor(Uint8 r,  Uint8 g,  Uint8 b)
{
  Uint32 color;

  // Obliczamy kod piksela
  color  = (r << s->format->Rshift) & (s->format->Rmask);
  color |= (g << s->format->Gshift) & (s->format->Gmask);
  color |= (b << s->format->Bshift) & (s->format->Bmask);
  return color;
}

// Funkcja znajduje segment
//-------------------------
int FindFSegment(int x, int y)
{
  int x2;

  x2 = x;  // x2 reprezentuje koniec segmentu
  do
    x--;   // próbujemy rozszerzyć segment w lewo
  while((x >= xs) && (ReadPixel(x,y) == rc));
  x++;
  do
    x2++;  // próbujemy rozszerzyć segment w prawo
  while((x2 <= xe) && (ReadPixel(x2,y) == rc));
  q.push(x); q.push(y); q.push(x2-x); // segment na stos
  return x2 + 1;
}

// Funkcja wyszukuje segmenty
//---------------------------
void SearchFSegment(int x, int y, int len)
{
  int x2;
  Uint32 pc;

  x2 = x + len - 1;  // koniec segmentu
  while(x <= x2)     // skanujemy segment
  {
    pc = ReadPixel(x,y);
    if(pc == fc)
    {
      x += 2;
      continue;
    }
    if(pc != rc)
    {
      x++;
      continue;
    }
    x = FindFSegment(x,y);
  }
}

// Rysuje segment w kolorze fc
//----------------------------
void DrawSegment(int x, int y, int len)
{
  Uint32 * addr = (Uint32 *)s->pixels + x + y * s->w;
  while(len--) *(addr++) = fc;
}

// Wypełnianie powodziowe
//-----------------------
void FloodFill(int x, int y)
{
  int len;

  // Obliczamy aktualny prostokąt obcinający
  xs = s->clip_rect.x;
  ys = s->clip_rect.y;
  xe = xs + s->clip_rect.w - 1;
  ye = ys + s->clip_rect.h - 1;

  // Zapamiętujemy kolor ziarna
  rc = ReadPixel(x,y);

  // Znajdujemy pierwszy segment i umieszczamy go na stosie
  FindFSegment(x,y);
  while(!q.empty())
  {
     // Pobieramy segment ze stosu w odwrotnej kolejności
     len = q.top(); q.pop();
     y   = q.top(); q.pop();
     x   = q.top(); q.pop();

     // Wypełniamy segment kolorem fb
     DrawSegment(x,y,len);

     // Znajdujemy segmenty powyżej i poniżej i umieszczamy je na stosie
     if(y > ys) SearchFSegment(x,y-1,len);
     if(y < ye) SearchFSegment(x,y+1,len);
  }
}

int main(int argc, char* args[])
{
   // Inicjujemy SDL
  if(SDL_Init(SDL_INIT_VIDEO))
  {
    cout << "SDL_Init Error: " << SDL_GetError() << endl;
    return 1;
  }

  // Tworzymy okno
  w = SDL_CreateWindow("Powierzchnia graficzna", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, W_W, W_H, 0);
  if(!w)
  {
    cout << "SDL_CreateWindow Error: " << SDL_GetError() << endl;
    SDL_Quit();
    return 2;
  }

  // Tworzymy powierzchnię graficzną okna
  s = SDL_GetWindowSurface(w);

  // Tworzymy programowy kontekst graficzny
  SDL_Renderer * r = SDL_CreateSoftwareRenderer(s);
  if(!r)
  {
     cout << "SDL_CreateSoftwareRenderer Error: " << SDL_GetError() << endl;
     SDL_DestroyWindow(w);
     SDL_Quit();
     return 3;
  }

  SDL_Rect rect;
  rect.w = W_W / 8;
  rect.h = W_H / 8;

  // Inicjujemy generator pseudolosowy
  srand(time(NULL));

  // Rysujemy po 16 prostokątów przy każdej krawędzi okna
  SDL_LockSurface(s);
  for(int i = 0; i < 16; i++)
  {
    SDL_SetRenderDrawColor(r,rand()%256,rand()%256,rand()%256,255);
    rect.x = rand() % (W_W / 8);
    rect.y = rand() % W_H;
    SDL_RenderDrawRect(r,&rect);
  }
  for(int i = 0; i < 16; i++)
  {
    SDL_SetRenderDrawColor(r,rand()%256,rand()%256,rand()%256,255);
    rect.x = rand() % W_W;
    rect.y = rand() % (W_H / 8);
    SDL_RenderDrawRect(r,&rect);
  }
  for(int i = 0; i < 16; i++)
  {
    SDL_SetRenderDrawColor(r,rand()%256,rand()%256,rand()%256,255);
    rect.x = W_W - rand() % (W_W / 8);
    rect.y = rand() % W_H;
    SDL_RenderDrawRect(r,&rect);
  }
  for(int i = 0; i < 16; i++)
  {
    SDL_SetRenderDrawColor(r,rand()%256,rand()%256,rand()%256,255);
    rect.x = rand() % W_W;
    rect.y = W_H - rand() % (W_H / 8);
    SDL_RenderDrawRect(r,&rect);
  }

  // Ustalamy kolor wypełnienia
  fc = PixelColor(0,0,255);     // Wypełnienie niebieskie dla odmiany

  // Wypełniamy od środka
  FloodFill(W_W/2,W_H/2);

  SDL_UnlockSurface(s);

  // Uaktualniamy okno na ekranie
  SDL_UpdateWindowSurface(w);

  // Czekamy na zamknięcie okna
  SDL_Event event;
  while(1)
  {
    // Sprawdzamy, czy użytkownik zamyka program
    if(SDL_PollEvent(&event) && event.type == SDL_QUIT) break;
  }

  // Usuwamy kontekst graficzny
  SDL_DestroyRenderer(r);

  // Usuwamy okno
  SDL_DestroyWindow(w);

  // Kończymy pracę z SDL2
  SDL_Quit();

  return 0;
}

// Wypełnianie powodziowe algorytmem Smitha
//----------------------------------------

#include <SDL.h>
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <stack>

using namespace std;

// Rozmiar okienka
const int W_W = 640;
const int W_H = 480;

// Aby zmniejszyć ilość przekazywanych argumentów
// do funkcji, wspólne zmienne tworzymy jako globalne
SDL_Window * w;   // Okno
SDL_Surface * s;  // Powierzchnia graficzna okna
stack<int> q;     // Stos
int xs,ys,xe,ye;  // Prostokąt obcinający
Uint32 rc,fc;     // Kolory ziarna i wypełnienia

// Funkcja odczytuje kolor piksela na pozycji x,y
//------------------------------------------------
Uint32 ReadPixel(int x, int y)
{
  // Obliczamy adres piksela
  Uint32 * addr = (Uint32 *)s->pixels + x + y * s->w;

  Uint32 color = *addr;
  // Zwracamy kod koloru piksela
  return color & ((s->format->Amask)^-1);
}

// Funkcja zapisuje piksel na pozycji x,y
//---------------------------------------
void WritePixel(int x, int y, Uint32 color)
{
  Uint32 * addr;

  // Obliczamy adres piksela
  addr = (Uint32 *)s->pixels + x + y * s->w;

  // Zapisujemy kolor piksela
  * addr = color;
}

// Funkcja zwraca kod koloru piksela dla danej powierzchni graficznej
//-------------------------------------------------------------------
Uint32 PixelColor(Uint8 r,  Uint8 g,  Uint8 b)
{
  Uint32 color;

  // Obliczamy kod piksela
  color  = (r << s->format->Rshift) & (s->format->Rmask);
  color |= (g << s->format->Gshift) & (s->format->Gmask);
  color |= (b << s->format->Bshift) & (s->format->Bmask);
  return color;
}

// Funkcja znajduje segment
//-------------------------
int FindFSegment(int x, int y)
{
  int x2;

  x2 = x;  // x2 reprezentuje koniec segmentu
  do
    x--;   // próbujemy rozszerzyć segment w lewo
  while((x >= xs) && (ReadPixel(x,y) == rc));
  x++;
  do
    x2++;  // próbujemy rozszerzyć segment w prawo
  while((x2 <= xe) && (ReadPixel(x2,y) == rc));
  q.push(x); q.push(y); q.push(x2-x); // segment na stos
  return x2 + 1;
}

// Funkcja wyszukuje segmenty
//---------------------------
void SearchFSegment(int x, int y, int len)
{
  int x2;
  Uint32 pc;

  x2 = x + len - 1;  // koniec segmentu
  while(x <= x2)     // skanujemy segment
  {
    pc = ReadPixel(x,y);
    if(pc == fc)
    {
      x += 2;
      continue;
    }
    if(pc != rc)
    {
      x++;
      continue;
    }
    x = FindFSegment(x,y);
  }
}

// Rysuje segment w kolorze fc
//----------------------------
void DrawSegment(int x, int y, int len)
{
  Uint32 * addr = (Uint32 *)s->pixels + x + y * s->w;
  while(len--) *(addr++) = fc;
}

// Wypełnianie powodziowe
//-----------------------
void FloodFill(int x, int y)
{
  int len;

  // Obliczamy aktualny prostokąt obcinający
  xs = s->clip_rect.x;
  ys = s->clip_rect.y;
  xe = xs + s->clip_rect.w - 1;
  ye = ys + s->clip_rect.h - 1;

  // Zapamiętujemy kolor ziarna
  rc = ReadPixel(x,y);

  // Znajdujemy pierwszy segment i umieszczamy go na stosie
  FindFSegment(x,y);
  while(!q.empty())
  {
     // Pobieramy segment ze stosu w odwrotnej kolejności
     len = q.top(); q.pop();
     y   = q.top(); q.pop();
     x   = q.top(); q.pop();

     // Wypełniamy segment kolorem fb
     DrawSegment(x,y,len);

     // Uaktualniamy okno
     SDL_UnlockSurface(s);
     SDL_UpdateWindowSurface(w);
     SDL_LockSurface(s);

     // Opóźnienie, aby lepiej widzieć
     SDL_Delay(25);

     // Znajdujemy segmenty powyżej i poniżej i umieszczamy je na stosie
     if(y > ys) SearchFSegment(x,y-1,len);
     if(y < ye) SearchFSegment(x,y+1,len);
  }
}

int main(int argc, char* args[])
{
   // Inicjujemy SDL
  if(SDL_Init(SDL_INIT_VIDEO))
  {
    cout << "SDL_Init Error: " << SDL_GetError() << endl;
    return 1;
  }

  // Tworzymy okno
  w = SDL_CreateWindow("Powierzchnia graficzna", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, W_W, W_H, 0);
  if(!w)
  {
    cout << "SDL_CreateWindow Error: " << SDL_GetError() << endl;
    SDL_Quit();
    return 2;
  }

  // Tworzymy powierzchnię graficzną okna
  s = SDL_GetWindowSurface(w);

  // Tworzymy programowy kontekst graficzny
  SDL_Renderer * r = SDL_CreateSoftwareRenderer(s);
  if(!r)
  {
     cout << "SDL_CreateSoftwareRenderer Error: " << SDL_GetError() << endl;
     SDL_DestroyWindow(w);
     SDL_Quit();
     return 3;
  }

  SDL_Rect rect;
  rect.w = W_W / 8;
  rect.h = W_H / 8;

  // Inicjujemy generator pseudolosowy
  srand(time(NULL));

  // Rysujemy po 16 prostokątów przy każdej krawędzi okna
  SDL_LockSurface(s);
  for(int i = 0; i < 16; i++)
  {
    SDL_SetRenderDrawColor(r,rand()%256,rand()%256,rand()%256,255);
    rect.x = rand() % (W_W / 8);
    rect.y = rand() % W_H;
    SDL_RenderDrawRect(r,&rect);
  }
  for(int i = 0; i < 16; i++)
  {
    SDL_SetRenderDrawColor(r,rand()%256,rand()%256,rand()%256,255);
    rect.x = rand() % W_W;
    rect.y = rand() % (W_H / 8);
    SDL_RenderDrawRect(r,&rect);
  }
  for(int i = 0; i < 16; i++)
  {
    SDL_SetRenderDrawColor(r,rand()%256,rand()%256,rand()%256,255);
    rect.x = W_W - rand() % (W_W / 8);
    rect.y = rand() % W_H;
    SDL_RenderDrawRect(r,&rect);
  }
  for(int i = 0; i < 16; i++)
  {
    SDL_SetRenderDrawColor(r,rand()%256,rand()%256,rand()%256,255);
    rect.x = rand() % W_W;
    rect.y = W_H - rand() % (W_H / 8);
    SDL_RenderDrawRect(r,&rect);
  }

  // Ustalamy kolor wypełnienia
  fc = PixelColor(0,0,255);     // Wypełnienie niebieskie dla odmiany

  // Wypełniamy od środka
  FloodFill(W_W/2,W_H/2);

  SDL_UnlockSurface(s);

  // Uaktualniamy okno na ekranie
  SDL_UpdateWindowSurface(w);

  // Czekamy na zamknięcie okna
  SDL_Event event;
  while(1)
  {
    // Sprawdzamy, czy użytkownik zamyka program
    if(SDL_PollEvent(&event) && event.type == SDL_QUIT) break;
  }

  // Usuwamy kontekst graficzny
  SDL_DestroyRenderer(r);

  // Usuwamy okno
  SDL_DestroyWindow(w);

  // Kończymy pracę z SDL2
  SDL_Quit();

  return 0;
}