Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
958 connectés 

  FORUM HardWare.fr
  Programmation
  C

  probleme fuite de memoire

 
 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

probleme fuite de memoire

n°2186561
icemake
Posté le 19-04-2013 à 09:32:11  profilanswer
 

bonjour,
je vous montre mon programme vous pouvez me dire si vous trouvé un endroit ou il peut y avoir des fuite de mémoire car j'en ai mais je sais pas pourquoi
 
 
PROBLEME RESOLU


Message édité par icemake le 19-04-2013 à 11:52:15
mood
Publicité
Posté le 19-04-2013 à 09:32:11  profilanswer
 

n°2186580
theshockwa​ve
I work at a firm named Koslow
Posté le 19-04-2013 à 10:50:07  profilanswer
 

Ton indentation est en vrac, ton code est un pavé illisible.
Commence par découper ton programme en bloc sémantiques que tu mets dans des fonctions séparées, et peut-être que tu trouveras le problème tout seul en faisant ce brin de nettoyage.

 

Edit : Erf, j'ai loupé qu'il y avait quelques fonctions, c'est juste tellement dense que ca n'apparait pas (et le nommage de tes variables et fonctions n'aide pas énormément)


Message édité par theshockwave le 19-04-2013 à 10:51:38

---------------
last.fm
n°2186620
gilou
Modérateur
Modzilla
Posté le 19-04-2013 à 13:54:37  profilanswer
 

Comme je n'aime pas qu'on supprime un code posté ici, je le remet, mais juste un poil formaté, parce que ce qui était posté ici était complètement illisible.
Et si on pond du code illisible, on ne peut pas se relire, et donc on ne peut pas corriger correctement son code.

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include "libbmp.h"   // permet de travailler sur des images au format .bmp
  5. //prototypes
  6. t_bmp bordure(t_bmp);
  7. t_bmp LPE(t_bmp);
  8. t_bmp dilatation(t_bmp, t_bmp);
  10. // declaration de variables
  11. char image[60],car;
  12. t_bmp bmp,bmp1,bmp2,bmp3;
  13. int a=0,b=0,c=0, i, k, savi, j, savj, l, largeur, longueur, longueur2,test,test1,test2,test3,nbrbille=0,current = 10;
  14. const int z=100;
  15. double bille;
  16. long repere;
  17. FILE *texte;
  19. int main(int argc, const char * argv[])
  20. {
  21.     while(1) {
  22.         sprintf(image, argv[2]);  //choix du nom de l'image
  23.         test = libbmp_load(image, &bmp);  //ouvre l'image au format .bmp
  24.         if(test) {
  25.             texte = fopen(argv[1],"at" ); //ouverture d'un fichier texte
  26.             fseek(texte, current, SEEK_SET);
  27.             car = fgetc(texte);
  28.             while(car != '\n') {
  29.                 if(ftell(texte)==0) {
  30.                     break;
  31.                 }
  32.                 current--;
  33.                 fseek(texte, current, SEEK_SET);
  34.                 car = fgetc (texte);
  35.             }
  36.             fgets(image, 60, texte);
  37.             fprintf(texte,"%s\n",image); //ecriture du nom de l'image dans le fichier texte
  38.             /******************elimination des billes en bordure *********************/
  39.             bmp = bordure(bmp);    //supprime les billes coupees par les bords de l'image
  40.             /*****************decoupage par LPE**************************************/
  41.             bmp = LPE(bmp);     //decolle les billes collees
  42.             /*******************traitement de l'image**************************************/
  43.             a=0;
  44.             b=0;
  45.             c=0;
  46.             for(i=0; i<bmp.width; i++) { //deplacement sur le pixel en largeur
  47.                 for(j=0; j<bmp.height; j++) { // deplacement sur les pixel en hauteur
  48.                     if(j<bmp.height-2 && j>2) { //supprime les trou pouvant etre present entre les billes
  49.                         if(bmp.data[j][i].moy==0
  50.                                 && (bmp.data[j-2][i].moy==255 || bmp.data[j-1][i].moy==255)
  51.                                 && (bmp.data[j+2][i].moy==255 || bmp.data[j+1][i].moy==255)
  52.                                 && bmp.data[j-1][i-1].moy==255
  53.                                 && bmp.data[j][i-1].moy==255
  54.                                 && bmp.data[j+1][i-1].moy==255
  55.                                 && (bmp.data[j+1][i+1].moy==255 || bmp.data[j+2][i+1].moy==255)) {
  56.                             bmp.data[j][i].moy=255;
  57.                         }
  58.                     }
  59.                 }
  60.             }
  61.             for(i=0; i<bmp.width; i++) { //deplacement sur le pixel en largeur
  62.                 for(j=0; j<bmp.height; j++) { // deplacement sur les pixel en hauteur
  63.                     a+=20; //labellisation des billes
  64.                     if(a>255) {
  65.                         a=0;
  66.                         b+=20;
  67.                     }
  68.                     if(b>255) {
  69.                         b=0;
  70.                         c+=20;
  71.                     }
  72.                     if(bmp.data[j][i].moy==255) { //recherche de pixel blanc
  73.                         longueur2=0; //initialisation des valeurs
  74.                         largeur=0;
  75.                         bille=0;
  76.                         savi=i;     //sauvegarde la position du point
  77.                         savj=j;
  78.                         do  { //double boucle pour compter la taille d'un bille et la supprimer de l'image
  79.                             do {
  80.                                 if(j<bmp.height-1 && j>0)
  81.                                     if(bmp.data[j][i+1].moy==255
  82.                                             && bmp.data[j+3][i+1].moy==255
  83.                                             && bmp.data[j+1][i+1].moy==255
  84.                                             && bmp.data[j-3][i+1].moy==255
  85.                                             && bmp.data[j-1][i+1].moy==255
  86.                                             && bmp.data[j-2][i+1].moy==255
  87.                                             && bmp.data[j+2][i+1].moy==255) {
  88.                                         savj=j;
  89.                                     }
  90.                                 longueur++;
  91.                                 bmp.data[j][i].moy=(a+b+c)/3;   //change la couleur du pixel
  92.                                 // bmp.data[j][i].r=a;
  93.                                 // bmp.data[j][i].b=b;
  94.                                 // bmp.data[j][i].g=c;
  95.                                 j++;
  96.                                 if(j==bmp.height) {
  97.                                     break;
  98.                                 }
  99.                             } while(bmp.data[j][i].moy==255);
  100.                             j=savj;
  101.                             i++;
  102.                             if(j>0) {
  103.                                 while(bmp.data[j-1][i].moy==255 && j>1) {
  104.                                     j--;
  105.                                     if(bmp.data[j-1][i].moy==0 && bmp.data[j-2][i].moy==255 && bmp.data[j-2][i-1].moy==((a+b+c)/3)) {
  106.                                         bmp.data[j-1][i].moy=255;
  107.                                     }
  108.                                 }
  109.                             }
  110.                             largeur++;
  111.                             if(longueur>longueur2) {      //cherche la longueur la plus grande
  112.                                 longueur2=longueur;
  113.                             }
  114.                             longueur=0;
  115.                         } while(bmp.data[j][i].moy==255);
  116.                         if(longueur2>8 && largeur>8) { //difference entre bille et parasite
  117.                             if(longueur2>largeur) {          //cherche la valeur la plus grande
  118.                                 bille=longueur2 * 0.07716 + 0.1543;     //calcul pour avoir le resultat en millimetre
  119.                             } else {
  120.                                 bille=largeur * 0.07716 +0.1543;
  121.                             }
  122.                             if(bille<8) {
  123.                                 fprintf(texte,"%.2f\n",bille);  //ecrit le resultat dans le fichier texte
  124.                                 nbrbille ++;
  125.                                 //  printf("%.2f\n",bille);    //debugage
  126.                             }
  127.                         }
  128.                         i=savi;                 //retourne au point sauvegardé
  129.                         j=savj;
  130.                     }
  131.                 }
  132.             }      //prepare l'ouverture de la prochaine image
  133.             fprintf(texte,"il y a %d bille(s) sur l'image\n",nbrbille);
  134.             fclose(texte);
  135.             for (i = 0; i < bmp.height; i++) {
  136.                 free(bmp.data[i]);
  137.             }
  138.             free(bmp.data);
  139.             remove(image);
  140.             nbrbille=0;
  141.         }
  142.     }
  143. }
  145. /***********sous programme**************/
  146. t_bmp bordure(t_bmp bmp)
  147. {
  148.     int i;
  149.     for (i = 0; i < bmp.width; ++i) {   // supprime toutes les billes touchant le bas de l'image
  150.         j=0;
  151.         if(bmp.data[j][i].moy < z) {
  152.             savi=i;
  153.             do {
  154.                 do {
  155.                     bmp.data[j][i].moy=255;
  156.                     i++;
  157.                     if(i==bmp.width) {
  158.                         break;
  159.                     }
  160.                 } while(bmp.data[j][i].moy<z);
  161.                 i=savi;
  162.                 j++;
  163.                 if(j==bmp.height) {
  164.                     break;
  165.                 }
  166.                 if(bmp.data[j][i].moy>z) {
  167.                     if(i<bmp.width-1) {
  168.                         if(bmp.data[j][i+1].moy<z) {
  169.                             i=i+1;
  170.                             savi=i;
  171.                         }
  172.                     }
  173.                 } else {
  174.                     while(bmp.data[j][i-1].moy<z && i>1) {
  175.                         i--;
  176.                     }
  177.                 }
  178.             } while(bmp.data[j][i].moy<z);
  179.         }
  180.     }
  181.     for(i=0; i<bmp.width; i++) { // supprime toutes les billes touchant le haut de l'image
  182.         j=bmp.height-1;
  183.         if(bmp.data[j][i].moy<z) {
  184.             savi=i;
  185.             do {
  186.                 do {
  187.                     bmp.data[j][i].moy=255;
  188.                     i++;
  189.                     if(i==bmp.width) {
  190.                         break;
  191.                     }
  192.                 } while(bmp.data[j][i].moy<z);
  193.                 i=savi;
  194.                 j--;
  195.                 if(bmp.data[j][i].moy>z) {
  196.                     if(i<bmp.width-1) {
  197.                         if(bmp.data[j][i+1].moy<z) {
  198.                             i=i+1;
  199.                             savi=i;
  200.                         }
  201.                     }
  202.                 } else {
  203.                     while(bmp.data[j][i-1].moy<z && i>1) {
  204.                         i--;
  205.                     }
  206.                 }
  207.             } while(bmp.data[j][i].moy<z && i<bmp.width-1);
  208.         }
  209.     }
  210.     for(j=0; j<bmp.height; j++) { // supprime toutes les billes touchant le bord gauche de l'image
  211.         i=0;
  212.         if(bmp.data[j][i].moy<z) {
  213.             savj=j;
  214.             do {
  215.                 do {
  216.                     bmp.data[j][i].moy=255;
  217.                     j++;
  218.                     if(j==bmp.height) {
  219.                         break;
  220.                     }
  221.                 } while(bmp.data[j][i].moy<z);
  222.                 j=savj;
  223.                 i++;
  224.                 if(i<bmp.width-1) {
  225.                     if(bmp.data[j][i].moy>z) {
  226.                         if(j<bmp.height-1) {
  227.                             if(bmp.data[j+1][i].moy<z) {
  228.                                 j=j+1;
  229.                                 savj=j;
  230.                             }
  231.                         }
  232.                     } else {
  233.                         while(bmp.data[j-1][i].moy<z) {
  234.                             j--;
  235.                             if(j==0) {
  236.                                 break;
  237.                             }
  238.                         }
  239.                     }
  240.                 }
  241.             } while(bmp.data[j][i].moy<z && j<bmp.height-1);
  242.         }
  243.     }
  244.     for(j=0; j<bmp.height; j++) { // supprime toutes les billes touchant le bord droit de l'image
  245.         i=bmp.width-1;
  246.         if(bmp.data[j][i].moy<z) {
  247.             savj=j;
  248.             do {
  249.                 do {
  250.                     bmp.data[j][i].moy=255;
  251.                     j++;
  252.                     if(j==bmp.height) {
  253.                         break;
  254.                     }
  255.                 } while(bmp.data[j][i].moy<z);
  256.                 j=savj;
  257.                 i--;
  258.                 if(bmp.data[j][i].moy>z) {
  259.                     if(j<bmp.height-1) {
  260.                         if(bmp.data[j+1][i].moy<z) {
  261.                             j=j+1;
  262.                             savj=j;
  263.                         }
  264.                     }
  265.                 } else {
  266.                     while(bmp.data[j-1][i].moy<z && j>1) {
  267.                         j--;
  268.                     }
  269.                 }
  270.             } while(bmp.data[j][i].moy<z && j<bmp.height-1);
  271.         }
  272.     }
  273.     return bmp;
  274. }
  275. /********************LPE*******************************/
  276. t_bmp LPE(t_bmp bmp)
  277. {
  278.     libbmp_load(image, &bmp1);
  279.     libbmp_load(image, &bmp2);
  280.     libbmp_load(image, &bmp3);
  281.     int fin=0;
  282.     for(i=0; i<bmp.width; i++) { //deplacement sur le pixel en largeur
  283.         for(j=0; j<bmp.height; j++) { // deplacement sur les pixel en hauteur
  284.             if(bmp.data[j][i].moy>z) {
  285.                 bmp.data[j][i].moy=255;
  286.                 /*bmp.data[j][i].r=255;bmp.data[j][i].g=255;bmp.data[j][i].b=255;*/
  287.             } //transforme l'image en image binaire
  288.             if(bmp.data[j][i].moy<z) {
  289.                 bmp.data[j][i].moy=0;
  290.                 /*bmp.data[j][i].r=0;bmp.data[j][i].g=0;bmp.data[j][i].b=0;*/
  291.             }
  292.             bmp.data[j][i].moy= 255 - bmp.data[j][i].moy;
  293.             //bmp.data[j][i].r= 255 - bmp.data[j][i].r;bmp.data[j][i].g= 255 - bmp.data[j][i].g;bmp.data[j][i].b= 255 - bmp.data[j][i].b;
  294.         }
  295.     }
  296.     for(i=1; i<bmp.width-1; i++) { //deplacement sur le pixel en largeur
  297.         for(j=1; j<bmp.height-1; j++) { // deplacement sur les pixel en hauteur
  298.             //premiere erosion
  299.             if(bmp.data[j][i].moy==255
  300.                     && bmp.data[j-1][i].moy==255
  301.                     && bmp.data[j][i-1].moy==255
  302.                     && bmp.data[j+1][i].moy==255
  303.                     && bmp.data[j][i+1].moy==255) {
  304.                 bmp1.data[j][i].moy=255;
  305.                 //bmp1.data[j][i].r=255;bmp1.data[j][i].g=255;bmp1.data[j][i].b=255;
  306.             } else if(bmp.data[j][i].moy==0
  307.                       || bmp.data[j-1][i].moy==0
  308.                       || bmp.data[j][i-1].moy==0
  309.                       || bmp.data[j+1][i].moy==0
  310.                       || bmp.data[j][i+1].moy==0) {
  311.                 bmp1.data[j][i].moy=0;//bmp1.data[j][i].r=0;bmp1.data[j][i].g=0;bmp1.data[j][i].b=0;
  312.             }
  313.         }
  314.     }
  315.     do { //erosion de taille 9
  316.         fin++;
  317.         for(i=1; i<bmp.width-1; i++) { //deplacement sur le pixel en largeur
  318.             for(j=1; j<bmp.height-1; j++) { // deplacement sur les pixel en hauteur
  319.                 if(bmp1.data[j][i].moy==255
  320.                         && bmp1.data[j-1][i].moy==255
  321.                         && bmp1.data[j][i-1].moy==255
  322.                         && bmp1.data[j+1][i].moy==255
  323.                         && bmp1.data[j][i+1].moy==255
  324.                         && bmp1.data[j-1][i+1].moy==255
  325.                         && bmp1.data[j+1][i+1].moy==255
  326.                         && bmp1.data[j-1][i-1].moy==255
  327.                         && bmp1.data[j+1][i-1].moy==255) {
  328.                     bmp2.data[j][i].moy=255;
  329.                     //bmp2.data[j][i].r=255;bmp2.data[j][i].g=255;bmp2.data[j][i].b=255;
  330.                 } else if(bmp1.data[j][i].moy==0
  331.                           || bmp1.data[j-1][i].moy==0
  332.                           || bmp1.data[j][i-1].moy==0
  333.                           || bmp1.data[j+1][i].moy==0
  334.                           || bmp1.data[j][i+1].moy==0
  335.                           || bmp1.data[j-1][i+1].moy==0
  336.                           || bmp1.data[j+1][i+1].moy==0
  337.                           || bmp1.data[j-1][i-1].moy==0
  338.                           || bmp1.data[j+1][i-1].moy==0) {
  339.                     bmp2.data[j][i].moy=0;
  340.                     //bmp2.data[j][i].r=0;bmp2.data[j][i].g=0;bmp2.data[j][i].b=0;
  341.                 }
  342.             }
  343.         }
  344.         for(i=0; i<bmp.width; i++) { //deplacement sur le pixel en largeur
  345.             for(j=0; j<bmp.height; j++) { // deplacement sur les pixel en hauteur
  346.                 bmp1.data[j][i].moy = bmp2.data[j][i].moy;
  347.             }
  348.         }
  349.     } while(fin != 9);
  350.     //   sprintf(nouvelle,"image%dbmp1.bmp",k);
  351.     //   libbmp_write(nouvelle,&bmp1);  //debugage
  352.     bmp3=dilatation(bmp2,bmp3);  //dilatation
  353.     //       sprintf(nouvelle,"image%dbmp2.bmp",k);
  354.     //       libbmp_write(nouvelle,&bmp2);  //debugage
  355.     //       sprintf(nouvelle,"image%dbmp3.bmp",k);
  356.     //       libbmp_write(nouvelle,&bmp3);  //debugage
  357.     for(i=0; i<bmp.width; i++) { //deplacement sur le pixel en largeur
  358.         for(j=0; j<bmp.height; j++) { // deplacement sur les pixel en hauteur
  359.             bmp.data[j][i].moy *= bmp3.data[j][i].moy; //decolle les billes collées
  360.             if(bmp.data[j][i].moy != 0) {    // transforme l'image en image binaire
  361.                 bmp.data[j][i].moy=255;
  362.             }
  363.         }
  364.     }
  365.     for (i = 0; i < bmp.height; i++) {
  366.         free(bmp1.data[i]);
  367.         free(bmp2.data[i]);
  368.         free(bmp3.data[i]);
  369.     }
  370.     free(bmp1.data);
  371.     free(bmp2.data);
  372.     free(bmp3.data);
  373.     return bmp;
  374. }
  376. t_bmp dilatation (t_bmp bmp2,t_bmp bmp3)
  377. {
  378.     a=0;
  379.     b=0;
  380.     c=0;
  381.     int l, fin=0;
  382.     for(i=0; i<bmp2.width; i++) { //deplacement sur le pixel en largeur
  383.         for(j=0; j<bmp2.height; j++) { // deplacement sur les pixel en hauteur
  384.             a+=20; //labelisation de l'image
  385.             if(a>255) {
  386.                 a=0;
  387.                 b+=20;
  388.             }
  389.             if(b>255) {
  390.                 b=0;
  391.                 c+=20;
  392.             }
  393.             if(bmp2.data[j][i].moy==255) { //recherche de pixel blanc
  394.                 savi=i;     //sauvegarde la position du point
  395.                 savj=j;
  396.                 do  {//double boucle pour labelisé les billes
  397.                     do {
  398.                         bmp2.data[j][i].moy=(a+b+c)/3;   //change la couleur du pixel
  399.                         //bmp2.data[j][i].r=a;
  400.                         //bmp2.data[j][i].b=b;
  401.                         //bmp2.data[j][i].g=c;
  402.                         j++;
  403.                         if(j==bmp2.height) {
  404.                             break;
  405.                         }
  406.                     } while(bmp2.data[j][i].moy==255);
  407.                     j=savj;
  408.                     i++;
  409.                     if(bmp2.data[j][i].moy==0) {
  410.                         for(l=1; l<15; l++) {
  411.                             if(bmp2.data[j+l][i].moy==255) {
  412.                                 j=j+l;
  413.                                 savj=j;
  414.                                 break;
  415.                             }
  416.                         }
  417.                     } else {
  418.                         if(j>0) {
  419.                             while(bmp2.data[j-1][i].moy==255 && j>1) {
  420.                                 j--;
  421.                             }
  422.                         }
  423.                     }
  424.                 } while(bmp2.data[j][i].moy==255);
  425.                 j=savj;
  426.                 i=savi;
  427.             }
  428.         }
  429.     }
  430.     for(i=0; i<bmp2.width; i++) { //deplacement sur le pixel en largeur
  431.         for(j=0; j<bmp2.height; j++) { // deplacement sur les pixel en hauteur
  432.             bmp3.data[j][i].moy = bmp2.data[j][i].moy;  //copie de donnée
  433.             // bmp3.data[j][i].r = bmp2.data[j][i].r;
  434.             // bmp3.data[j][i].g = bmp2.data[j][i].g;
  435.             // bmp3.data[j][i].b = bmp2.data[j][i].b;
  436.         }
  437.     }
  438.     // sprintf(nouvelle,"image%dbmp31.bmp",k);
  439.     //  libbmp_write(nouvelle,&bmp3);  //debugage
  440.     do { //dilatation sous contrainte de 40
  441.         fin++;
  442.         for(i=2; i<bmp2.width-2; i++) { //deplacement sur le pixel en largeur
  443.             for(j=2; j<bmp2.height-2; j++) { // deplacement sur les pixel en hauteur
  444.                 if(bmp2.data[j][i].moy!=0) {
  445.                     if(bmp2.data[j-1][i].moy==0) {
  446.                         if(((bmp2.data[j-2][i].moy==0 || bmp2.data[j-2][i].moy==bmp2.data[j][i].moy)
  447.                                 && (bmp3.data[j-2][i].moy==0 || bmp3.data[j-2][i].moy==bmp2.data[j][i].moy))
  448.                                 && ((bmp2.data[j-2][i+1].moy==0 || bmp2.data[j-2][i+1].moy==bmp2.data[j][i].moy)
  449.                                     && (bmp3.data[j-2][i+1].moy==0 || bmp3.data[j-2][i+1].moy==bmp2.data[j][i].moy))
  450.                                 && ((bmp2.data[j-2][i-1].moy==0 || bmp2.data[j-2][i-1].moy==bmp2.data[j][i].moy)
  451.                                     && (bmp3.data[j-2][i-1].moy==0 || bmp3.data[j-2][i-1].moy==bmp2.data[j][i].moy))) {
  452.                             bmp3.data[j-1][i].moy=bmp3.data[j][i].moy;
  453.                             //bmp3.data[j-1][i].r=bmp3.data[j][i].r;bmp3.data[j-1][i].g=bmp3.data[j][i].g;bmp3.data[j-1][i].b=bmp3.data[j][i].b;
  454.                         }
  455.                     }
  456.                     if(bmp2.data[j+1][i].moy==0) {
  457.                         if(((bmp2.data[j+2][i].moy==0 || bmp2.data[j+2][i].moy==bmp2.data[j][i].moy)
  458.                                 && (bmp3.data[j+2][i].moy==0 || bmp3.data[j+2][i].moy==bmp2.data[j][i].moy))
  459.                                 && ((bmp2.data[j+2][i+1].moy==0 || bmp2.data[j+2][i+1].moy==bmp2.data[j][i].moy)
  460.                                     && (bmp3.data[j+2][i+1].moy==0 || bmp3.data[j+2][i+1].moy==bmp2.data[j][i].moy))
  461.                                 && ((bmp2.data[j+2][i-1].moy==0 || bmp2.data[j+2][i-1].moy==bmp2.data[j][i].moy)
  462.                                     && (bmp3.data[j+2][i-1].moy==0 || bmp3.data[j+2][i-1].moy==bmp3.data[j][i].moy))) {
  463.                             bmp3.data[j+1][i].moy=bmp3.data[j][i].moy;
  464.                             //bmp3.data[j+1][i].r=bmp3.data[j][i].r;bmp3.data[j+1][i].g=bmp3.data[j][i].g;bmp3.data[j+1][i].b=bmp3.data[j][i].b;
  465.                         }
  466.                     }
  467.                     if(bmp2.data[j][i+1].moy==0) {
  468.                         if(((bmp2.data[j][i+2].moy==0 || bmp2.data[j][i+2].moy==bmp2.data[j][i].moy)
  469.                                 && (bmp3.data[j][i+2].moy==0 || bmp3.data[j][i+2].moy==bmp2.data[j][i].moy))
  470.                                 && ((bmp2.data[j-1][i+2].moy==0 || bmp2.data[j-1][i+2].moy==bmp2.data[j][i].moy)
  471.                                     && (bmp3.data[j-1][i+2].moy==0 || bmp3.data[j-1][i+2].moy==bmp2.data[j][i].moy))
  472.                                 && ((bmp2.data[j+1][i+2].moy==0 || bmp2.data[j+1][i+2].moy==bmp2.data[j][i].moy)
  473.                                     && (bmp3.data[j+1][i+2].moy==0 || bmp3.data[j+1][i+2].moy==bmp2.data[j][i].moy))) {
  474.                             bmp3.data[j][i+1].moy=bmp3.data[j][i].moy;
  475.                             //bmp3.data[j][i+1].r=bmp3.data[j][i].r;bmp3.data[j][i+1].g=bmp3.data[j][i].g;bmp3.data[j][i+1].b=bmp3.data[j][i].b;
  476.                         }
  477.                     }
  478.                     if(bmp2.data[j][i-1].moy==0) {
  479.                         if(((bmp2.data[j][i-2].moy==0 || bmp2.data[j][i-2].moy==bmp2.data[j][i].moy)
  480.                                 && (bmp3.data[j][i-2].moy==0 || bmp3.data[j][i-2].moy==bmp2.data[j][i].moy))
  481.                                 && ((bmp2.data[j-1][i-2].moy==0 || bmp2.data[j-1][i-2].moy==bmp2.data[j][i].moy)
  482.                                     && (bmp3.data[j-1][i-2].moy==0 || bmp3.data[j-1][i-2].moy==bmp2.data[j][i].moy))
  483.                                 && ((bmp2.data[j+1][i-2].moy==0 || bmp2.data[j+1][i-2].moy==bmp2.data[j][i].moy)
  484.                                     && (bmp3.data[j+1][i-2].moy==0 || bmp3.data[j+1][i-2].moy==bmp2.data[j][i].moy))) {
  485.                             bmp3.data[j][i-1].moy=bmp3.data[j][i].moy;
  486.                             //bmp3.data[j][i-1].r=bmp3.data[j][i].r;bmp3.data[j][i-1].g=bmp3.data[j][i].g;bmp3.data[j][i-1].b=bmp3.data[j][i].b;
  487.                         }
  488.                     }
  489.                 }
  490.                 bmp2.data[j][i].moy = bmp3.data[j][i].moy;
  491.             }
  492.         }
  493.     } while(fin!= 40);
  494.     return bmp3;
  495. }


C'est quasiment un cas d'école de tout ce qu'il ne faut pas faire, ce truc.
On va pouvoir détailler.
A+,


Message édité par gilou le 19-04-2013 à 13:57:11

---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --

Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C

  probleme fuite de memoire

 

Sujets relatifs
Petit probleme de batchProblème d'accent dans un mail.php uniquement les requêtes sql
[AJAX] problème d'etat...Problème de mise en page selon le navigateur
Probleme de liaison à l'interfaceProblème pour actualiser les valeurs d'une Trackbar
Problème lors de la génération de la javadocproblème de manipulation/réorganisation de fichiers
Erreur Mémoire insuffisante. Comment optimiserproblème de fuite mémoire
Plus de sujets relatifs à : probleme fuite de memoire

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.384 secondes

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR