Aide s.v.p

Signaler
Messages postés
2
Date d'inscription
dimanche 31 janvier 2010
Statut
Membre
Dernière intervention
4 février 2010
-
Messages postés
14934
Date d'inscription
lundi 11 juillet 2005
Statut
Modérateur
Dernière intervention
15 janvier 2021
-
salut
j'ai besoin de vous aide s.v.p pour corriger cet erreur( juste une seule erreur),j'aime savoir sa signification
 //* La fonction classique des C-moyens flous  *//

void FCM(uint8* input,int Nbclasse,int Nbpixels, Segmentation *SEG)
{
int loop,i,j,k,l,n,m;
double sumdenom,num,vdenom,denomcentre,error,diff,C_temp;
double *numcentre=new double[3];
double *v=new double[3];
double *vk=new double[3];
double *x=new double[3];
double *vnum=new double[3];
double *vtemp=new double[3];
double *v0temp=new double[3];
double *vmtemp=new double[3];

double ** Centers=new double*[Nbclasse];

for(i=0;i<Nbclasse;i++)
Centers[i]=new double[3];
double ** Partition=new double*[Nbpixels];

for(i=0;i<Nbpixels;i++)
Partition[i]=new double[Nbclasse];

//--------------------------Initialisation--------------------------------//

//centres
for (i=0;i<Nbclasse;i++)
for(j=0;j<3;j++)
Centers[i][j]=(i+j)*4.0;// l'initialisation n'est pas aléatoire :est ce que c'est important ..!!

// degrés d'appartenance
vk[0]=Centers[0][0];vk[1]=Centers[0][1];vk[2]=Centers[0][2];
for(k=0;k<Nbpixels;k++)
{
x[0]=(double)input[k];x[1]=(double)input[k+Nbpixels];x[2]=(double)input[k+2*Nbpixels];
sumdenom=0.0;
for(m=0;m<Nbclasse;m++)
{
v[0]=Centers[m][0];v[1]=Centers[m][1];v[2]=Centers[m][2];
sumdenom=sumdenom+(diff_norm2(x,vk)/diff_norm2(x,v));
}

Partition[k][0]=1.0/sumdenom;
}

for(m=1;m<Nbclasse;m++)
{
for(k=0;k<Nbpixels;k++)
{
v[0]=Centers[m][0];v[1]=Centers[m][1];v[2]=Centers[m][2];
Partition[k][m]=(diff_norm2(x,vk)/diff_norm2(x,v))*Partition[k][0];
}
}

//--------------------------Fin de l'initialisation--------------------------------//

// Processus itératif
error=1;loop=0;
while (error>ereps && loop<150)
{
// Centers update
vdenom=0.0;
vnum[0]=0.0;vnum[1]=0.0;vnum[2]=0.0;
for(k=0;k<Nbpixels;k++)
{
x[0]=(double)input[k];x[1]=(double)input[k+Nbpixels];x[2]=(double)input[k+2*Nbpixels];
vk[0]=Centers[0][0];vk[1]=Centers[0][1];vk[2]=Centers[0][2];
sumdenom=0.0;
for(m=0;m<Nbclasse;m++)
{
v[0]=Centers[m][0];v[1]=Centers[m][1];v[2]=Centers[m][2];
sumdenom=sumdenom+(diff_norm2(x,vk)/diff_norm2(x,v));
}

Partition[k][0]=1.0/sumdenom;
for(n=0;n<3;n++)
vnum[n]=vnum[n]+Partition[k][0]*Partition[k][0]*x[n];
vdenom=vdenom+Partition[k][0]*Partition[k][0];
}

v0temp[0]=vnum[0]/vdenom;v0temp[1]=vnum[1]/vdenom;v0temp[2]=vnum[2]/vdenom;
vtemp[0]=Centers[0][0];vtemp[0]=Centers[0][1];vtemp[0]=Centers[0][2];			
diff=diff_norm2(vtemp,v0temp);
error=0.0;
for(m=1;m<Nbclasse;m++)
{
vdenom=0.0;
vnum[0]=0.0;vnum[1]=0.0;vnum[2]=0.0;
for(k=0;k<Nbpixels;k++)
{
x[0]=(double)input[k];x[1]=(double)input[k+Nbpixels];x[2]=(double)input[k+2*Nbpixels];
v[0]=Centers[m][0];v[1]=Centers[m][1];v[2]=Centers[m][2];
Partition[k][m]=(diff_norm2(x,vk)/diff_norm2(x,v))*Partition[k][0];
for(n=0;n<3;n++)
vnum[n]=vnum[n]+Partition[k][m]*Partition[k][m]*x[n];
vdenom=vdenom+Partition[k][m]*Partition[k][m];
}
vmtemp[0]=vnum[0]/vdenom;vmtemp[1]=vnum[1]/vdenom;vmtemp[2]=vnum[2]/vdenom;
vtemp[0]=Centers[m][0];vtemp[0]=Centers[m][1];vtemp[0]=Centers[m][2];
diff=diff+diff_norm2(vtemp,v0temp);
Centers[m][0]=vmtemp[0];Centers[m][1]=vmtemp[1];Centers[m][2]=vmtemp[2];
error=max(error,diff);
}

Centers[0][0]=v0temp[0]; Centers[0][1]=v0temp[1];Centers[0][2]=v0temp[2];
loop++;
}// end while


// définition de la segmentation
for(i=0;i<Nbclasse;i++)
{
Cluster* K_current=new Cluster(Nbpixels,1);

//construire les clusters
K_current->Centers[0][0]=Centers[i][0];
K_current->Centers[0][1]=Centers[i][1];
K_current->Centers[0][2]=Centers[i][2];

for (k=0;k<Nbpixels;k++)
{
K_current->ListFuzzy[0]->DegApp[k]=Partition[k][i];
K_current->DegApp[k]=Partition[k][i];
}
K_current->Label=i;
SEG->ajouter(K_current);
delete K_current;
}

// Destruction
delete [] numcentre;
delete [] v,x,vk,vtemp;
delete [] vnum,v0temp,vmtemp;

for(i=0;i<Nbclasse;i++)
delete [] Centers[i];
delete []Centers;

for(i=0;i<Nbpixels;i++)
delete [] Partition[i];

delete []Partition;

}// end function

