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:

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

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.

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

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

• Kod źródłowy Rekurencja
• Kod źródłowy Kolejka

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.

• Kod źródłowy Zadanie 1