srbija

 private void btnObeleziKandidate_Click(object sender, EventArgs e)
        {
            Bitmap bmp = imageEditorDisplay1.mapa.bmp;
            byte[,] oSlika = ImageUtil.bitmapToByteMatrix(bmp);
            byte[,] slika = ImageUtil.matrixToBinary(oSlika, 200);

            int w = slika.GetLength(1);
            int h = slika.GetLength(0);

            kandidati = ImageUtil.regionLabeling(slika);
            foreach (RasterRegion reg in kandidati)
            {
                reg.odrediMomente();
            }

            // ovde spojiti tacke i kukice njima odgovarajucim slovima
            kandidati = SpojiTackeIKukice(kandidati);

            foreach (RasterRegion reg in kandidati)
            {
                reg.odrediMomente();
            }

            // ovde sloziti slova u redove i kolone
            String[] linije = tbTrenningSet.Text.Replace("\r", "").Split('\n');
            String slova = tbTrenningSet.Text.Replace("\n", "").Replace("\r", "");
            int rr = 0;
            List<RasterRegion> slozeniKandidati = new List<RasterRegion>();
            for (int i = 0; i < linije.Length; i++)
            {
                String linija = linije[i];
                int N = linija.Length;
                List<RasterRegion> red = new List<RasterRegion>();
                for (int j = 0; j < N; j++)
                {
                    red.Add(kandidati[rr]);
                    rr++;
                }
                red.Sort(new DigitalImage.util.RasterRegion.RComparer());
                foreach (RasterRegion regS in red)
                    slozeniKandidati.Add(regS);
            }
            kandidati = slozeniKandidati;

            int regId = 0;
            int redBr = 0;
            foreach (RasterRegion reg in kandidati)
            {
                List<Tacka> tacke = new List<Tacka>();
                tacke.Add(new Tacka(reg.minX - 1, reg.minY - 1));
                tacke.Add(new Tacka(reg.maxX + 1, reg.minY - 1));
                tacke.Add(new Tacka(reg.maxX + 1, reg.maxY + 1));
                tacke.Add(new Tacka(reg.minX - 1, reg.maxY + 1));
                Poligon rec = new Poligon(tacke, Color.FromArgb(10, Color.Green));
                imageEditorDisplay1.selectedIndexer.add(rec);
                reg.Tag = "" + slova[regId];
                if (!alfabet.ContainsKey(reg.Tag))
                {
                    alfabet.Add(reg.Tag, redBr);
                    alfabetInv.Add(redBr, reg.Tag);
                    redBr++;
                }

                Labela lbl = new Labela(reg.minX - 1, reg.minY - 1);
                lbl.boja = Color.Red;
                lbl.labela = reg.Tag;
                imageEditorDisplay1.selectedIndexer.add(lbl);
                regId++;
            }
            imageEditorDisplay1.FitImage();
            imageEditorDisplay1.Refresh();
        }

        double[, ,] obucavajuciSkup = null;
        int brojUzoraka = 0;
        private void btnTrainingSet_Click(object sender, EventArgs e)
        {
            brojUzoraka = kandidati.Count;
            obucavajuciSkup = new double[brojUzoraka, 2, 64];
            Size size = new Size(64, 64);
            for (int uzorak = 0; uzorak < brojUzoraka; uzorak++)
            {
                RasterRegion reg = kandidati[uzorak];

                byte[,] regSlika = reg.odrediNSliku(); // ispravi region da stoji uspravno
                byte[,] nSlika = ImageUtil.resizeImage(regSlika, size); // resize na 64x64
                double[] ulaz = pripremiSlikuZaVNM(nSlika); // kreiraj vektor od 64 elementa na osnovu 64x64 slike
                int index = alfabet[reg.Tag]; // nadji koji je index (u izlaznom sloju) obelezeni region

                // formiranje obucavajuceg skupa
                // - na ulaze neuronske mreze dovodi se kreirani vektor od 64 elementa
                for (int k = 0; k < ulaz.Length; k++)
                {
                    obucavajuciSkup[uzorak, 0, k] = ulaz[k];
                }

                // - na izlaz koji odgovara indeksu postaviti 1, na ostale 0
                for (int ii = 0; ii < alfabet.Count; ii++)
                {
                    if (ii == index)
                        obucavajuciSkup[uzorak, 1, ii] = 1;
                    else
                        obucavajuciSkup[uzorak, 1, ii] = 0;
                }
            }

            MessageBox.Show("Obucavajuci skup formiran! ");
        }

        private void btnTraining_Click(object sender, EventArgs e)
        {
            if (bp != null)
            {
                brojUzoraka = obucavajuciSkup.GetLength(0) + bp.obucavajuciSkup.GetLength(0);
                double[, ,] novi = new double[brojUzoraka, 2, 64];
                for (int i = 0; i < brojUzoraka; i++)
                {
                    if (i < obucavajuciSkup.GetLength(0))
                    {
                        for (int j = 0; j < obucavajuciSkup.GetLength(1); j++)
                        {
                            for (int k = 0; k < obucavajuciSkup.GetLength(2); k++)
                            {
                                novi[i, j, k] = obucavajuciSkup[i, j, k];
                            }
                        }
                    }
                    else
                    {
                        for (int j = 0; j < bp.obucavajuciSkup.GetLength(1); j++)
                        {
                            for (int k = 0; k < bp.obucavajuciSkup.GetLength(2); k++)
                            {
                                novi[i, j, k] = bp.obucavajuciSkup[i - obucavajuciSkup.GetLength(0), j, k];
                            }
                        }
                    }
                }

                obucavajuciSkup = novi;
            }
            bp = new BackPropagation(obucavajuciSkup);
            bp.obuci();

            Function f1 = new Function(Color.Red, bp.greske, Function.VBAR);
            List<Function> ff = new List<Function>();
            ff.Add(f1);
            FrmChart chart = new FrmChart(ff);
            chart.Show();
        }
        /// <summary>
        /// Funkcija sluzi za spajanje kukica iznad slova i tih slova u jedan region.
        /// </summary>
        /// <param name="regions"></param>
        /// <returns></returns>
        private List<RasterRegion> SpojiTackeIKukice(List<RasterRegion> regions)
        {
            // spojiti regione na takav nacin da
            // tacke iznad slova (npr. u  i,j)
            // i kukice iznad slova (npr. u š,č,ć,ž)
            // ne budu zasebni regioni, već da pripadaju celom slovu


            //ris ASD  (radi za sifru 1)
            //Kukice iznad slova
            List<RasterRegion> kukiceZaBrisanje = new List<RasterRegion>();
            foreach (RasterRegion kukica in regions)
            {
                foreach (RasterRegion slovo in regions)
                {
                    //za kukice koje su iznad slova
                    if (kukica.maxY < slovo.minY) //ako je kukica negde iznad slova
                    {
                        if (kukica.minX < slovo.maxX && kukica.maxX > slovo.minX) //ako se kukica bar jednim delom nalazi iznad bas tog slova

                        {
                            int y_raz = slovo.minY - kukica.maxY;    //rastojanje izmedju slova i kukice
                            if (y_raz > 0 && y_raz < ((slovo.maxY - slovo.minY) * 0.40))  //ako to rastojanje nije vece od jedne trecine slova
                            {
                                slovo.points.AddRange(kukica.points); //slovo prosirujemo sa kukicom
                                kukiceZaBrisanje.Add(kukica); //kukica ce biti kasnije obrisana
                                slovo.minY = kukica.minY;   //bez ovog doda tacke i ali ne promeni dimenziju, pa ne radi za 2 kukice
                            }
                        }
                    }

                }
            }
            foreach (RasterRegion kukica in kukiceZaBrisanje)
            {
                regions.Remove(kukica);  //iz regiona brisemo kukice, a ostavljamo cela slova
            }

            //Kukice iznad kukice iznad slova (u slucaju kada imamo 2 kukice iznad jednog slova)
            kukiceZaBrisanje.Clear();
            foreach (RasterRegion kukica in regions)
            {
                foreach (RasterRegion slovo in regions)
                {
                    //za kukice koje su iznad slova
                    if (kukica.maxY < slovo.minY) //ako je kukica negde iznad slova
                    {
                        if (kukica.minX < slovo.maxX && kukica.maxX > slovo.minX) //ako se kukica bar jednim delom nalazi iznad bas tog slova
                        {
                            int y_raz = slovo.minY - kukica.maxY;    //rastojanje izmedju slova i kukice
                            if (y_raz > 0 && y_raz < ((slovo.maxY - slovo.minY) * 0.25))  //ako to rastojanje nije vece od jedne trecine slova
                            {
                                slovo.points.AddRange(kukica.points); //slovo prosirujemo sa kukicom
                                kukiceZaBrisanje.Add(kukica); //kukica ce biti kasnije obrisana
                            }
                        }
                    }

                }
            }
            foreach (RasterRegion kukica in kukiceZaBrisanje)
            {
                regions.Remove(kukica);  //iz regiona brisemo kukice, a ostavljamo cela slova
            }

            //Kukica ispod slova
            List<RasterRegion> kukiceZaBrisanje2 = new List<RasterRegion>();
            foreach (RasterRegion kukica in regions)
            {
                foreach (RasterRegion slovo in regions)
                {
                    //za kukice koje su ispod slova
                    if (kukica.maxY > slovo.minY)   //ako je kukica negde ispod slova
                    {
                        if (kukica.minX < slovo.maxX && kukica.maxX > slovo.minX) //ako se kukica bar jednim delom nalazi iznad bas tog slova
                        {
                            int y_raz = kukica.minY - slovo.maxY;    //rastojanje izmedju slova i kukice
                            if (y_raz > 0 && y_raz < ((slovo.maxY - slovo.minY) * 0.35))  //ako to rastojanje nije vece od jedne trecine slova
                            {
                                slovo.points.AddRange(kukica.points); //slovo prosirujemo sa kukicom
                                kukiceZaBrisanje2.Add(kukica); //kukica ce biti kasnije obrisana
                            }
                        }
                    }
                }
            }
            foreach (RasterRegion kukica in kukiceZaBrisanje2)
            {
                regions.Remove(kukica);  //iz regiona brisemo pojedinacne i ostavljamo samo cele
            }
            //****************************************************************************************************edited
            //Kukice iznad kukice iznad slova (u slucaju kada imamo 2 kukice iznad jednog slova)
            kukiceZaBrisanje.Clear();
            foreach (RasterRegion kukica in regions)
            {
                foreach (RasterRegion slovo in regions)
                {
                    //za kukice koje su desno od slova
                    //if (kukica.maxY < slovo.minY) //ako je kukica negde iznad slova
                    //{
                        if (kukica.maxY < slovo.maxY && kukica.maxY > slovo.minY) //ako se kukica bar jednim delom nalazi iznad bas tog slova
                        {
                            int x_raz = Math.Abs(kukica.maxX - slovo.maxX);    //rastojanje izmedju slova i kukice
                            if (x_raz < ((slovo.maxY - slovo.minY) * 0.30))  //ako to rastojanje nije vece od jedne trecine slova
                            {
                                slovo.points.AddRange(kukica.points); //slovo prosirujemo sa kukicom
                                kukiceZaBrisanje.Add(kukica); //kukica ce biti kasnije obrisana
                            }
                        }
                    //}

                }
            }
            foreach (RasterRegion kukica in kukiceZaBrisanje)
            {
                regions.Remove(kukica);  //iz regiona brisemo kukice, a ostavljamo cela slova
            }
            //****************************************************************************************************
            return regions;
        }