Discussion :

[souviron34]

il n 'y a pas de conception, ni d'architecture,
ce que je dois faire est comme suit:

déjà là, gros problème....

AVANT de se lancer dans du code et des solutions, il FAUT s"asseoir et réfléchir au problème et à l'algo.

je dois calculer la position de chaque sous image dans l'image globale
pour chaque couple, calculer l'intersection et en deduire des parametre
constituer un systeme d'equations lineaires
et ainsi soustraire chaque Xi de l'image i, afin de pouvoir rassembler les images en un seul morceau, en éliminant le maximum de discontinuité

Exposé peu clair -> problème pas vraiment compris -> solution pas adaptée.

• Tu as une grosse image.
• Tu as plusieurs petites images

jusque là ça va.

1. Maintenant quel est le lien entre les petites et la grosse ?
2. pourquoi avoir besoin de calculer l'intersection (entre quoi et quoi ??) ?
3. pourquoi soustraire ?
4. quel est le but final ?

[wiztricks]

Bonjour,

J'ai regardé la librarie CFITSIO. Pour ouvrir ces images elle à ses propres primitives auxquelles on donne le nom du fichier (et non un stream retourné par fopen).

Ces primitives sont de la forme:

int fits_open_file / ffopen
(fitsfile **fptr, char *filename, int iomode, > int *status)

=> est-ce qu'on a un problème avec fopen de stdio ou avec les primitives de cette librairie.

Pour le reste, il est clair que votre algorithme étant en O(n^2) avec n=360 incite à trouver des solutions pour rester en O(n) partout ou c'est possible.

