Ci joint un algo de détourage d'un bmp de qq lignes :
 
Le Binze c'est que des que la zone a détourée est trop importante je me tape un Stack overflow (le nb de fonction récursive empilé est trop important).
 
Cependant j'ai augmenté la taille de la pile à 1Go est à l'execution le programme plante (sur de grosses zones) alors que la mémoire utilisée est de 9-10 Mo.
 
Comprend pas.
 
void CPicture::Def4Connexes(unsigned long offset_pixel,const int & largeur,const int & hauteur)
{
 
BufferDetour[offset_pixel] = 1;
int y = offset_pixel/largeur;
int x = offset_pixel%largeur;
long off = offset_pixel;
//int nb_voisins = 0;
float seuil = 0.8;
 
for(int i=0;i<4;i++)
{
   switch(i){
   case 0:
    off = offset_pixel + 1;//droit
    break;
   case 1:
    off = offset_pixel + largeur;//bas
    break;
   case 2:
    off = offset_pixel -1;//gauche
    break;
   case 3:
    off = offset_pixel - largeur;//haut
    break;
   }
   
  if( ((x-1)>=0) && ((x+1)<largeur) && ((y+1)<hauteur) && ((y-1)>=0) ){
   if( (BufferDetour[off] == 0) && (SimilariteCouleur(bmpBuffer[off]) > seuil)){
  //  nb_voisins++;
    Def4Connexes(off,largeur,hauteur);
   }
  }  
}
  //if(nb_voisins != 4) TabResul[indiceConn++] = offset_pixel; //mise anjour du tableau des contours  
}
 
Zen [B)]

ben t'overflow quoi
fais ca autrement qu'en recursif

quel compilateur ?
t'as pas moyen de réduire le nombre de variables locales ?
(x-1)>=0 -> x>=1
 
combien de profondeut d'appel récursif ? t'es sur que ça s'arrete ?
 
récursivité terminale ?

Ton code ne marche pas, en fait tu boucles.
 
1er  appel D4C(op0, l, h) i=0 ->
2eme appel D4C(op0 +1, l, h) i =2 ->
xeme appel D4C(op0 +1 -1, l, h)
et puisque tu n'a pas d'effet de bords, c'est ==1er appel.
 
Sinon, tu peux sortir ton if ((x-1 blabla y)) du for(..).
Tu pourras p-e t'en sortir en traitant d'abord tous les cas gauche, puis bas, puis ... si l'algo le permet.

première ligne :

condition de récursivité :

 
 
ceci dit j'ai rien pour l'aider, trop la flemme de tailler dans le spaguetti

Pour commencer, utilise les balises cpp pour délimiter le code, c'est beaucoup plus lisible
 

 
Ensuite, rapidement :
 
Pourquoi passer largeur et hauteur par const & ? Disons le, c'est assez ridicule dans ce cas. Passe les par recopie simplement.
 
Pourquoi recopier la variable "offset_pixel" dans la variable "off" ? Aucun interet ici tant que les commentaires restent à leur place.
 
Et pour finir, je prédis un depacement de capacité dans le tableau TabResul Solution recomandée : utiliser un std::vector<long> au lieu de ce que je suppose être un "long [trop_petit_de_toute_facon]" Et utiliser la methode push_back() pour ajouter un element à la fin du tableau.

^^ a ouais, l'avais pas vu. Desole leboss.

j'ai quand même globalement un gros doute sur l'intérêt de la récursivité quand tout passe pas effet de bord.
T'as pas envie de sortir une pile explicite ?

C'est bien cool tout vos messages, je vois que certains maitrise le sujet.
Alors petites informations :
- En itératif cela est d'une lenteur imparable (donc a exclure)
- J'ai vu un algo du même genre tourner surper bien.
- Mon programme n'utilise meme pas 6Mo ram

ça veut dire quoi d'une lenteur imparable ? ton programme est facilement transformable
 
mais je penche encore pour un problème de point fixe : ta condition d'arret n'est peut etre jamais atteinte ? tu nous as toujours pas dit à quelle profondeut de récursion du travailles

 
Je te dis que ça fonctionne sur des zones à détourer petites. L'algo est bon. Le Pb c'est l'overflow non justifié.

 
La condition d'arret est atteinte puisque cela fonctionne sur de petites zones.
 
En termes de profondeur, c'est facile si la zone contient n pixels on une prfondeur de n.

ben passe en itératif bordel
on y peut quoi si ton compilo est pas capable de bien faire l'optimisation ...
 
passe en itératif, c très facile dans ton cas

Puis si l'iteratif est lent, c'est que tu t'y prend mal. Y'à toujours moyen de faire plus rapide en iteratif qu'en récursif.

[+1]
ayé, je viens de reconnaitre l'algo, c'est l'algo du peintre, et je l'avais fait en récursif sans pb, pour faire de la segmentation temps-réel sur de la vidéo. Et mes seul problèmes de perfs étaient la vitesse d'acquisition de la caméra et l'algo de relaxation des étiquettes dont la complexité n'était pas bornée.

bien vu, je l'avais pas reconnu