Strona główna » Algorytmy » Artykuły » Wypełnianie Przez Podtapianie
 

Wypełnianie Przez Podtapianie

Wstęp

Wypełnianie przez podtapianie pozwala na zmianę koloru grupy takich samych pikseli np. na obrazku. Jest to bardzo prosty algorytm, ale niestety zużywa bardzo dużo mocy obliczeniowej oraz pamięci komputera. W tym artykule zostanie wyjaśniona jego implementacja.

Algorytm

Algorytm rozpoczyna pracę w dowolnym punkcie (x, y) oraz ma zdefiniowany jaki kolor jest zamieniany na jaki. Jeśli dany punkt jest takiego koloru jak ten, który jest zmieniany to zmieniamy jego kolor, a następnie wykonujemy rekurencyjnie tę operację dla punktów sąsiadujących (zwykle przyjmuje się, że tylko te stykające się krawędzią, ale można też we wszystkich 8 kierunkach). Oto przykładowy obrazek:

11111011
11000200
10222220
10222220
11022201
11100011

Przypuśćmy, że kolorujemy od punktu (3, 2). Zamalowywujemy go i przechodzimy do wywołania tego algorytmu na sąsiadach:

11111011
11000200
10232220
10222220
11022201
11100011

Sąsiedzi są rozpatrywani kolejno w lewo, w górę, w prawo i w dół. W tym przypadku algorytm pomaluje punkt obok na lewo, ale dalej zatrzyma się na ścianie i pozostanie do pomalowania punkt na dole.

11111011
11000200
10332220
10322220
11022201
11100011

Dalej algorytm zacznie przeglądać punkt na prawo i tak rekurencyjnie, aż zostanie uzyskany następujący obrazek:

11111011
11000300
10333330
10333330
11033301
11100011

Złożoność

Algorytm Wypełnianie przez podtapianie nie jest algorytmem optymalnym, ponieważ większość punktów jest sprawdzana wielokrotnie. Pierwsze sprawdzenie następuje w momencie malowania punktu, a następnie ten punkt jest odwiedzany za każdym razem, gdy sąsiad zostanie pomalowany. Podstawowa wersja algorytmu jest rekurencyjna. Oznacza to, że im więcej punktów jest do pokolorowania to zapoptrzebowanie na pamięć znacząco rośnie.

Implementacja

Rekurencja

Poniżej została przedstawiona rekurencyjna wersja algorytmu WypelnijMacierz(), która w zmiennej dane zmianie kolor stary na nowy rozpoczynając zamianę w punkcie (x, y).

  1. static void WypelnijMacierz(int[,] dane, int szer, int wys, int x, int y, int stary, int nowy)
  2. {
  3. if (CzyIstnieje(x, y, szer, wys) && dane[y, x] == stary)
  4. {
  5. dane[y, x] = nowy;
  6. WypelnijMacierz(dane, szer, wys, x + 1, y, stary, nowy);
  7. WypelnijMacierz(dane, szer, wys, x - 1, y, stary, nowy);
  8. WypelnijMacierz(dane, szer, wys, x, y + 1, stary, nowy);
  9. WypelnijMacierz(dane, szer, wys, x, y - 1, stary, nowy);
  10. }
  11. }

Dany punkt malujemy tylko jeśli jego kolor jest odpowiedni i jeśli wogle istnieje, ponieważ jak widać w dalszej części kodu może zostać podany punkt do rozpatrzenia, który niekoniecznie istnieje. Przekazane dane są modyfikowane w miejscu.

Kolejka

Głównym problemem wersji rekurencyjnej jest odkładnie na stos bardzo dużej ilości informacji, dlatego lepszym pomysłem jest utworzenie kolejki na którą będą wrzucane kolejne punkty do zamalowania. Algorytm działa, aż do momentu, gdy kolejka nie jest pusta.

  1. static void WypelnijMacierz(int[,] dane, int szer, int wys, int x, int y, int stary, int nowy)
  2. {
  3. Queue<Punkt> kolejka = new Queue<Punkt>();
  4. kolejka.Enqueue(new Punkt(x, y));
  5. while (kolejka.Count > 0)
  6. {
  7. Punkt pkt = kolejka.Dequeue();
  8. if (!CzyIstnieje(pkt.x, pkt.y, szer, wys) || dane[pkt.y, pkt.x] != stary)
  9. continue;
  10. dane[pkt.y, pkt.x] = nowy;
  11. kolejka.Enqueue(new Punkt(pkt.x + 1, pkt.y));
  12. kolejka.Enqueue(new Punkt(pkt.x - 1, pkt.y));
  13. kolejka.Enqueue(new Punkt(pkt.x, pkt.y + 1));
  14. kolejka.Enqueue(new Punkt(pkt.x, pkt.y - 1));
  15. }
  16. }

Wykorzystanie pętli zamiast rekurencji pozytywnie wpływa na czas działania algorytmu, ale niestety nie rozwiązuje problemu z wielokrotnym sprawdzaniem koloru tego samego punktu.

Testowanie funkcji

W celu przetestowania kodu można skorzystać z poniższego fragmentu programu, który dla podanej macierzy danych oraz informacji o zamienianym kolorze wypisze wynik.

  1. static void Main(string[] args)
  2. {
  3. Console.Write("Podaj wymiar tablicy\n szer, wys = ");
  4. string[] data = Console.ReadLine().Split(' ');
  5. int szer = Convert.ToInt32(data[0]);
  6. int wys = Convert.ToInt32(data[1]);
  7. Console.Write("Podaj miejsce rozpoczęcia\n x, y = ");
  8. data = Console.ReadLine().Split(' ');
  9. int x = Convert.ToInt32(data[0]);
  10. int y = Convert.ToInt32(data[1]);
  11. Console.Write("Podaj zamieniany kolor\n s = ");
  12. int stary = Convert.ToInt32(Console.ReadLine());
  13. Console.Write("Podaj docelowy kolor\n n = ");
  14. int nowy = Convert.ToInt32(Console.ReadLine());
  15. Console.Write("Podaj macierz grafu:\n");
  16. int[,] dane = new int[wys, szer];
  17. for (int i = 0; i < wys; i++)
  18. {
  19. data = Console.ReadLine().Split(' ');
  20. for (int j = 0; j < szer; j++)
  21. {
  22. dane[i, j] = Convert.ToInt32(data[j]);
  23. }
  24. }
  25. WypelnijMacierz(dane, szer, wys, x, y, stary, nowy);
  26. Console.WriteLine("Po wypełnieniu:");
  27. for (int i = 0; i < wys; i++)
  28. {
  29. for (int j = 0; j < szer; j++)
  30. {
  31. Console.Write("{0} ", dane[i, j]);
  32. }
  33. Console.WriteLine();
  34. }
  35. Console.ReadKey();
  36. }

Oto przykładowa macierz obrazku:

  1. 1 1 1 1 1 0 1 1
  2. 1 1 0 0 0 2 0 0
  3. 1 0 2 2 2 2 2 0
  4. 1 0 2 2 2 2 2 0
  5. 1 1 0 2 2 2 0 1
  6. 1 1 1 0 0 0 1 1

Zadania

Zadanie 1

Napisz rekurencyjny algorytm, który będzie zamalowywał sąsiednie pola we wszystkich ośmiu kierunkach (czyli prócz punktów stykających się krawędziami to jeszcze te z którymi tylko rogami). Zastanów się czy taki algorytm jest optymalny. Takim algorytmem będzie możliwa zmiana zmiana koloru obramowania obiektu w przedstawionym w artykule obrazku.