Discussion :

[Foobar1329]

Hello,

C'est bon, j'ai vérifié avant ... c'est pas tant n'importe quoi que ça. Mais si ça peut vous faire plaisir, je vais m'empresser de mettre un *pixelfloat_i qui garde la valeur d'origine

Je suggère de partir sur une solution où allocations et libérations de mémoire sont réalisées en amont de la fonction. Cela peut être fait également en interne également, si par exemple on souhaite travailler sur des copies de données à la base non modifiables, mais ca n'a pas l'air de l'être dans ton cas. Tout ça est en fait une question de conception. Il fallait bien dans ton code original libérer quelquepart la mémoire allouée pointée par pixelfloat...Par chance, c'était fait correctement grâce à la variable pixel_i qui sauvegardait le pointeur pixel, mais c'est dangereux, propice à générer de superbes fuites mémoires. Donc je ne te conseille pas la solution de mettre un float * pixelfloat_i...Soit tu fais les allocation/libération en interne dan la fonction, soit en amont, mais mélanger les deux est souvent responsable de soucis surtout dus à un manque de rigueur du programmeur, qui entre temps aura soit modifié son pointeur avnt libération, soit oubliera de libérer la mémoire associée.

Voici donc ce que je te propose :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
/* DEBUT CODE EN AMONT */
 
#include <assert.h>
#include <stdlib.h>
 
/* .... */
 
int rc = 0;
 
float * littleImg;
int dimPetit = 512;
 
unsigned char * largeImg;
int dimGrand = 1024;
 
littleImg = malloc(dimPetit*dimPetit*sizeof*littleImg);
if (!littleImg) { /* gestion erreur, sortie */ }
 
largeImg = malloc(dimGrand*dimGrand*sizeof*largeImg);
if (!largeImg) { /* gestion erreur, sortie */ }
 
/* Remplissage buffers ....  */ 
 
/* Retaillage */
rc = retailler(littleImg, dimPetit, dimPetit, largeImg, dimGrand, dimGrand);
assert(!rc);
 
/* Affichage ou je ne sais quoi ....  */
 
/* Libération mémoire */
free(largeImg);
free(littleImg);
 
/* FIN CODE EN AMONT */
 
/* Proposition de fonction modifiee */
int retailler(float * petiteImgBuf, int PetitX, int PetitY,  MIL_ID * grandeImgBuf, int GrandX, int GrandY)
{
   int rc = 0;
 
   /* Ctrl args */
   if (!petiteImgBuf) { rc = -1; }
   if (PetitX < 0) { rc = -2; }
   if (PetitY < 0) { rc = -3; }
   if (!grandeImgBuf) { rc = -4; }
   if (GrandX < 0) { rc = -5; }
   if (GrandY < 0) { rc = -6; }
 
   if (rc >= 0)  {
 
       /* 'Marges' quand la petite image est centrée sur la grande */
       int deltaX, deltaY;
 
       /* Indices de boucle */
       int i,j;         
 
       float *pixelfloat = petiteImgBuf; /* Pointeur pour l'image en float */
       unsigned char *pixel = (unsigned char *)grandeImgBuf; /* Pointeur pour l'image en char */
 
       /* Calcul des marges */
       deltaX = (GrandX-PetitX)/2;
       deltaY = (GrandY-PetitY)/2;
 
       for(j=0;j<GrandY;++j) {
         for(i=0;i<GrandX;++i) {  
            /* Si le pixel lu dans la grande image n'est pas dans les marges */
            if(i>=deltaX && i<(PetitX + deltaX) && j>=deltaY && j<(PetitY + deltaY)) {
                 /* On l'ajoute à la petite image */
                 *pixelfloat = (float)*pixel;
                 /* On passe au pixel suivant sur la petite image */
                 ++pixelfloat;
             }
             /* Dans tous les cas, on doit lire le pixel suivant sur la grande image */
             ++pixel;
          }
       }
    }
 
    return rc;
}

[thewho]

Bonjour,

Oui, je sais, c'est ce que je disais à la fin de mon premier post. Mais si je fais pas ça, je ne visualise plus mon image (la fenetre reste toute noire). On va chercher à joindre quelqu'un de spécialisé dans la carte qu'on utilise et dans la librairies pour savoir s'il n a pas connaissance de bugs.

Là, il y a un problème manifeste : le fait de réserver ou non de la mémoire, que tu n'utilises jamais, modifie le comportement du programme ?

J'en perds le peu de latin qu'il me reste.

[BenjaminLustrement]

Merci à tous de vous être donné tant de mal pour mon problème, c'est effectivement en effectuant mes déclarations et allocations en amont du programme que ça fonctionne. concernant le précédent message (de je sais plus qui ) j'attends de savoir si les fonctions de la carte sont buggées ou pas... saurai ça cet après midi, mais à vrai dire, j'en ai déjà la certitude. Merci à tous encore !