private void WczytajUstawienia()
        {
            if (!File.Exists(PLIK_KONFIGURACYJNY))
            {
                return;
            }

            FileStream fs = new FileStream(PLIK_KONFIGURACYJNY, FileMode.Open);

            if (fs.Length != PLIK_DLUGOSC)
            {
                throw new IOException("Plik konfiguracyjny ma nieprawidłową długość.");
            }
            fs.Seek(0, SeekOrigin.Begin);
            byte[] b = new byte[ILOSC_KANALOW];


            fs.Read(b, 0, ILOSC_KANALOW);
            pionki_min = new KolorHSV(b);

            fs.Read(b, 0, ILOSC_KANALOW);
            pionki_max = new KolorHSV(b);

            fs.Read(b, 0, ILOSC_KANALOW);
            damki_min = new KolorHSV(b);

            fs.Read(b, 0, ILOSC_KANALOW);
            damki_max = new KolorHSV(b);

            fs.Read(b, 0, ILOSC_KANALOW);
            pionki_wrog_min = new KolorHSV(b);

            fs.Read(b, 0, ILOSC_KANALOW);
            pionki_wrog_max = new KolorHSV(b);

            fs.Read(b, 0, ILOSC_KANALOW);
            damki_wrog_min = new KolorHSV(b);

            fs.Read(b, 0, ILOSC_KANALOW);
            damki_wrog_max = new KolorHSV(b);

            fs.Read(b, 0, ILOSC_KANALOW);
            pola_min = new KolorHSV(b);

            fs.Read(b, 0, ILOSC_KANALOW);
            pola_max = new KolorHSV(b);

            fs.Close();
        }
        private void AnalizujPlansze(Mat obraz, KolorHSV min, KolorHSV max, ref VectorOfVectorOfPoint kontury, ref Mat obrazWyciety)
        {
            //NamedWindow("Test progów");

            Mat          obr    = new Mat();
            List <Point> pola   = new List <Point>();
            Mat          zakres = new Mat();

            InRange(obraz, min.DoTablicy(), max.DoTablicy(), zakres);
            BitwiseAnd(obraz, obraz, obrazWyciety, zakres);

            CvtColor(obrazWyciety, obrazWyciety, ColorConversion.Hsv2Bgr);
            obr = obrazWyciety.Clone();
            CvtColor(obr, obr, ColorConversion.Bgr2Gray);
            Threshold(obr, obr, 0, 255, ThresholdType.Binary);



            //if (pokaz) Imshow("Oryginal", obr);

            Erode(obr, obr, GetStructuringElement(ElementShape.Rectangle, new Size(ELEMENT_STRUKTURALNY1, ELEMENT_STRUKTURALNY1), new Point(-1, -1)), new Point(-1, -1), 1, BorderType.Default, new MCvScalar());
            //if(pokaz) Imshow("Erozja 1", obr);


            Dilate(obr, obr, GetStructuringElement(ElementShape.Rectangle, new Size(ELEMENT_STRUKTURALNY2, ELEMENT_STRUKTURALNY2), new Point(-1, -1)), new Point(-1, -1), 1, BorderType.Default, new MCvScalar());
            //if(pokaz) Imshow("Dylacja", obr);

            Erode(obr, obr, GetStructuringElement(ElementShape.Rectangle, new Size(ELEMENT_STRUKTURALNY3, ELEMENT_STRUKTURALNY3), new Point(-1, -1)), new Point(-1, -1), 1, BorderType.Default, new MCvScalar());
            //if(pokaz) Imshow("Erozja 2", obr);



            IOutputArray hierarchia = new Mat();

            FindContours(obr, kontury, hierarchia, RetrType.Tree, ChainApproxMethod.ChainApproxSimple);
        }
        /// <summary>
        /// Wyświetla okno umożliwiające wybranie zakresu kolorów, używanego do rozpoznania określonych elementów na obrazie.
        /// </summary>
        public void Kalibruj(TypObiektu element)
        {
            wndKalibracja okno;

            KolorHSV min = new KolorHSV(0, 0, 0);
            KolorHSV max = new KolorHSV(255, 255, 255);
            string   kom = "Ustaw zakres tak, aby na obrazie widoczne były tylko ";

            switch (element)
            {
            case TypObiektu.Pola:
                min  = pola_min;
                max  = pola_max;
                kom += "białe pola.";
                break;

            case TypObiektu.Pionki:
                min  = pionki_min;
                max  = pionki_max;
                kom += "Twoje pionki.";
                break;

            case TypObiektu.Damki:
                min  = damki_min;
                max  = damki_max;
                kom += "Twoje damki.";
                break;

            case TypObiektu.PionkiWrog:
                min  = pionki_wrog_min;
                max  = pionki_wrog_max;
                kom += "pionki przeciwnika.";
                break;

            case TypObiektu.DamkiWrog:
                min  = damki_wrog_min;
                max  = damki_wrog_max;
                kom += "damki przeciwnika.";
                break;
            }

            okno = new wndKalibracja(min.H, min.S, min.V, max.H, max.S, max.V, kom);

            okno.Show();
            const string tytul = "Kalibracja";

            NamedWindow(tytul);

            while (okno.Otwarte)
            {
                VectorOfVectorOfPoint kontury = new VectorOfVectorOfPoint();
                Mat wyciety = new Mat();
                AnalizujPlansze(WczytajObraz(), new KolorHSV(okno.Hmin, okno.Smin, okno.Vmin), new KolorHSV(okno.Hmax, okno.Smax, okno.Vmax), ref kontury, ref wyciety);

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

            DestroyWindow(tytul);

            if (okno.DialogResult == DialogResult.OK)
            {
                min = new KolorHSV(okno.Hmin, okno.Smin, okno.Vmin);
                max = new KolorHSV(okno.Hmax, okno.Smax, okno.Vmax);

                switch (element)
                {
                case TypObiektu.Pola:
                    pola_min = min;
                    pola_max = max;
                    break;

                case TypObiektu.Pionki:
                    pionki_min = min;
                    pionki_max = max;
                    break;

                case TypObiektu.Damki:
                    damki_min = min;
                    damki_max = max;
                    break;

                case TypObiektu.PionkiWrog:
                    pionki_wrog_min = min;
                    pionki_wrog_max = max;
                    break;

                case TypObiektu.DamkiWrog:
                    damki_wrog_min = min;
                    damki_wrog_max = max;
                    break;
                }
                ZapiszUstawienia();
            }
        }