package kui;
// Bayes classifier

import java.util.ArrayList;

public class Bayes extends Classifier implements ClassifierInterface
{
        private int veSkupine=32;//sdružování odstínu do skupin : x odstínu sdruženo do 1 skupiny
        /**
         * Pomocná třída písmeno - slouží jako řádek tabulky - položka kolekce naučenáData
         */
        class Pismeno
        {
            private double pravdepodobnosti[][]=new double[100][256/veSkupine];   //[počet pixelů][počet odstínů]
            private char znak;

            public Pismeno(double[][] pravdepodobnosti,char znak)
            {
                this.pravdepodobnosti=pravdepodobnosti;
                this.znak=znak;
            }

            public char vratZnak(){return znak;}
            public double[][] vratPravdepodobnosti(){return pravdepodobnosti;}
        }

        ArrayList<Pismeno> naucenaData=new ArrayList(); //KOlekce pro uložení naučených dat
/*****************************************************************************************************/
        private double porovnaniPismen(double[] porovnat, double[][]porovnats)
        {
            double x=1;
            int i,o;

            //prodejeme všechny pixely
            for(i=0;i<100;i++)
            {
                x*=0.0001+porovnats[i][ ( (int)porovnat[i] )/ veSkupine  ];                
            }

            return x;
        }

/*****************************************************************************************************/
        /**
         * Tato metoda spočte pravděpodobnost výskytu jednotlivých pixelů dané množiny dat
         */
        private double[][] provedVypocetPravdepodobnosti(ArrayList data)
        {
            //nejdříve vezmeme 1 pixely všech položek, pak 2 .... 100
            int i,o;
            int rozmer=256/veSkupine;
            int[] pocet=new int[rozmer]; //odstíny pixelů
            int celkem;
            double[][] pravdepodobnosti=new double[100][rozmer]; //[počet pixelů][počet odstínů]
            
            //vše si načteme pěkně do pole
            
            //položka je odstín šedi
            double zpracuj[][]=new double[ data.size() ][100]; //[počet údajů o písmenu][počet pixelů]

            for(i=0;i<data.size();i++)
            {
                zpracuj[i]=(double[]) data.get(i);
            }

            //projdeme ty pixely
            for(i=0;i<100;i++)
            {
                for(o=0;o<rozmer;o++)pocet[o]=0;//vynulejeme počítadlo
                celkem=0;
                
                for(o=0;o<data.size();o++)
                {
                    pocet[  (int)zpracuj[o][i]/veSkupine  ]++;
                    celkem++;
                }

                //nyní spočteme pravděpodobnosti jednotlivých úrovní šedi
                for(o=0;o<rozmer;o++)
                {
                    pravdepodobnosti[i][o]=(  (double)pocet[o]  )/(  (double)celkem  );
                }                
            }

            //vrátíme výsledek
            return pravdepodobnosti;
        }

/*****************************************************************************************************/
        public Bayes()
	{
		super();
	}

/*****************************************************************************************************/
	// learns classifier from training data
	public void learn()
	{
		System.out.println("Bayes is learning ...");
                if(matrix==null || labels==null){System.err.println("Prázdná vstupní data");System.exit(1);}
		
		//UCENI
     
                //načtu všechny Ačka, béčka .....
                int i;                
                ArrayList<double[]> data=new ArrayList(); //data jednolivého písmene
                char z=labels.get(0).toString().charAt(0);//aktuálně zpracovávané písmeno
                char z2;                                  //písmeno které je další nařadě
                
                i=0; //režije cyklu <   0 ; labels.size()   )
                //
                while(true)
                {
                    z2=labels.get(i).toString().charAt(0);
                    if(z==z2)
                    {
                        data.add( matrix[i] );
                        i++;
                        if(i==labels.size())
                        {
                            //jsme na konci, musíme ještě vyhodnotit načtená data                           
                            i=0; //fígl - načteme jakoby první znak kteráý jeji než poslední - provede se vyhodnocení
                        }

                    }else{
                       //máme nové písmeno
                        
                       //provedeme zpracování načteného písmene
                       naucenaData.add(    new Pismeno( provedVypocetPravdepodobnosti(data), z )    );

                       //nastavíme nový znak, vynulujeme data
                       z=z2;
                       data.clear();

                       //jsme na konci?
                       if(i==0)break;
                    }
                }
                //END WHILE
		state = "clever";
	}

/*****************************************************************************************************/
	// counts Vector of labels
	public void classify()
	{
		if (state.equals("dump")){System.out.println("Classifier Bayes is not learnt!!!");System.exit(1);}
                if(matrix==null || labels==null){System.err.println("Prázdná vstupní data");System.exit(1);}
		System.out.println("\nBayes is classifying ...");
		
                //ROZPOZNANI
                int rozmer=256/veSkupine;
                int i,o;
                char vysledek;
                double[][] pravd=new double[100][rozmer]; //[počet pixelů][odstín šedi]
                double nejD;                
                double mezivypocet;

                for(i=0;i<matrix.length;i++)
                {
                    //vypočteme pravděpodobnost jednotlivých odstínů jednotlivých piexlů                    
                    nejD=Double.NEGATIVE_INFINITY;
                    vysledek='?';

                    //najdeme nejlepší shodu s naučenými daty
                    for(o=0;o<naucenaData.size();o++)
                    {                        
                        mezivypocet=porovnaniPismen( matrix[i],naucenaData.get(o).vratPravdepodobnosti() );
                        //porovnáme s předchozími výsledky
                        if(mezivypocet>nejD)
                        {
                            nejD=mezivypocet;
                            vysledek=naucenaData.get(o).vratZnak();                            
                        }
                    }

                    //
                    result_labels.add(vysledek);
                }
	}
/*****************************************************************************************************/
        
}