void Calculer(Segmentation *SEG, uint8 *output, uint8 *input,int Nbpixels)
{
int current_Label,k=0;
float sup = 0.0;
int * inputLabel=new int[Nbpixels];
int taille=SEG->TailleListe();
double **Mean;
Mean=new double*[taille];
for(k=0;k<taille;k++)
Mean[k]=new double[4];


Noeud *courant;

Noeud * courant0 = SEG->tete;
k=0;
while(courant0!=NULL)
{
courant0->element->Label=k;
courant0=courant0->suivant;
k++;
}
//Initialiser Mean
for (k =0; k<taille;k++ )
{
Mean[k][0]=0.0;
Mean[k][1]=0.0;
Mean[k][2]=0.0;
Mean[k][3]=0.0;
}

for (k=0;k<Nbpixels;k++) // parcourir l'image pixel par pixel (colonne par colonne).
{
sup=0.0;
courant = SEG->tete;
while (courant != NULL) // par rapport aux clusters de la SEG
{
if (courant->element->DegApp[k]>sup)
{
current_Label = courant->element->Label;
sup = courant->element->DegApp[k];
}
courant = courant->suivant;
}

inputLabel[k]=current_Label;

Mean[current_Label][0]=((Mean[current_Label][0]*Mean[current_Label][3])+input[k])/(Mean[current_Label][3]+1);
Mean[current_Label][1]=((Mean[current_Label][1]*Mean[current_Label][3])+input[k+Nbpixels])/(Mean[current_Label][3]+1);
Mean[current_Label][2]=((Mean[current_Label][2]*Mean[current_Label][3])+input[k+2*Nbpixels])/(Mean[current_Label][3]+1);
Mean[current_Label][3]=Mean[current_Label][3]+1;
}

for (k=0;k<Nbpixels;k++)
{
output[k]=(uint8)Mean[inputLabel[k]][0];
output[k+Nbpixels]=(uint8)Mean[inputLabel[k]][1];
output[k+2*Nbpixels]=(uint8)Mean[inputLabel[k]][2];
}

for(k=0;k<taille;k++)
delete [] Mean[k];
delete []Mean;
delete []inputLabel;
}

1 réponse

Messages postés
14934
Date d'inscription
lundi 11 juillet 2005
Statut
Modérateur
Dernière intervention
15 janvier 2021
93
Hello,
Quelle est l'erreur?


@+
Buno
----------------------------------------
L'urgent est fait, l'impossible est en cours. Pour les miracles, prévoir un délai...