Bonjour,
 
j'ai un probleme avec une fonction reccursive.
Le code s'exécute mais, il arrive un moment où l'exception  
StackOverflowError est levée. Je me demande si cette erreur n'est pas liée à la mémoire virtuel.
 
Le code est le suivant :
private void getPartImage(int cSel,int x,int y,int w,int h) {
   
  int yy,xx;
  xx = x + 1;
  yy = y;
  if (xx < w && yy < h && yy >=0 && xx >= 0) {
   if (iPix[yy * w + xx] == cSel) {
    iPix[yy * w + xx] = -255;
    vPix.add(new Dimension(xx,yy));
    getPartImage(cSel,xx,yy,w,h);
   }
  }
   
  xx = x + 1;
  yy = y - 1;
   
  if (xx < w && yy < h && yy >=0 && xx >= 0) {
   if (iPix[yy * w + xx] == cSel) {
    iPix[yy * w + xx] = -255;
    vPix.add(new Dimension(xx,yy));
     
    getPartImage(cSel,xx,yy,w,h);
     
     
   }
  }
 
  xx = x;
  yy = y - 1;
   
  if (xx < w && yy < h && yy >=0 && xx >= 0) {
   if (iPix[yy * w + xx] == cSel) {
    iPix[yy * w + xx] = -255;
    vPix.add(new Dimension(xx,yy));
    getPartImage(cSel,xx,yy,w,h);
     
     
   }
  }
   
  xx = x - 1;
  yy = y - 1;
   
  if (xx < w && yy < h && yy >=0 && xx >= 0) {
   if (iPix[yy * w + xx] == cSel) {
    iPix[yy * w + xx] = -255;
    vPix.add(new Dimension(xx,yy));
    getPartImage(cSel,xx,yy,w,h);
   }
  }
   
  xx = x - 1;
  yy = y ;
   
  if (xx < w && yy < h && yy >=0 && xx >= 0) {
   if (iPix[yy * w + xx] == cSel) {
    iPix[yy * w + xx] = -255;
    vPix.add(new Dimension(xx,yy));
    getPartImage(cSel,xx,yy,w,h);
 
   }
  }
   
  xx = x - 1;
  yy = y + 1;
   
  if (xx < w && yy < h && yy >=0 && xx >= 0) {
   if (iPix[yy * w + xx] == cSel) {
    iPix[yy * w + xx] = -255;
    vPix.add(new Dimension(xx,yy));
    getPartImage(cSel,xx,yy,w,h);
     
   }
  }
   
  xx = x ;
  yy = y + 1 ;
   
  if (xx < w && yy < h && yy >=0 && xx >= 0) {
   if (iPix[yy * w + xx] == cSel) {
    iPix[yy * w + xx] = -255;
    vPix.add(new Dimension(xx,yy));
    getPartImage(cSel,xx,yy,w,h);
 
   }
  }
   
  xx = x + 1;
  yy = y + 1;
 
   
  if (xx < w && yy < h && yy >=0 && xx >= 0) {
   if (iPix[yy * w + xx] == cSel) {
    iPix[yy * w + xx] = -255;
    vPix.add(new Dimension(xx,yy));
    getPartImage(cSel,xx,yy,w,h);
         
   }
  }  
   
   
 }
 
Le principe est de délimiter une zone de mon tableau dont les valeurs sont identiques et délimités par des valeurs différentes dans le tableau.
Si quelqu'un pouvait m'indiquer m'aider sur ce pb Merci

J'ai pas lu le code de ta méthode (trop longue à mon gout) mais une chose est sure : c'est la condition d'arrêt de la récursivité qui n'arrête pas le traitement.
 
normalement, on fait ça avec l'algorithme du peintre, qu'on dérécursivise (en utilisant une pile explicite) pour des raisons de lisibilité.

Disons que le code est un gros brouillon. Normalement la fonction doit s'arrêter forcément à un moment donné par contre le nombre d'appel doit être supérieur à une limite qui déclenche une exception.
J'ai fait un test avec la fonction void essai() { it++ ; if (it<50000) { essai(); } }  
 
ca plante par contre avec it < 500, ca marche.

quelle est la taille du tableau iPix ?
 
D'une manière générale, ce n'est *jamais* en raison de la taille des données mais en raison d'un bug qu'on a ce genre d'erreur. En particulier quand on a un code aussi dégueulasse.

ce n'est pas à mon avis en terme de taille de données mais plutôt d'itérations.

Par construction, la pile d'appels n'est pas infinie.
 
Pour confirmer/infirmer tes dires, j'ai fait un petit test rapide :

Et voici le résultat sur ma machine (avec Java HotSpot(TM) Client VM (build 1.3.1_09-b03, mixed mode) :

 
Ce qui confirme que la récursivité n'est pas faite pour des millers d'appels récursifs, seulement quelques dizaines ou quelques centaines. Au-delà, comme le dit nraynaud, il faut dérécursifier en utilisant sa propre pile.
 
Et au passage, factoriser ton code serait aussi une très bonne idée (ton double "if" existe en huit exemplaires !). Du genre :

 
Un tel code est déjà beaucoup plus lisible, beaucoup plus facile à maintenir que ton code initial (et pourtant, il est strictement équivalent pour la machine). Et il sera beaucoup plus facile à dérécursifier.

rehello,
 
Je suis tous à fait d'accord avec toi BifaceMcLeOD. J'ai fait ce code en quelques minutes pour essayer de voir si ça fonctionnait.
Les performances de la machine ne sont d'ailleurs pas mise à contribution par rapport à un code plus propre. J'ai l'intention de coder proprement les méthodes.
Par contre, j'essaye de résoudre le pb technique ce qui m'énerve de + en +.
J'ai essayer sous forme d'applet un code équivalent un peu comme celui proposé précédemment et il n'y a pas de souci. Par contre, sous forme d'appli ca plante.
 
Il y a une exception levée pour les fonctions récursives trop longue. c la première fois que je trouve JAVA bizarre (ou c moi ???).
 
En tout cas j'apprécie ton discours constructifs. je pense que "Rien ne sert de coder proprement pour tester qqch à l'origine"
Par contre ensuite, il est clair que c plutot indispensable.

Une pile d'appel 17000 c'est déjà pas mal, hein

ça dépend de la taille des frames, hein
 
 
bon et le monsieur il va arrêter de croire que c'est de la faute du matériel s'il a touché le fond de la pile !

Le programme est fait pour récupérer des zones d'une image. La fonction récursive fonctionnera ou non selon la taille de l'image.
J'aimerai savoir s'il faut que je traite en plusieurs fois l'image selon sa taille s'il existe une autre solution.
 
Ceci dit je n'ai pas encore trouvé un outil du type photoshop qui permet de faire un remplissage d'une zone non régulière en JAVA.

 
De toute façon, il vaut mieux éviter au maximum d'écrire des fonctions récursives pour des raisons de performances ou sinon, de bien savoir ce que l'on fait. Souvent, cela revient à gaspiller sa cpu et d'autant plus que toute fonction récursive peut s'écrire avec un algo non-récursif.

 
merci de toutes vos remarques. Ca m'a fait pas mal avancé. Je vais ecrire une fonction avec des boucles imbriqués.