Vous avez pointé les ouvertures de fichiers, je vous ai incité à considérer aussi les entrées sorties disques (beaucoup plus coûteuses à mon sens puisqu'on devrait (re)lire 359 * 0,5 Go).

Ce que vous devez chercher à réduire, c'est les relectures.
Cela suppose que les données des images utilisées par votre algorithme pourront être extraites des fichiers et utilisées pour les 359 comparaisons.

Une fois ces données extraites vous pourrez fermer le fichier.
=> Même si votre librairie 'limite' le nombre de fichiers ouverts à 255, cela ne devrait plus être un soucis.

Cordialement
- W

[MPEG4]

quand je dis pas de conception, je veux dire,que je ne passe pas par lediagrammes et le reste, mais sinon, y a tout a fait une conception
alors ce que je dois faire est comme suit:

je travaillesur des images astronomique;
donc une image est une collecte de sous-images
comme les dispositifs d'aquisition ne sont pas fiable a 100%, il nous faut corriger le fond du ciel,
donc, je calcule l'intersection entre chaque deux images, ce qui reviens a les localiser dans l'espace(les coordonnees des points inf-gauche et sup-droit)

donc pour chaque intersection de deux images, je calcule deux coefficients suivant les valeurs des pixels dans les images donnees et leur carte de poids

a la fin de cette etape, j'aurais construit un systeme d'equation lineaire a resoudre par la methode LU par exemple, ce qui me donnerais au final les fonds de ciel de chaque images
on faisant la soustracation, " image[i]-fond_ciel[i]) je trouve des images final normalement plus belles a voir, plus adaptees aux scientifiques...

et il restera que l'etape de rassembler les morceaux qui est faits ailleurs
NB: pour une meme region du ciel y a plusieurs acquisitions , et cela pour obetnir au final une meilleure image, la plus fidele possible a la realite
merci de bien vouloir m'aider

[MPEG4]

effectivement, j'ai assez de ram, donc j'ouvre les fichiers un a un
je recupere toute les donnees et les donnees qui m'interessent des headers d'un seule coup

et puis c'est a moi de jouer, pour recuperer mes donnees dans les tableaux que j'aurais cree
c'est une tres bonne idee
merci, je suis bete de n'y avoir pas penser

je ferais cela, le temps que je puisse trouver le moyen de faire un memory mapping
merci

[MPEG4]

Bonjour,

J'ai regardé la librarie CFITSIO. Pour ouvrir ces images elle à ses propres primitives auxquelles on donne le nom du fichier (et non un stream retourné par fopen).

Ces primitives sont de la forme:


=> est-ce qu'on a un problème avec fopen de stdio ou avec les primitives de cette librairie.

Pour le reste, il est clair que votre algorithme étant en O(n^2) avec n=360 incite à trouver des solutions pour rester en O(n) partout ou c'est possible.

Vous avez pointé les ouvertures de fichiers, je vous ai incité à considérer aussi les entrées sorties disques (beaucoup plus coûteuses à mon sens puisqu'on devrait (re)lire 359 * 0,5 Go).

Ce que vous devez chercher à réduire, c'est les relectures.
Cela suppose que les données des images utilisées par votre algorithme pourront être extraites des fichiers et utilisées pour les 359 comparaisons.

Une fois ces données extraites vous pourrez fermer le fichier.
=> Même si votre librairie 'limite' le nombre de fichiers ouverts à 255, cela ne devrait plus être un soucis.

Cordialement
- W

oui, je voulais repondre a votre remarque qussi,
effectivement, le proble est avec les open_fits_file
ca ne permets pas plus de 300 ficheirs ouvert

mais avec de simple fopen?fclose ca marche, mais le pb, ce qu'il fallait tout relire a chaque fois aussi

mais l'idee de tout charcher en memoire est tres bien, d'autant plus que fits_open_file le charge de toute facon

je vais reecrire mes algorithme et on verra bien ce que ca donnerais

merci bcp de votre aide
je posterais la version qui marcherait

[souviron34]

quand je dis pas de conception, je veux dire,que je ne passe pas par lediagrammes et le reste, mais sinon, y a tout a fait une conception
alors ce que je dois faire est comme suit:

je travaillesur des images astronomique;
donc une image est une collecte de sous-images
comme les dispositifs d'aquisition ne sont pas fiable a 100%, il nous faut corriger le fond du ciel,
donc, je calcule l'intersection entre chaque deux images, ce qui reviens a les localiser dans l'espace(les coordonnees des points inf-gauche et sup-droit)

donc pour chaque intersection de deux images, je calcule deux coefficients suivant les valeurs des pixels dans les images donnees et leur carte de poids

a la fin de cette etape, j'aurais construit un systeme d'equation lineaire a resoudre par la methode LU par exemple, ce qui me donnerais au final les fonds de ciel de chaque images
on faisant la soustracation, " image[i]-fond_ciel[i]) je trouve des images final normalement plus belles a voir, plus adaptees aux scientifiques...

et il restera que l'etape de rassembler les morceaux qui est faits ailleurs
NB: pour une meme region du ciel y a plusieurs acquisitions , et cela pour obetnir au final une meilleure image, la plus fidele possible a la realite
merci de bien vouloir m'aider

j'ai déjà fait de la correction de fond de ciel (mon premier métier était astronome), et je n vois pas en quoi cela ne peut pas être fait image par image, avec une image résultante construite au fur et à mesure....

En général, le fond de ciel est calculé en écrêtant (éliminant les pics), et moyenner plusieurs images. Mais même pour la moyenne, on n'a pas besoin de toutes les images ouvertes ....

[MPEG4]

j'essaie d'experimenter une autre methode
celle des moyennes et des medians s'avere un peu limitee quand on parle de gros objets
la, j'implemente dans un premeir temps "Backgroundmatching" avant de voir les methodes plus complexes telles les B-splines.. nefin c'est pas encore arrete...

[MPEG4]

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
int Create_System(char *Dir, char ***list, double  ***SD, double ***SW , int *Nb_files, double **M, double **Z, int *status)
{
  fitsfile *fd, *fw;
  char  *filed, *filew;
  int i,j;
 
  char *comment,
    *extweight=".weight.fits", 
    *extdata=".fits";
 
  void *nulval=NULL;
  int anynul;
  long NAXIS1, NAXIS2,CRPIX1, CRPIX2;
 
  RECT *R;
  List_Files(Dir, list, Nb_files, status);
 
  R=(RECT*)malloc(sizeof(RECT)*(*Nb_files));
  *SD=(double**)malloc(sizeof(double*)*(*Nb_files));
  *SW=(double**)malloc(sizeof(double*)*(*Nb_files));
 
  for (i=0;i<(*Nb_files);i++)
    {
      Name_frame(Dir, (*list)[i], extdata,&filed);
      Name_frame(Dir, (*list)[i], extweight,&filew);
      printf("%s\n%s\n",filed, filew);
      fits_open_file(&fd, filed,READONLY,status); 
      fits_open_file(&fw, filew,READONLY,status); 
      free(filed);
      free(filew);
 
      R[i]=Create_Rect(0,0,0,0);
      fits_read_key(fw,TLONG, "NAXIS1" , &NAXIS1,comment, status);
      fits_read_key(fw,TLONG, "NAXIS2" , &NAXIS2,comment, status);
      fits_read_key(fw,TLONG, "CRPIX1" , &CRPIX1,comment, status);
      fits_read_key(fw,TLONG, "CRPIX2" , &CRPIX2,comment, status);
 
      R[i]->Xmin=(long)(CRPIX1-(long)(NAXIS1/2));
      R[i]->Ymin=(long)(CRPIX2-(long)(NAXIS2/2));
      R[i]->Xmax=R[i]->Xmin+NAXIS1;
      R[i]->Ymax=R[i]->Ymin+NAXIS2;
 
      (*SD)[i]=(double*)malloc(sizeof(double)*NAXIS1*NAXIS2);
      (*SW)[i]=(double*)malloc(sizeof(double)*NAXIS1*NAXIS2);
      long fpixel[2]={1,1};
      long lpixel[2]={NAXIS1,NAXIS2};
      long inc[2]={1,1};
      fits_read_subset(fd, TDOUBLE, fpixel, lpixel, inc, nulval,  (*SD)[i], &anynul, status);
      fits_read_subset(fw, TDOUBLE, fpixel, lpixel, inc, nulval,  (*SW)[i], &anynul, status);
 
      fits_close_file(fd,status);
      fits_close_file(fw,status);
 
      if(*status)
	printf("statut = %d erreur!!",  *status);
      else
	printf(" %ld %ld %ld %ld\n", R[i]->Xmin, R[i]->Ymin, R[i]->Xmax, R[i]->Ymax);
 
      }
....
}

manque les tests de bonnes allocations, mais en principe ca va aller pour ca
merci pour votre aide precieuse
la, je dois readapter mon algorithme du calcul du systeme suivant la nouvelle architecture, mais normalement , ca deverait aller aussi
merci encore une fois

[MPEG4]

Encore une question:

Svp, a votre avis, ca serait mieux que j'utilise un mmap ou simplement charger tout le corps de l'image en memoire, quelle est la facon la plus propre et celle qui permet de charger le maximum d'images en memoire?
Merci de bien vouloir m'eclairer sur ce point
Cordialement

[wiztricks]

Encore une question:

Svp, a votre avis, ca serait mieux que j'utilise un mmap ou simplement charger tout le corps de l'image en memoire, quelle est la facon la plus propre et celle qui permet de charger le maximum d'images en memoire?
Merci de bien vouloir m'eclairer sur ce point
Cordialement

Je n'aime pas ton premier code: j'aurais préféré que le chargement d'un fichier constitue une routine spécifique plutôt que d'être encapsulé dans un gros machin qui fait 'tout' d'un coup.
Ce n'est pas une question d'esthétique... Si tu subdivises tu auras beaucoup moins de tests a faire pour t'assurer que tout marche. Comme ensuite tu construis en assemblant des primitives que tu sais fonctionner, le code sera plus simple et beaucoup plus maintenable.

mmap était un artifice pour accéder au contenu des fichiers sans avoir à les lire directement. Au départ nous voulions éviter d'avoir 360*359 lectures de fichiers. Comme tu es contrainte par la librairie FIPS de lire et de stocker en mémoire les données, l'utilisation de mmap n'est plus pertinente.
=> nous ne faisons que 360 lectures et c'est bien.

mmap pourra être 'utile' dans un deuxième temps s'il y a besoin d'optimiser ton programme. Les modifications seraient limitées aux mallocs.
L'idée est il va falloir plus de 0,5 Go de mémoire virtuelle pour y copier les images. On pourrait utiliser mmap pour pré-allouer la mémoire physique correspondante et lui associer un fichier de 'swap' spécifique (plutôt que le swap général du système).

Mais fait fonctionner d'abord ton programme, ce type d'optimisation peut attendre.
-W

[MPEG4]

Tout a fait, j'ai dejas commencé a réecrire les routines de telle sorte a recupérer les données du header ainsi que les donneés des fichiers image et weight en meme temps, je me suis rendu compte en relisant mon code ce matin , c'est vrai que j'aurais dû etre plus eveillée ...

c'est vrai que c'est pas propre mais je voulais avoir au moins une version qui me fait quelque chose, d'autant plus que c'est la premiere fois que je sois affrontée a ecrire un vrai programme, qui aura son utilité si je réussi

je vais rassembler le tout en une seule structure

Code :

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

1
2
3
4
5
6
7
8
 
typedef struct
 {
     int naxis1, naxis2;
     double crpix1; crpix2;
     double *SD;//sauvegarder les pixels de l'image .fits
     double *SW; // sauvegarder les pixels de l'image .weight.fits
 } frame, *FRAME;

voila, donc j'aurais les fonctions suivantes:

Code :

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

1
2
3
4
 
FRAME *Create_Frame( char *Dir, char *name);
void  Overlap(FRAME *F1, FRAME *F2, double *M, double *Diff);
void Create_System(char* Dir, double **M, double **Z);

plus les fonctions periph qui me feront le reste du travail

me reste aussi a fixer la methode de resoudre le systeme, car la matrice M est singuliere, ce qui veut dire qu'il faut fixer la variable et la ligne a iliminer

mais je ferais tout cela ce soir et je vous tiendrais au courant de mon avancement

merci bien de votre aide, et si vous avez des idees
je suis toujours prenante
merci encore

[MPEG4]

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
 
typedef struct
{
  long Xmin,Ymin;//lower corner
  long Xmax, Ymax;//upper corner
 
  double *SD;
  double *SW;
} frame, *Frame;
 
/******************************************************************/
int str_sub ( char *s, unsigned int start, unsigned int end, char **res );//soustraire une sous chaine
int List_Files(char *Dir, char ***list_files, int *Nb_files);//mets dans un tableau toutes les racines des fichiers .fits sans les concatener avec la directory
 
int Create_Frame(char *Dir, char *racine, Frame *Res );//cree une frame a partir des images donnees et weight
void Free(Frame F);//detruit un frame
 
/********************************************************************/
int OverLap(Frame F1, Frame F2, double *M, double *D);//calcul la region d'intersection entre deux frames
 
//--------------------------------------------------------------------
int Create_System(char *Dir, char ***list, Frame **CCD , int *Nb_files, double **M, double **Z );//cree le systeme M*E=Z
int Offset( double *M, double *B, double **E);//resoud le systeme
int Substract_BackSky_Frame(char *DirSource, char *DirDest, char *name ,char *ext_sky, Frame F, double E);  //soustrai une constante d'une image suivant son ficheir weight et sauvegarde le resultat dans une nouvelles image
int Substract_BackSky(char *DirSource, char *DirDest, char **liste ,char *ext_sky, Frame *F, double *E);  //idem mais pour toutes les images
//---------------------------------------------------------------------

voila ma nouvelle conception
si vous avez des remarques, tout est bien venu

[MPEG4]

merci bien pour votre aide,
voila, mon programme de base marche bien , mais les resulats ne sont pas fameux
l'image resultats n'est pas tres loin de l'image d'origine, juste un facteur en moins par CCD, mais le bruit est toujours la!!

donc me faudra trouver une meilleure methode pour l'extraction du fond du ciel, si par hasard un atsronome passe par ici, et qu'il a des idees prometteuses, s'il peut m'aider, je serais bien reconnaissante

Merci a tous pour votre aide

[souviron34]

ben il faudrait savoir que représentent tes images ?

Obtenues avec quelles conditions ?

lors de ma thèse (il y a un certain nombre d'années), j'étais dans une des 3 équipes au monde (et la seule en France), à faire des images CCD.


Le zéro était obtenu par moyennage de environ 10 photos prises au crépuscule et à l'aube, au zénith, à temps de pose croissant, pour chaque filtre.

Cela donnait d'une part l'offset (le zéro éléctronique) de chaque pixel, et le rendement de chaque pixel (efficacité par rayonnement).

[MPEG4]

ops,
pas tres au courant des conditions d'acquisition des image, je suis formee en informatique sans aucune notion dans ce domaine la, malgre que je m'y interesse, et meme , le seul domaine qui m'interesse reellement
ce que je sais, c'est que je dois developper une methode de modelisation et de soustraction du fond du ciel applique a tout type d'images astronomiques, mais dans l'immediat, faudra que ca marche sur des images a gros objets( par rapport a la taille d'un CCD)
alors voila, je dois trouver une solution automatique, la developper et la alide, dans moins d e deux mois...

[souviron34]

c'est pourtant essentiel....

Regarde ma thèse ("Métallicité dans les galaxies elliptiques grâce à des observations à l'aide d'une caméra CCD", 1984, Paris V).

2 solutions :

• tu potasses les docs/bouquins/thèses
• je peux être sous-traitant

[MPEG4]

Merci bien pour votre aide
avez vous une version electronique d evotre these? ca me serait plus facile a recuperer

[souviron34]

non.

En 1984 les thèses c'était du papier....

mais tu es où ? ça doit se trouver à la biblothèque de l'endroit où tu travailles...

[MPEG4]

ah, c'est vrai j'y ai pas pense du moment que je ne suis etudiante de l'institut

oui, effectivement, je crois avoir droit au document
merci bien pour les directives

[Emmanuel Delahaye]

Es-tu toujours interesse a m'aider dans mon stage?
il me reste a peu pres un mois et je dois peaufiner la modélisation du fond en polynôme, et si j'ai le temps, travailler en radial peut etre vu la diffusion sur la camera, pour enfin, optimiser les procedures ( utilisation de mmap et des threading) pour pouvoir les appliquer sur des donnees en full resolution

Je suis bien perdu dans mon stage mais je n'ai pas envie de decrocher, c'est le domaine qui m'interesse le plus et je dois faire mes preuves...

J'ai rien compris. C'est quoi la question sur le langage C ? Et c'est quoi le rapport avec POSIX (ici, section POSIX ...) ?