#include "kmeans.h"
#include <iostream>

kmeans::kmeans (double **ma, int hh, int ww, int nbclu, int nbite,double** intervx){

    //parametres de depart
    mat=ma;
    h=hh;
    w=ww;
    nbclus=nbclu;
    nbiter=nbite;
    epsilon=0.000001;
    interv=intervx;
    //-------------------

    //Construction du tabeau contenant les centre de classes
    matclus=new double* [nbclus];
    for( int i=0 ; i < nbclus ; i++ )
      matclus[i] = new double[w];
    //-------------------------------

    //Initialisation
    srand(time(NULL));
    for(int i=0;i<nbclus;i++){
        for(int j=0;j<w;j++){
            double z=interv[j][1]-interv[j][0];
            double e=(rand()*1.0)/RAND_MAX;
            double re=z*e;
            double res=interv[j][0]+re;
            matclus[i][j]=res;
    }
    }

    for(int i=0;i<nbclus;i++){
        for(int j=0;j<w;j++){
            std::cout<<"Les centres initiaux "<<matclus[i][j]<<"  ";
        }
    }

    std::cout<<""<<std::endl;

    //Fabrication du tableau des degrés d'appartenances binaires
    matship = new double* [h];
      for( int i=0 ; i < h ; i++ )
        matship[i] = new double[nbclus];
    //----------------------
    //---------------------

    computemembership();
    oldobj=computeobjectivefunction();
    currentobj=0;



}

double** kmeans::core(){

     std::cout<<""<<std::endl;
    //itération
    for(int k=0;k<nbiter;k++){
        computemembership();
        computeclustercenters();
        currentobj=computeobjectivefunction();
        std::cout<<"Objective function "<<currentobj<<std::endl;
        if(fabs(currentobj-oldobj)<epsilon){
            break;
        }

        oldobj=currentobj;

    }

    return matship;

}

 //calcule de la matrice d'appartenance
void kmeans::computemembership(){
    for(int i=0;i<h;i++){
        double ref=euclid(mat[i],matclus[0],w);
        int in=0;
        for(int j=1;j<nbclus;j++){
            double d=euclid(mat[i],matclus[j],w);
            if(d<ref){
                ref=d;
                in=j;
            }
        }
        for(int q=0;q<nbclus;q++){
            if(q==in){
                matship[i][q]=1;

            }
            else{
                matship[i][q]=0;
            }
        }
    }

    //test if there is an empty cluster
     double* empt=new double[nbclus];
     for(int i=0;i<nbclus;i++){
         empt[i]=0;
     }
     for(int i=0;i<nbclus;i++){
         int c=0;
         for(int j=0;j<h;j++){
             if(matship[j][i]==1){
                c++;
             }
         }
         empt[i]=c;
     }

     bool b=false;
     for(int i=0;i<nbclus;i++){
         //refaire une initialisation pour les empty cluster
         if(empt[i]==0){
             b=true;
                 for(int j=0;j<w;j++){
                     double z=interv[j][1]-interv[j][0];
                     double e=(rand()*1.0)/RAND_MAX;
                     double re=z*e;
                     double res=interv[j][0]+re;
                     matclus[i][j]=res;
                     std::cout<<"je suis res "<<res<<std::endl;
             }
         }
         //-------------------------------------------------
     }
    //--------------------------------

     if(b){
         std::cout<<"Empty cluster détécté"<<std::endl;
         computemembership();
     }


}
//------------------------------------

//calcule des centres de classes
void kmeans::computeclustercenters(){

    double* ve=new double[w];
    for(int j=0;j<nbclus;j++){
        for(int o=0;o<w;o++){
            ve[o]=0;
        }
        double a=0;
        for(int i=0;i<h;i++){
            if(matship[i][j]==1){
                a++;
                for(int v=0;v<w;v++){
                    ve[v]=ve[v]+mat[i][v];
                }
            }
        }
        for(int m=0;m<w;m++){
            matclus[j][m]=ve[m]/a;
        }
    }
}
//------------------------------------------


// Le calcule de la fonction objectif
double kmeans::computeobjectivefunction(){
    double sum=0;
    for(int i=0;i<h;i++){
        for(int j=0;j<nbclus;j++){
            if(matship[i][j]==1){
            double d=euclid(mat[i],matclus[j],w);
            sum=sum+d;
            }
        }
    }
    return sum;
}
//-----------------------------------------------

// calcule la distance euclidienne
double kmeans::euclid(double *vect1, double *vect2, int dim){
    double sum=0;
    for(int i=0;i<dim;i++){
        double a=vect1[i]-vect2[i];
        double c=pow(a,2);
        sum=sum+c;
    }
    double d=sqrt(sum);
    return d;
}
//----------------------------------------------------

kmeans::~kmeans(){
    for(int i=0;i<h;i++){
        delete [] matship[i];
    }
    for(int i=0;i<nbclus;i++){
        delete [] matclus[i];
    }
    for(int i=0;i<w;i++){
        delete [] interv[i];
    }
}