/// <summary>
        /// Wyświetla obraz z kamery z zaznaczonymi polami, granicami pól i pionkami.
        /// </summary>
        public void PokazObraz()
        {
            PokazywanieObrazu = true;
            const string tytul = "Warcaby";

            NamedWindow(tytul);
            MCvScalar kolor_granice = new MCvScalar(0, 0, 255);

            DanePionka[] dane = new DanePionka[] {
                new DanePionka()
                {
                    min = pionki_min, max = pionki_max, kolor = new MCvScalar(255, 0, 0)
                },
                new DanePionka()
                {
                    min = damki_min, max = damki_max, kolor = new MCvScalar(255, 128, 0)
                },
                new DanePionka()
                {
                    min = pionki_wrog_min, max = pionki_wrog_max, kolor = new MCvScalar(0, 128, 255)
                },
                new DanePionka()
                {
                    min = damki_wrog_min, max = damki_wrog_max, kolor = new MCvScalar(0, 255, 255)
                },
                new DanePionka()
                {
                    min = pola_min, max = pola_max, kolor = new MCvScalar(0, 255, 0)
                }
            };

            while (PokazywanieObrazu)
            {
                Mat obr  = WczytajObraz();
                Mat obr2 = obr.Clone();
                CvtColor(obr2, obr2, ColorConversion.Hsv2Bgr);

                for (int d = 0; d < dane.Length; d++)
                {
                    VectorOfVectorOfPoint kontury = new VectorOfVectorOfPoint();
                    Mat wyciety = new Mat();



                    if (d == 4)
                    {
                        pokaz = true;
                    }

                    AnalizujPlansze(obr, dane[d].min, dane[d].max, ref kontury, ref wyciety);

                    pokaz = false;



                    for (int i = 0; i < kontury.Size; i++)
                    {
                        DrawContours(obr2, kontury, i, dane[d].kolor, 5);
                    }
                }


                if (Plansza != null)
                {
                    Point[][] pkt = new Point[64][];
                    int       i   = 0;
                    Pole      pp;

                    for (int x = 0; x < POLA_WIERSZ; x++)
                    {
                        for (int y = 0; y < POLA_WIERSZ; y++)
                        {
                            pp        = Plansza[x, y];
                            pkt[i]    = new Point[4];
                            pkt[i][0] = new Point(pp.xmin, pp.ymin);
                            pkt[i][1] = new Point(pp.xmax, pp.ymin);
                            pkt[i][2] = new Point(pp.xmax, pp.ymax);
                            pkt[i][3] = new Point(pp.xmin, pp.ymax);
                            i++;
                        }
                    }

                    VectorOfVectorOfPoint p2 = new VectorOfVectorOfPoint(pkt);
                    for (i = 0; i < 64; i++)
                    {
                        DrawContours(obr2, p2, i, kolor_granice, 1);
                    }
                }

                Imshow(tytul, obr2);
                Application.DoEvents();
            }

            DestroyAllWindows();
        }
        /// <summary>
        /// Rozpoznaje pionki na planszy. Przed wywołaniem należy wywołać funkcję RozpoznajPola.
        /// </summary>
        /// <returns>Zwraca pozycje pionków na warcabnicy. Jeśli nie wywołano funkcji RozpoznajPola lub zwróciła ona inną wartość niż 32, funkcja zwraca null.</returns>
        public Pionek[] RozpoznajPionki()
        {
            if (Plansza == null)
            {
                return(null);
            }

            Mat obr = WczytajObraz();
            HashSet <Pionek> pionki = new HashSet <Pionek>();

            DanePionka[] dane = new DanePionka[] {
                new DanePionka()
                {
                    min = pionki_min, max = pionki_max, typ = TypObiektu.Pionki
                },
                new DanePionka()
                {
                    min = damki_min, max = damki_max, typ = TypObiektu.Damki
                },
                new DanePionka()
                {
                    min = pionki_wrog_min, max = pionki_wrog_max, typ = TypObiektu.PionkiWrog
                },
                new DanePionka()
                {
                    min = damki_wrog_min, max = damki_wrog_max, typ = TypObiektu.DamkiWrog
                }
            };

            for (int d = 0; d < dane.Length; d++)
            {
                VectorOfVectorOfPoint kontury = new VectorOfVectorOfPoint();
                Mat wyciety = new Mat();
                AnalizujPlansze(obr, dane[d].min, dane[d].max, ref kontury, ref wyciety);

                Point[][] punkty = kontury.ToArrayOfArray();
                Pole      pole;
                Point     srodek;
                Pole      pp;
                bool      znaleziono;

                for (int i = 0; i < punkty.Length; i++)
                {
                    pole       = new Pole(punkty[i].Min(p => p.X), punkty[i].Max(p => p.X), punkty[i].Min(p => p.Y), punkty[i].Max(p => p.Y));
                    srodek     = new Point(pole.xmin + (pole.xmax - pole.xmin) / 2, pole.ymin + (pole.ymax - pole.ymin) / 2);
                    znaleziono = false;

                    for (int x = 0; x < POLA_WIERSZ; x++)
                    {
                        for (int y = 0; y < POLA_WIERSZ; y++)
                        {
                            pp = Plansza[x, y];

                            if (pp.xmin < srodek.X && pp.xmax > srodek.X && pp.ymin < srodek.Y && pp.ymax > srodek.Y)
                            {
                                pionki.Add(new Pionek()
                                {
                                    x = x, y = y, typ = dane[d].typ
                                });
                                znaleziono = true;
                                break;
                            }
                        }

                        if (znaleziono)
                        {
                            break;
                        }
                    }
                }
            }

            return(pionki.ToArray());
        }