openCARP
Doxygen code documentation for the open cardiac electrophysiology simulator openCARP
IGBheader.cc
Go to the documentation of this file.
1 // SPDX-FileCopyrightText: Copyright (c) NumeriCor GmbH
2 // SPDX-License-Identifier: Apache-2.0
3 
12 #include "IGBheader.h"
13 
14 #include <stdlib.h>
15 #include <stdio.h>
16 #include <iostream>
17 #include <assert.h>
18 #include <math.h>
19 
20 namespace opencarp {
21 
22 using namespace std;
23 
24 // -------------- Bits de statut pour Header_Read et Header_Write ------
25 #define MOT_CLEF_INV 2
26 #define GRANDEUR_INV 4
27 
28 /*
29  * Types de trames
30  */
31 #define MIN_TRAME 0
32 #define C8 0
33 #define C4 1
34 #define HEX 2
35 #define HEXEDGES 3
36 #define HEXBRIDGES 4
37 #define HEXLINES 5
38 #define HEX2 6
39 #define MAX_TRAME 6
40 #define NTRAMES 7
41 
42 #define LF 0x0A
43 #define FF 0x0C
44 #define CR 0x0D
45 
46 /*---------------------------------------------------------------------------*\
47 
48  y x-> 1 2 3 4 5
49  |
50  v
51  X|X|X|X|X|X
52  1 -o-o-o-o-o-
53  X|X|X|X|X|X
54  2 -o-o-o-o-o-
55  \|/ X|X|X|X|X|X
56 C8: -o- 3 -o-o-o-o-o-
57  /|\ X|X|X|X|X|X
58  4 -o-o-o-o-o-
59  X|X|X|X|X|X
60  5 -o-o-o-o-o-
61  X|X|X|X|X|X
62 
63 \*---------------------------------------------------------------------------*/
64 /*---------------------------------------------------------------------------*\
65 
66  y x-> 1 2 3 4 5
67  |
68  v
69  | | | | |
70  1 -o-o-o-o-o-
71  | | | | |
72  2 -o-o-o-o-o-
73  | | | | | |
74 C4: -o- 3 -o-o-o-o-o-
75  | | | | | |
76  4 -o-o-o-o-o-
77  | | | | |
78  5 -o-o-o-o-o-
79  | | | | |
80 
81 \*---------------------------------------------------------------------------*/
82 /*---------------------------------------------------------------------------*\
83 
84  y x-> 1 2 3 4 5 1 2 3 4 5
85  |
86  v 1 2 3 4 5
87 
88  \|\|\|\|\| \ / \ / \ / \ / \ /
89  1 -o-o-o-o-o- -o---o---o---o---o---
90  \| /|/|/|/|/|/ / \ / \ / \ / \ / \ /
91  y impair -o- 2 -o-o-o-o-o- ---o---o---o---o---o-
92  /| \|\|\|\|\|\ \ / \ / \ / \ / \ / \
93 HEX: 3 -o-o-o-o-o- -o---o---o---o---o---
94  |/ /|/|/|/|/|/ / \ / \ / \ / \ / \ /
95  y pair -o- 4 -o-o-o-o-o- ---o---o---o---o---o-
96  |\ \|\|\|\|\|\ \ / \ / \ / \ / \ / \
97  5 -o-o-o-o-o- -o---o---o---o---o---
98  /|/|/|/|/| / \ / \ / \ / \ / \
99 
100 \*---------------------------------------------------------------------------*/
101 /*---------------------------------------------------------------------------*\
102 
103  x x-> 1 2 3 4 5 1 2 3 4 5 6
104 
105  impair pair 1 2 3 4 5
106 
107  y 1 2 3 4 5
108  |
109  \| v 1 2 3 4 5
110  y%4==1 -o- -o-
111  /| \| \| \| \ / . \ / . \ / .
112  1 -o-o-o-o-o- -o---o---o---o---o---o
113  | / /| /| /| / \ . / \ . / \ .
114  y%4==2 o o 2 o o o o o o o o o o
115  | / |/ |/ |/ . \ / . \ / . \
116 HEXEDGES: 3 -o-o-o-o-o- -o---o---o---o---o---o
117  |/ |\ |\ |\ . / \ . / \ . /
118  y%4==3 -o- -o- 4 o o o o o o o o o o
119  |\ \| \| \| \ / . \ / . \ / .
120  5 -o-o-o-o-o- -o---o---o---o---o---o
121  | \ /| /| /| / \ . / \ . / \ .
122  y%4==0 o o 6 o o o o o o o o o o
123  | \ |/ |/ | . \ / . \ / . \
124 
125 \*---------------------------------------------------------------------------*/
126 /*---------------------------------------------------------------------------*\
127 
128  x x-> 1 2 3 4 5 1 2 3 4 5 6
129 
130 
131  impair pair 1 2 3 4 5
132 
133 
134  y 1 2 3 4 5
135  |
136  v
137  y%4==1 o -o- 1 2 3 4 5
138  . . .
139  1 o -o- o -o- o o -o- o -o- o -o
140  . . .
141  | / | / | / | \ . . / \ . . / \ .
142  y%4==2 o o 2 o o o o o o o o o o
143  | / | / | / | . \ / . . \ / . . \
144  . . .
145 HEXBRIDGES: 3 o -o- o -o- o -o- o -o- o -o- o
146  . . .
147  | \ | \ | . / \ . . / \ . . /
148  y%4==3 o -o- 4 o o o o o o o o o o
149  | \ | \ | / . . \ / . . \ / .
150  . . .
151  5 o -o- o -o- o o -o- o -o- o -o
152  . . .
153  | \ | / | / | \ . . / \ . . / \ .
154  y%4==0 o o 6 o o o o o o o o o o
155  | \ | / | / | . \ / . . \ / . . \
156 
157 \*---------------------------------------------------------------------------*/
158 /*---------------------------------------------------------------------------*\
159 
160  x x-> 1 2 3 4 5 1 2 3 4 5 6
161 
162  impair pair 1 2 3 4 5
163 
164  y 1 2 3 4 5
165  |
166  \| v 1 2 3 4 5
167  y%4==1 o o
168  /| \| \| \./ \./ \./
169  1 o o o o o o o o o o o
170  / | /| /| / /.\ /.\ /.\
171  y%4==2 -o- -o- 2 -o-o-o-o-o- ---o---o---o---o---o---
172  / | / |/ |/ \./ \./ \./
173 HEXLINES: 3 o o o o o o o o o o o
174  |/ |\ |\ /.\ /.\ /.\
175  y%4==3 o o 4 -o-o-o-o-o- ---o---o---o---o---o---
176  |\ \| \| \./ \./ \./
177  5 o o o o oo o o o o o o
178  \ | /| /| / /.\ /.\ /.\
179  y%4==0 -o- -o- 6 -o-o-o-o-o- ---o---o---o---o---o---
180  \ | / |/ |/ / \./ \./
181 
182 \*---------------------------------------------------------------------------*/
183 /*---------------------------------------------------------------------------*\
184 
185  x-> 1 2 3 4 5 1 2 3 4 5 6
186 
187  y 1 2 3 4 5
188  |
189  v 1 2 3 4 5
190 
191  \| 1 2 3 4 5
192  y%4==1 -o-
193  /| \|\|\|\|\| \ / \ / \ / \ / \ /
194  1 -o-o-o-o-o- -o---o---o---o---o---o
195  |/ /|/|/|/|/| / \ / \ / \ / \ / \ /
196  y%4==2 -o- 2 -o-o-o-o-o- ---o---o---o---o---o-
197  /| /|/|/|/|/|/ \ / \ / \ / \ / \ / \
198 HEX2: 3 -o-o-o-o-o- -o---o---o---o---o---o
199  |/ \|\|\|\|\| / \ / \ / \ / \ / \ /
200  y%4==3 -o- 4 -o-o-o-o-o- ---o---o---o---o---o-
201  |\ \|\|\|\|\| \ / \ / \ / \ / \ / \
202  5 -o-o-o-o-o- -o---o---o---o---o---o
203  \| /|/|/|/|/| / \ / \ / \ / \ / \ /
204  y%4==0 -o- 6 -o-o-o-o-o- ---o---o---o---o---o-
205  |\ /|/|/|/|/| / \ / \ / \ / \ / \
206 
207 \*---------------------------------------------------------------------------*/
208 
209 // -------------- Definitions pour conv_date --------------------------- */
210 
211 #define FRANCAIS 0
212 #define ANGLAIS 1
213 #define NUMERIQUE 2
214 #define IGB_DATE 0
215 
216 // -------------- Constantes diverses ---------------------------------- */
217 
218 #define MAXL 80 // Longueur maximale d'une ligne d'entete */
219 #define N_MAX_ITEMS 30 // Nombre maximal d'items optionnels */
220 #define L_MAX_ITEM 49 // Longueur maximale pour un item
221 #ifndef VRAI
222 #define VRAI 1
223 #endif
224 #ifndef FAUX
225 #define FAUX 0
226 #endif
227 
228 
229 int my_fputs( FILE *, char * );
230 
231 bool Header_Quiet = false;
232 char Header_Message[256];
233 
234 const char *Header_Type[] =
235  {
236  "", "byte", "char", "short", "long", "float", "double", "complex",
237  "double_complex", "rgba", "structure", "pointer", "list","int","uint",
238  "ushort",
239  "vec3f","vec3d","vec4f","vec4d","hfloat","vec9f","vec9d"
240  };
241 
242 
244 const char *deprecated[] = {
245  "fac_x", "fac_y", "fac_z", "fac_t"
246  };
247 
248 //* size of the stored data, not the variable type
249 unsigned short Data_Size[] =
250  {
251  0, sizeof(Byte), sizeof(char), sizeof(short), sizeof(long), sizeof(float),
252  sizeof(double), 0, 0, 0, 0, sizeof(void *), 0, sizeof(int), sizeof(UInt),
253  sizeof(unsigned short),
254  3*sizeof(float), 3*sizeof(double), 4*sizeof(float), 4*sizeof(double),
255  sizeof(short_float), 9*sizeof(float), 9*sizeof(double)
256  };
257 
258 
260 int Num_Components[] =
261  {
262  0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 3, 3, 4, 4, 1, 9, 9
263  };
264 
265 
266 long unsigned
267 Header_Systeme_No[] =
268  {
269  IGB_BIG_ENDIAN,
270  IGB_LITTLE_ENDIAN
271  };
272 
273 const char
274 *Header_Systeme[] =
275  {
276  "big_endian",
277  "little_endian"
278  };
279 
280 
281 static bool
282 is_deprecated( char *s ) {
283  for( unsigned int i=0; i<sizeof(deprecated)/sizeof(deprecated[0]); i++ )
284  if( !strcmp( s, deprecated[i] ) )
285  return true;
286  return false;
287 }
288 
289 
290 #define MAKE_CONSISTENT( D ) \
291  if( bool_dim_##D && bool_inc_##D && bool_##D ) \
292  if( v_dim_##D != v_inc_##D * (v_##D-1) ) { \
293  fprintf( stderr, "Adjusting dim_%s to make dimensions consistent\n", #D ); \
294  v_dim_##D = v_inc_##D * (v_##D-1);\
295  }
296 
297 
298 IGBheader::IGBheader( FILE *f, bool _read, bool quiet )
299 {
300  fileptr(f);
301  if( _read )
302  if( read( quiet ) )
303  throw 1;
304 }
305 
306 
307 IGBheader::~IGBheader()
308 {}
309 
310 
311 // set input/output file
312 void IGBheader::fileptr( FILE* fp )
313 {
314  file = fp;
315 }
316 
317 
318 int IGBheader::write()
319 {
320  int statut = 1;
321 
322  if (getenv("HEADER_QUIET")) Header_Quiet = VRAI;
323 
324  if (file==NULL) {
325  if (!Header_Quiet)
326  cerr<< "\nERREUR: descripteur de fichier nul\n";
327  snprintf(Header_Message, sizeof Header_Message, "\nERREUR: descripteur de fichier nul\n");
328  return(0) ;
329  }
330 
331  if (v_type<IGB_MIN_TYPE || v_type>IGB_MAX_TYPE) {
332  if (!Header_Quiet)
333  cerr<< "\nHeader_Write: type inconnu: "<< v_type;
334  snprintf(Header_Message, sizeof Header_Message, "\nHeader_Write: type inconnu: %d\n",
335  v_type);
336  return (0);
337  }
338  const char *type = Header_Type[v_type];
339 
340  if (v_type==IGB_STRUCTURE && v_taille<1) {
341  if (!Header_Quiet)
342  cerr << "\nHeader_Write: taille invalide:" << v_taille << endl;
343  snprintf(Header_Message, sizeof Header_Message, "\nHeader_Write: taille invalide: %d\n",
344  v_taille);
345  return (0);
346  }
347 
348  if (v_trame<MIN_TRAME || v_trame>MAX_TRAME) {
349  if (!Header_Quiet)
350  fprintf(stderr, "\nHeader_Write: trame inconnue: %d\n", v_trame);
351  snprintf(Header_Message, sizeof Header_Message, "\nHeader_Write: trame inconnue: %d\n",
352  v_trame);
353  return (0);
354  }
355 
356  MAKE_CONSISTENT( x );
357  MAKE_CONSISTENT( y );
358  MAKE_CONSISTENT( z );
359  MAKE_CONSISTENT( t );
360 
361  char ligne[1024];
362  if (bool_t) {
363  if (bool_z) {
364  snprintf(ligne, sizeof ligne, "x:%d y:%d z:%d t:%d type:%s systeme:%s ",
365  v_x, v_y, v_z, v_t, type, systemestr());
366  } else {
367  snprintf(ligne, sizeof ligne, "x:%d y:%d t:%d type:%s systeme:%s ",
368  v_x, v_y, v_t, type, systemestr());
369  }
370  } else {
371  if (bool_z) {
372  snprintf(ligne, sizeof ligne, "x:%d y:%d z:%d type:%s systeme:%s ",
373  v_x, v_y, v_z, type, systemestr());
374  } else {
375  snprintf(ligne, sizeof ligne, "x:%d y:%d type:%s systeme:%s ",
376  v_x, v_y, type, systemestr());
377  }
378  }
379  int n_car = strlen(ligne);
380 
381  int n_lignes = 1;
382  int n_items = 0;
383  int l_item[N_MAX_ITEMS+1];
384  char items[N_MAX_ITEMS+1][L_MAX_ITEM];
385  /*
386  Le mot-clef "taille" n'est ecrit que pour le type STRUCTURE mais il est
387  obligatoire pour ce cas.
388  */
389  if (v_type==IGB_STRUCTURE) {
390  snprintf(&items[n_items][0], L_MAX_ITEM, "taille:%d ", v_taille);
391  l_item[n_items] = strlen(&items[n_items][0]);
392  n_items++;
393  }
394  if (bool_org_x) {
395  snprintf(&items[n_items][0], L_MAX_ITEM, "org_x:%g ", v_org_x);
396  l_item[n_items] = strlen(&items[n_items][0]);
397  n_items++;
398  }
399  if (bool_org_y) {
400  snprintf(&items[n_items][0], L_MAX_ITEM, "org_y:%g ", v_org_y);
401  l_item[n_items] = strlen(&items[n_items][0]);
402  n_items++;
403  }
404  if (bool_org_z) {
405  snprintf(&items[n_items][0], L_MAX_ITEM, "org_z:%g ", v_org_z);
406  l_item[n_items] = strlen(&items[n_items][0]);
407  n_items++;
408  }
409  if (bool_org_t) {
410  snprintf(&items[n_items][0], L_MAX_ITEM, "org_t:%g ", v_org_t);
411  l_item[n_items] = strlen(&items[n_items][0]);
412  n_items++;
413  }
414  if (bool_dim_x) {
415  snprintf(&items[n_items][0], L_MAX_ITEM, "dim_x:%g ", v_dim_x);
416  l_item[n_items] = strlen(&items[n_items][0]);
417  n_items++;
418  }
419  if (bool_inc_x) {
420  snprintf(&items[n_items][0], L_MAX_ITEM, "dim_x:%g ", v_inc_x);
421  l_item[n_items] = strlen(&items[n_items][0]);
422  n_items++;
423  }
424  if (bool_dim_y) {
425  snprintf(&items[n_items][0], L_MAX_ITEM, "dim_y:%g ", v_dim_y);
426  l_item[n_items] = strlen(&items[n_items][0]);
427  n_items++;
428  }
429  if (bool_inc_y) {
430  snprintf(&items[n_items][0], L_MAX_ITEM, "dim_y:%g ", v_inc_y);
431  l_item[n_items] = strlen(&items[n_items][0]);
432  n_items++;
433  }
434  if (bool_dim_z) {
435  snprintf(&items[n_items][0], L_MAX_ITEM, "dim_z:%g ", v_dim_z);
436  l_item[n_items] = strlen(&items[n_items][0]);
437  n_items++;
438  }
439  if (bool_inc_z) {
440  snprintf(&items[n_items][0], L_MAX_ITEM, "dim_z:%g ", v_inc_z);
441  l_item[n_items] = strlen(&items[n_items][0]);
442  n_items++;
443  }
444  if (bool_dim_t) {
445  snprintf(&items[n_items][0], L_MAX_ITEM, "dim_t:%g ", v_dim_t);
446  l_item[n_items] = strlen(&items[n_items][0]);
447  n_items++;
448  }
449  if (bool_inc_t) {
450  snprintf(&items[n_items][0], L_MAX_ITEM, "inc_t:%g ", v_inc_t);
451  l_item[n_items] = strlen(&items[n_items][0]);
452  n_items++;
453  }
454  if (bool_vect_z) {
455  snprintf(&items[n_items][0], L_MAX_ITEM, "vect_z:1 ");
456  l_item[n_items] = strlen(&items[n_items][0]);
457  n_items++;
458  }
459  if (bool_unites_x) {
460  snprintf(&items[n_items][0], L_MAX_ITEM, "unites_x:%.40s ", v_unites_x);
461  l_item[n_items] = strlen(&items[n_items][0]);
462  n_items++;
463  }
464  if (bool_unites_y) {
465  snprintf(&items[n_items][0], L_MAX_ITEM, "unites_y:%.40s ", v_unites_y);
466  l_item[n_items] = strlen(&items[n_items][0]);
467  n_items++;
468  }
469  if (bool_unites_z) {
470  snprintf(&items[n_items][0], L_MAX_ITEM, "unites_z:%.40s ", v_unites_z);
471  l_item[n_items] = strlen(&items[n_items][0]);
472  n_items++;
473  }
474  if (bool_unites_t) {
475  snprintf(&items[n_items][0], L_MAX_ITEM, "unites_t:%.40s ", v_unites_t);
476  l_item[n_items] = strlen(&items[n_items][0]);
477  n_items++;
478  }
479  if (bool_num) {
480  snprintf(&items[n_items][0], L_MAX_ITEM, "num:%d ", v_num);
481  l_item[n_items] = strlen(&items[n_items][0]);
482  n_items++;
483  }
484  if (bool_bin) {
485  snprintf(&items[n_items][0], L_MAX_ITEM, "bin:%d ", v_bin);
486  l_item[n_items] = strlen(&items[n_items][0]);
487  n_items++;
488  }
489  if (bool_trame) {
490  switch (v_trame) {
491  case C8:
492  snprintf(&items[n_items][0], L_MAX_ITEM, "trame:c8 ");
493  break;
494  case C4:
495  snprintf(&items[n_items][0], L_MAX_ITEM, "trame:c4 ");
496  break;
497  case HEX:
498  snprintf(&items[n_items][0], L_MAX_ITEM, "trame:hex ");
499  break;
500  case HEXEDGES:
501  snprintf(&items[n_items][0], L_MAX_ITEM, "trame:hexedges ");
502  break;
503  case HEXBRIDGES:
504  snprintf(&items[n_items][0], L_MAX_ITEM, "trame:hexbridges ");
505  break;
506  case HEXLINES:
507  snprintf(&items[n_items][0], L_MAX_ITEM, "trame:hexlines ");
508  break;
509  case HEX2:
510  snprintf(&items[n_items][0], L_MAX_ITEM, "trame:hex2 ");
511  break;
512  }
513  l_item[n_items] = strlen(&items[n_items][0]);
514  n_items++;
515  }
516  if (bool_lut) {
517  snprintf(&items[n_items][0], L_MAX_ITEM, "lut:%d ", v_lut);
518  l_item[n_items] = strlen(&items[n_items][0]);
519  n_items++;
520  }
521  if (bool_comp) {
522  snprintf(&items[n_items][0], L_MAX_ITEM, "comp:%d ", v_comp);
523  l_item[n_items] = strlen(&items[n_items][0]);
524  n_items++;
525  }
526  if (bool_epais) {
527  snprintf(&items[n_items][0], L_MAX_ITEM, "epais:%g ", v_epais);
528  l_item[n_items] = strlen(&items[n_items][0]);
529  n_items++;
530  }
531  if (bool_unites) {
532  snprintf(&items[n_items][0], L_MAX_ITEM, "unites:%.40s ", v_unites);
533  l_item[n_items] = strlen(&items[n_items][0]);
534  n_items++;
535  }
536  if (bool_facteur) {
537  snprintf(&items[n_items][0], L_MAX_ITEM, "facteur:%g ", v_facteur);
538  l_item[n_items] = strlen(&items[n_items][0]);
539  n_items++;
540  }
541  if (bool_zero) {
542  snprintf(&items[n_items][0], L_MAX_ITEM, "zero:%g ", v_zero);
543  l_item[n_items] = strlen(&items[n_items][0]);
544  n_items++;
545  }
546  if ( v_transparent != NULL ) {
547  char *p=(char *)v_transparent, value[MAXL];
548  int a;
549  for ( a=0; a<Data_Size[v_type]; a++ )
550  snprintf( value+a*2, L_MAX_ITEM, "%0.2x", *(p++) );
551  value[2*Data_Size[v_type]] = '\0';
552  snprintf(&items[n_items][0], L_MAX_ITEM, "transparent:%s ", value );
553  l_item[n_items] = strlen(&items[n_items][0]);
554  n_items++;
555  }
556  if (bool_struct_desc) {
557  snprintf(&items[n_items][0], L_MAX_ITEM, "struct:%.40s ", v_struct_desc);
558  l_item[n_items] = strlen(&items[n_items][0]);
559  n_items++;
560  }
561  if (bool_aut_name) {
562  snprintf(&items[n_items][0], L_MAX_ITEM, "aut:%.40s ", v_aut_name);
563  l_item[n_items] = strlen(&items[n_items][0]);
564  n_items++;
565  }
566  int n_car_total = 0;
567  int n_comment = 0;
568  char **comment;
569  if (bool_comment) {
570  comment = v_comment;
571  while (*comment != NULL) {
572  n_comment++;
573  n_car_total += strlen(*comment++) + 3;
574  }
575  }
576 
577  /*
578  Ecrit tous les items, sauf les commentaires
579  */
580  for (int i=0;i<n_items;i++) {
581  if (n_car+l_item[i]<71) { /* Ajoute a la ligne courante s'il reste de la place */
582  strcat(ligne, &items[i][0]);
583  n_car += l_item[i];
584  } else { /* Sinon, ecrit cette ligne et commence-en une autre */
585  ligne[n_car++] = '\r';
586  ligne[n_car++] = '\n';
587  ligne[n_car] = '\000';
588  n_car_total += n_car;
589  if (puts_fcn(file, ligne)==-1) {
590  if (!Header_Quiet) {
591  fprintf(stderr, "\nHeader_Write: Erreur a l'ecriture \n");
592  perror("\n *** ");
593  fprintf(stderr, "\n");
594  }
595  snprintf(Header_Message, sizeof Header_Message, "\nHeader_Write: Erreur a l'ecriture \n");
596  return (0);
597  }
598  strcpy(ligne, &items[i][0]);
599  n_car = l_item[i];
600  n_lignes++;
601  }
602  }
603 
604  /*
605  Termine la derniere ligne
606  */
607  ligne[n_car++] = '\r';
608  ligne[n_car++] = '\n';
609  ligne[n_car] = '\000';
610  n_car_total += n_car;
611  if (puts_fcn(file, ligne )==-1) {
612  if (!Header_Quiet) {
613  fprintf(stderr, "\nHeader_Write: Erreur a l'ecriture \n");
614  perror("\n *** ");
615  fprintf(stderr, "\n");
616  }
617  snprintf(Header_Message, sizeof Header_Message, "\nHeader_Write: Erreur a l'ecriture \n");
618  return (0);
619  }
620  n_lignes++;
621 
622  /*
623  Determine le nombre de caracteres et de lignes supplementaires
624  necessaires
625  */
626  int n_blocs = 1 + (n_car_total-1)/1024;
627  int n_car_sup = n_blocs*1024 - n_car_total;
628  int n_lig_sup;
629  if (n_car_sup>0) {
630  n_lig_sup = 1 + (n_car_sup-1)/72;
631  } else {
632  n_lig_sup = 0;
633  }
634  int n_car_dl = 1 + (n_car_sup-1)%72;
635 
636  /*
637  Ecrit les commentaires
638  */
639  if (bool_comment) {
640  comment = v_comment;
641  while (*comment != NULL) {
642  n_car = fprintf(file, "#%.80s\r\n", *comment++);
643  if (n_car==0) {
644  if (!Header_Quiet) {
645  fprintf(stderr, "\nHeader_Write: Erreur a l'ecriture \n");
646  perror("\n *** ");
647  fprintf(stderr, "\n");
648  }
649  snprintf(Header_Message, sizeof Header_Message, "\nHeader_Write: Erreur a l'ecriture \n");
650  return (0);
651  }
652  }
653  }
654 
655  /*
656  Complete l'entete a un multiple de 1024 caracteres
657  */
658  for (int i=0;i<70;i++) ligne[i] = ' ';
659  ligne[70] = '\r';
660  ligne[71] = '\n';
661  ligne[72] = '\000';
662  for (int i=0;i<n_lig_sup-1;i++) {
663  if (puts_fcn(file, ligne)==-1) {
664  if (!Header_Quiet) {
665  fprintf(stderr, "\nHeader_Write: Erreur a l'ecriture \n");
666  perror("\n *** ");
667  fprintf(stderr, "\n");
668  }
669  snprintf(Header_Message, sizeof Header_Message, "\nHeader_Write: Erreur a l'ecriture \n");
670  return 0;
671  }
672  }
673 
674  /*
675  La derniere ligne se termine par un saut de page (FF)
676  */
677  for (int i=0;i<n_car_dl-2;i++) ligne[i] = ' ';
678  if (n_car_dl>2) ligne[n_car_dl-3] = '\r';
679  if (n_car_dl>1) ligne[n_car_dl-2] = '\n';
680  ligne[n_car_dl-1] = FF;
681  ligne[n_car_dl] = '\000';
682  if (puts_fcn(file, ligne )==-1) {
683  if (!Header_Quiet) {
684  fprintf(stderr, "\nHeader_Write: Erreur a l'ecriture \n");
685  perror("\n *** ");
686  fprintf(stderr, "\n");
687  }
688  snprintf(Header_Message, sizeof Header_Message, "\nHeader_Write: Erreur a l'ecriture \n");
689  return (0);
690  }
691 
692  if (n_car_total>1024) {
693  if (!Header_Quiet)
694  fprintf(stderr,
695  "\nHeader_Write ATTENTION: etiquette de grandeur non-standard \n");
696  snprintf(Header_Message, sizeof Header_Message,
697  "\nHeader_Write ATTENTION: etiquette de grandeur non-standard \n");
698  statut |= GRANDEUR_INV;
699  } else {
700  snprintf(Header_Message, sizeof Header_Message,
701  "\nHeader_Write: Entete transcrite sans problemes\n");
702  }
703 
704  return (statut);
705 
706 }
707 
708 
717 int IGBheader::read( bool quiet )
718 {
719  int go=VRAI, nosup=VRAI;
720  int in, com=0;
721  char str[MAXL+1];
722  int statut=0;
723  float v_fac_t;
724  bool bool_fac_t = false;
725 
726  Header_Quiet = quiet;
727 
728  /* --- pour toutes les lignes de l'entete (def=8) ou jusqu'a un <FF> -- */
729  for ( int s=8; (s>0 || nosup) && go; s-- ) {
730 
731  /* --- lit la ligne dans le fichier --- */
732  int i = 0 ;
733  int bytes_read = tell(file);
734  if( bytes_read<0 )
735  return 2;
736 
737  while (1) {
738 
739  /* --- (ligne trop longue) --> erreur --- */
740  if ( i >= 80 ) {
741  if (!Header_Quiet)
742  fprintf(stderr,
743  "\nERREUR ligne trop longue (>80) dans l'entete !\n" ) ;
744  snprintf(Header_Message, sizeof Header_Message,
745  "\nERREUR ligne trop longue (>80) dans l'entete !\n" ) ;
746  return ERR_LINE_TOO_LONG;
747  }
748 
749  /* --- lit le caractere suivant --- */
750  in = getc(file);
751 
752  /* --- (EOF dans l'entete) --> erreur --- */
753  if ( in == -1 ) {
754  if (!Header_Quiet)
755  fprintf(stderr,
756  "\nERREUR Fin de fichier dans l'entete !\n" ) ;
757  snprintf(Header_Message, sizeof Header_Message,
758  "\nERREUR Fin de fichier dans l'entete !\n" ) ;
759  return ERR_EOF_IN_HEADER;
760  }
761 
762  /* --- FF --> termine le header --- */
763  else if ( in == FF ) {
764  str[i] = '\000' ;
765  go = FAUX ;
766  break ;
767  }
768 
769  /* --- CR et LF --> termine la ligne --- */
770  else if ( in == CR ) {
771  str[i] = '\000' ;
772  } else if ( in == LF ) {
773  str[i] = '\000' ;
774  break ;
775  }
776 
777  /* --- (0x20 < caractere > 0x7E) si non --> erreur --- */
778  else if ( in && ! isprint(in) ) {
779  if (!Header_Quiet)
780  fprintf(stderr,
781  "\nERREUR caract. non imprim. 0x%.2X dans "
782  "l'entete at byte number %ld\n", in, tell(file) );
783  snprintf(Header_Message, sizeof Header_Message,
784  "\nERREUR caract. non imprim. 0x%.2X dans l'entete !\n", in );
785  return ERR_UNPRINTABLE_CHAR;
786  } else {
787  str[i++] = (char) in ;
788  }
789 
790  }
791 
792  /* --- ----- ----- ----- sauve les commentaires ----- ----- --- */
793  for ( char* pt_1=str; *pt_1; pt_1++ ) {
794 
795  /* --- '*' ou '#' = commentaires ------> dans comment --- */
796  if ( *pt_1 == '*' || *pt_1 == '#') {
797  if ( *(pt_1+1) ) {
798  v_comment[com] = (char *)malloc( strlen(pt_1+1) + 1 ) ;
799  strcpy( v_comment[com++], pt_1+1 ) ;
800  if (com%NALLOC == 0)
801  v_comment = (char **)
802  realloc(v_comment, (com+NALLOC)*sizeof(char *));
803  v_comment[com] = NULL ;
804  bool_comment = VRAI;
805  }
806  *pt_1 = '\000' ;
807  break ;
808  }
809 
810  /* --- convertit majuscule un minuscules --- */
811  if (isupper(*pt_1)) *pt_1 = tolower( *pt_1 ) ;
812 
813  }
814 
815 
816  /* --- ----- ----- ----- analyse la ligne ----- ----- ----- --- */
817  for ( char *pt_1=strtok(str," ,;\t"); pt_1; pt_1=strtok(NULL," ,;\t") ) {
818 
819  /* --- separe la chaine de caract. --- */
820  /* --- pt_1 pointe au key_word ---- */
821  /* --- pt_2 pointe a la donne ---- */
822  char *pt_2;
823  for ( pt_2 = pt_1; *pt_2 != ':'; pt_2 ++ )
824  if ( ! *pt_2 ) {
825  if (!Header_Quiet)
826  fprintf(stderr,
827  "\nERREUR de syntaxe dans l'entete (%s)\n", pt_1);
828  snprintf(Header_Message, sizeof Header_Message,
829  "\nERREUR de syntaxe dans l'entete (%s)\n", pt_1);
830  return ERR_IGB_SYNTAX;
831  }
832 
833  *pt_2++ = '\000' ;
834 
835  /* --- recherche le mot-clef --- */
836  if ( ! strcmp( pt_1, "x" ) ) {
837  v_x = atoi( pt_2 ) ;
838  bool_x = VRAI;
839 
840  } else if ( ! strcmp( pt_1, "y" ) ) {
841  v_y = atoi( pt_2 ) ;
842  bool_y = VRAI;
843 
844  } else if ( ! strcmp( pt_1, "z" ) ) {
845  v_z = atoi( pt_2 ) ;
846  bool_z = VRAI;
847 
848  } else if ( ! strcmp( pt_1, "t" ) ) {
849  v_t = atoi( pt_2 ) ;
850  bool_t = VRAI;
851 
852  /* Pour compatibilite avec les vielles images */
853  } else if ( ! strcmp( pt_1, "sup" ) ) {
854  s += atoi( pt_2 ) ;
855  nosup = FAUX;
856 
857  } else if ( ! strcmp( pt_1, "type" ) ) {
858 
859  for( int htype=IGB_MIN_TYPE; htype<=IGB_MAX_TYPE; htype++ )
860  if ( !strcmp( pt_2, Header_Type[htype] ) ) {
861  v_type = htype;
862  }
863  bool_type = VRAI;
864 
865  } else if ( ! strcmp( pt_1, "taille" ) ) {
866  v_taille = atoi( pt_2 ) ;
867  bool_taille = VRAI;
868 
869  } else if ( ! strcmp( pt_1, "systeme" ) ) {
870  v_systeme = INCONNU;
871  for (i=0;i<N_SYSTEMES;i++) {
872  if ( ! strcmp( pt_2, Header_Systeme[i] ) ) {
873  v_systeme = Header_Systeme_No[i] ;
874  break;
875  }
876  }
877 
878  } else if ( ! strcmp( pt_1, "bin" ) ) {
879  v_bin = atoi( pt_2 ) ;
880  bool_bin = VRAI;
881 
882  } else if ( ! strcmp( pt_1, "trame" ) ) {
883 
884  if ( ! strcmp( pt_2, "c8" ) ) {
885  v_trame = C8 ;
886  } else if ( ! strcmp( pt_2, "c4" ) ) {
887  v_trame = C4 ;
888  } else if ( ! strcmp( pt_2, "hex" ) ) {
889  v_trame = HEX ;
890  } else if ( ! strcmp( pt_2, "hexedges" ) ) {
891  v_trame = HEXEDGES ;
892  } else if ( ! strcmp( pt_2, "hexbridges" ) ) {
893  v_trame = HEXBRIDGES ;
894  } else if ( ! strcmp( pt_2, "hexlines" ) ) {
895  v_trame = HEXLINES ;
896  } else if ( ! strcmp( pt_2, "hex2" ) ) {
897  v_trame = HEX2 ;
898  }
899  bool_trame = VRAI;
900 
901  } else if ( ! strcmp( pt_1, "num" ) ) {
902  v_num = atoi( pt_2 ) ;
903  bool_num = VRAI;
904 
905  } else if ( ! strcmp( pt_1, "comp" ) ) {
906  v_comp = atoi( pt_2 ) ;
907  bool_comp = VRAI;
908 
909  } else if ( ! strcmp( pt_1, "lut" ) ) {
910  v_lut = atoi( pt_2 ) ;
911  bool_lut = VRAI;
912 
913  } else if ( ! strcmp( pt_1, "dim_x" ) ) {
914  v_dim_x = atof( pt_2 ) ;
915  bool_dim_x = VRAI;
916 
917  } else if ( ! strcmp( pt_1, "dim_y" ) ) {
918  v_dim_y = atof( pt_2 ) ;
919  bool_dim_y = VRAI;
920 
921  } else if ( ! strcmp( pt_1, "dim_z" ) ) {
922  v_dim_z = atof( pt_2 ) ;
923  bool_dim_z = VRAI;
924 
925  } else if ( ! strcmp( pt_1, "dim_t" ) ) {
926  v_dim_t = atof( pt_2 ) ;
927  bool_dim_t = VRAI;
928 
929  } else if ( ! strcmp( pt_1, "inc_x" ) ) {
930  v_inc_x = atof( pt_2 ) ;
931  bool_inc_x = VRAI;
932 
933  } else if ( ! strcmp( pt_1, "inc_y" ) ) {
934  v_inc_y = atof( pt_2 ) ;
935  bool_inc_y = VRAI;
936 
937  } else if ( ! strcmp( pt_1, "inc_z" ) ) {
938  v_inc_z = atof( pt_2 ) ;
939  bool_inc_z = VRAI;
940 
941  } else if ( ! strcmp( pt_1, "inc_t" ) ) {
942  v_inc_t = atof( pt_2 ) ;
943  bool_inc_t = VRAI;
944 
945  } else if ( ! strcmp( pt_1, "org_x" ) ) {
946  v_org_x = atof( pt_2 ) ;
947  bool_org_x = VRAI;
948 
949  } else if ( ! strcmp( pt_1, "org_y" ) ) {
950  v_org_y = atof( pt_2 ) ;
951  bool_org_y = VRAI;
952 
953  } else if ( ! strcmp( pt_1, "org_z" ) ) {
954  v_org_z = atof( pt_2 ) ;
955  bool_org_z = VRAI;
956 
957  } else if ( ! strcmp( pt_1, "org_t" ) ) {
958  v_org_t = atof( pt_2 ) ;
959  bool_org_t = VRAI;
960 
961  } else if ( ! strcmp( pt_1, "vect_z" ) ) {
962  bool_vect_z = VRAI;
963 
964  } else if ( ! strcmp( pt_1, "unites_x" ) ) {
965  strncpy( v_unites_x, pt_2, 40 ) ;
966  bool_unites_x = VRAI;
967 
968  } else if ( ! strcmp( pt_1, "unites_y" ) ) {
969  strncpy( v_unites_y, pt_2, 40 ) ;
970  bool_unites_y = VRAI;
971 
972  } else if ( ! strcmp( pt_1, "unites_z" ) ) {
973  strncpy( v_unites_z, pt_2, 40 ) ;
974  bool_unites_z = VRAI;
975 
976  } else if ( ! strcmp( pt_1, "unites_t" ) ) {
977  strncpy( v_unites_t, pt_2, 40 ) ;
978  bool_unites_t = VRAI;
979 
980  } else if ( ! strcmp( pt_1, "epais" ) ) {
981  v_epais = atof( pt_2 ) ;
982  bool_epais = VRAI;
983 
984  } else if ( ! strcmp( pt_1, "unites" ) ) {
985  strncpy( v_unites, pt_2, 40 ) ;
986  bool_unites = VRAI;
987 
988  } else if ( ! strcmp( pt_1, "facteur" ) ) {
989  v_facteur = atof( pt_2 ) ;
990  bool_facteur = VRAI;
991 
992  } else if ( ! strcmp( pt_1, "zero" ) ) {
993  v_zero = atof( pt_2 ) ;
994  bool_zero = VRAI;
995 
996  } else if ( ! strcmp( pt_1, "struct" ) ) {
997  strncpy( v_struct_desc, pt_2, 40 ) ;
998  bool_struct_desc = VRAI;
999 
1000  } else if ( ! strcmp( pt_1, "aut" ) ) {
1001  strncpy( v_aut_name, pt_2, 40 ) ;
1002  bool_aut_name = VRAI;
1003 
1004  } else if ( !strcmp( pt_1, "transparent" ) ) {
1005  strcpy( transstr, pt_2 );
1006  bool_transparent = VRAI;
1007 
1008  } else {
1009  if( is_deprecated( pt_1 ) ){
1010  if (!Header_Quiet)
1011  fprintf(stderr,"\nATTENTION: mot-clef %s obsolete !\n", pt_1 ) ;
1012  if( !strcmp( pt_1, "fac_t" ) ){
1013  v_fac_t = atof( pt_2 );
1014  bool_fac_t = VRAI;
1015  }
1016  } else {
1017  if (!Header_Quiet)
1018  fprintf(stderr,"\nATTENTION: mot-clef %s non reconnu !\n", pt_1 );
1019  snprintf(Header_Message, sizeof Header_Message,
1020  "\nATTENTION: mot-clef %s non reconnu !\n", pt_1 ) ;
1021  statut |= MOT_CLEF_INV;
1022  }
1023  }
1024  }
1025  }
1026  /* determine the transparent value if one was chosen */
1027  if ( bool_transparent ) {
1028  if ( strlen(transstr) != 2*Data_Size[v_type] ) {
1029  fprintf(stderr,"ATTENTION: ignoring invalid transparent value !\n");
1030  } else {
1031  char s[3], *p, *v;
1032  s[2] = '\0';
1033  v = (char *)(v_transparent = calloc( Data_Size[v_type], 1 ));
1034  for ( int i=0; i<Data_Size[v_type]; i++ ) {
1035  s[0] = transstr[i*2];
1036  s[1] = transstr[i*2+1];
1037  v[i] = strtol( s, &p, 16 );
1038  }
1039  }
1040  }
1041 
1042  /* --- l'info x y et type est obligatoire --- */
1043  if ( !bool_x || !bool_y || !bool_type ) {
1044  if (!Header_Quiet)
1045  fprintf(stderr, "\nERREUR x, y ou type non definis\n") ;
1046  snprintf(Header_Message, sizeof Header_Message, "\nERREUR x, y ou type non definis\n") ;
1047  return ERR_UNDEFINED_X_Y_TYPE ;
1048  }
1049 
1050  /* --- calcul des inc et dim --- */
1051  if ( bool_dim_x )
1052  if ( bool_inc_x ) {
1053  float dim_x = v_inc_x * v_x ;
1054  if ( dim_x != v_dim_x ) {
1055  if (!Header_Quiet) {
1056  fprintf(stderr, "\nATTENTION:\n") ;
1057  fprintf(stderr,
1058  "conflit entre x (%d) * inc_x (%.12g) = %.12g et dim_x (%.12g)\n",
1059  v_x, v_inc_x, dim_x, v_dim_x) ;
1060  }
1061  snprintf(Header_Message, sizeof Header_Message,
1062  "conflit entre x (%d) * inc_x (%.12g) = %.12g et dim_x (%.12g)\n",
1063  v_x, v_inc_x, dim_x, v_dim_x) ;
1064  statut = WARN_DIM_INCONSISTENT ;
1065  }
1066  } else {
1067  v_inc_x = v_dim_x / v_x ;
1068  bool_inc_x = VRAI;
1069  }
1070  else {
1071  v_dim_x = v_x * v_inc_x ;
1072  if ( bool_inc_x ) bool_dim_x = VRAI;
1073  }
1074 
1075  if ( bool_dim_y )
1076  if ( bool_inc_y ) {
1077  float dim_y = v_inc_y * v_y ;
1078  if ( dim_y != v_dim_y ) {
1079  if (!Header_Quiet) {
1080  fprintf(stderr, "\nATTENTION:\n") ;
1081  fprintf(stderr,
1082  "conflit entre y (%d) * inc_y (%.12g) = %.12g et dim_y (%.12g)\n",
1083  v_y, v_inc_y, dim_y, v_dim_y) ;
1084  }
1085  snprintf(Header_Message, sizeof Header_Message,
1086  "conflit entre y (%d) * inc_y (%.12g) = %.12g et dim_y (%.12g)\n",
1087  v_y, v_inc_y, dim_y, v_dim_y) ;
1088  statut = WARN_DIM_INCONSISTENT ;
1089  }
1090  } else {
1091  v_inc_y = v_dim_y / v_y ;
1092  bool_inc_y = VRAI;
1093  }
1094  else {
1095  v_dim_y = v_y * v_inc_y ;
1096  if ( bool_inc_y ) bool_dim_y = VRAI;
1097  }
1098 
1099  if ( bool_dim_z )
1100  if ( bool_inc_z ) {
1101  float dim_z = v_inc_z * v_z ;
1102  if ( dim_z != v_dim_z ) {
1103  if (!Header_Quiet) {
1104  fprintf(stderr, "\nATTENTION:\n") ;
1105  fprintf(stderr,
1106  "conflit entre z (%d) * inc_z (%.12g) = %.12g et dim_z (%.12g)\n",
1107  v_z, v_inc_z, dim_z, v_dim_z) ;
1108  }
1109  snprintf(Header_Message, sizeof Header_Message,
1110  "conflit entre z (%d) * inc_z (%.12g) = %.12g et dim_z (%.12g)\n",
1111  v_z, v_inc_z, dim_z, v_dim_z) ;
1112  statut = WARN_DIM_INCONSISTENT ;
1113  }
1114  } else {
1115  v_inc_z = v_dim_z / v_z ;
1116  bool_inc_z = VRAI;
1117  }
1118  else {
1119  v_dim_z = v_z * v_inc_z ;
1120  if ( bool_inc_z ) bool_dim_z = VRAI;
1121  }
1122 
1123  if( !bool_inc_t && bool_fac_t ) {
1124  bool_inc_t = VRAI;
1125  v_inc_t = v_fac_t;
1126  }
1127  if ( bool_dim_t )
1128  if ( bool_inc_t ) {
1129  float dim_t = v_inc_t * (v_t-1) ;
1130  if ( fabs(dim_t - v_dim_t) > v_inc_t ) {
1131  if (!Header_Quiet) {
1132  fprintf(stderr, "\nATTENTION:\n") ;
1133  fprintf(stderr,
1134  "conflit entre t (%d) * inc_t (%.12g) = %.12g et dim_t (%.12g)\n",
1135  v_t, v_inc_t, dim_t, v_dim_t) ;
1136  }
1137  snprintf(Header_Message, sizeof Header_Message,
1138  "conflit entre t (%d) * inc_t (%.12g) = %.12g et dim_t (%.12g)\n",
1139  v_t, v_inc_t, dim_t, v_dim_t) ;
1140  statut = WARN_DIM_INCONSISTENT ;
1141  }
1142  } else {
1143  v_inc_t = v_dim_t / (v_t - 1) ;
1144  bool_inc_t = VRAI;
1145  }
1146  else {
1147  v_dim_t = (v_t-1) * v_inc_t ;
1148  if ( bool_inc_t )
1149  bool_dim_t = VRAI;
1150  }
1151 
1152  if ( bool_taille ) {
1153  if (v_type!=IGB_STRUCTURE) {
1154  if (!Header_Quiet)
1155  fprintf(stderr,
1156  "\nERREUR taille redefinie pour type autre que structure\n") ;
1157  snprintf(Header_Message, sizeof Header_Message,
1158  "\nERREUR taille redefinie pour type autre que structure\n") ;
1159  return ERR_SIZE_REDEFINED;
1160  }
1161  } else {
1162  if (v_type==IGB_STRUCTURE) {
1163  if (!Header_Quiet)
1164  fprintf(stderr,
1165  "\nERREUR taille non definie pour type structure\n") ;
1166  snprintf(Header_Message, sizeof Header_Message,
1167  "\nERREUR taille non definie pour type structure\n") ;
1168  return ERR_SIZE_NOT_DEFINED;
1169  } else {
1170  v_taille = Data_Size[v_type];
1171  }
1172  }
1173 
1174  if (tell(file)!=1024) {
1175  fseek(file, 1024, SEEK_SET);
1176  if (!Header_Quiet) {
1177  fprintf(stderr,
1178  "\nATTENTION: etiquette de grandeur non-standard: %ld \n", tell(file));
1179  }
1180  snprintf(Header_Message, sizeof Header_Message,
1181  "\nATTENTION: etiquette de grandeur non-standard \n");
1182  statut |= GRANDEUR_INV;
1183  } else {
1184  snprintf(Header_Message, sizeof Header_Message,
1185  "\nHeader_Read: Etiquette lue sans problemes\n");
1186  }
1187 
1188  if (bool_vect_z) {
1189  v_vect_z = (float *)malloc(v_z*sizeof(float));
1190  fread(v_vect_z, sizeof(float), v_z, file);
1191  }
1192 
1193  return statut;
1194 }
1195 
1196 /*
1197  * add a comment line
1198  * clear comments is NULL is passed
1199  */
1200 void IGBheader::comment(char *ligne)
1201 {
1202  int i = 0, n_lignes = 0;
1203 
1204  if ( ligne == NULL ) {
1205  while ( v_comment[n_lignes] != NULL )
1206  free( v_comment[n_lignes++] );
1207  return;
1208  }
1209 
1210  while (v_comment[i++]!=NULL) n_lignes++;
1211  v_comment = (char **)realloc(v_comment, (n_lignes+2)*sizeof(char *));
1212 
1213  v_comment[n_lignes] = (char *)malloc(strlen(ligne)+1) ;
1214  strcpy(v_comment[n_lignes++], ligne) ;
1215  v_comment[n_lignes] = NULL;
1216  bool_comment = true;
1217 }
1218 
1219 const char *IGBheader::systemestr( void )
1220 {
1221  int i;
1222 
1223  for ( i=0; i<N_SYSTEMES; i++ )
1224  if ( Header_Systeme_No[i] == v_systeme )
1225  break;
1226 
1227  if ( i<N_SYSTEMES )
1228  return Header_Systeme[i];
1229  else
1230  return NULL;
1231 }
1232 
1233 
1234 void IGBheader::systeme( const char* s )
1235 {
1236  int i;
1237  for ( i=0; i<N_SYSTEMES; i++ )
1238  if ( !strncmp( Header_Systeme[i], s, strlen(s) ) )
1239  break;
1240 
1241  if ( i<N_SYSTEMES )
1242  v_systeme = Header_Systeme_No[i];
1243 }
1244 
1245 
1246 void IGBheader::type( char *datatype )
1247 {
1248  int tn=IGB_MIN_TYPE;
1249  while ( tn<=IGB_MAX_TYPE && strcmp(Header_Type[tn],datatype) )
1250  tn++;
1251  if ( tn<=IGB_MAX_TYPE )
1252  v_type = tn;
1253  else {
1254  cerr << "illegal data type specified for IGB header" << endl;
1255  exit(1);
1256  }
1257  bool_type = true;
1258 }
1259 
1260 
1261 long IGBheader::tell( FILE *f )
1262 {
1263  return ftell(f);
1264 }
1265 
1266 
1267 int IGBheader::puts_fcn( FILE* f, char* s )
1268 {
1269  return fputs(s, f);
1270 }
1271 
1272 
1278 void IGBheader :: swab( void *data, int nd )
1279 {
1280  if ( data_size()==1 || v_type==IGB_RGBA )
1281  return;
1282 
1283  unsigned char *bp = (unsigned char *)data;
1284  int ds = data_size()/num_components();
1285 
1286  if ( nd<0 ) nd = v_x*v_y*v_z*v_t;
1287 
1288  nd *= num_components();
1289 
1290  switch ( ds ) {
1291  case 2:
1292  for ( int i=0; i<nd; i++ ) {
1293  unsigned char tmpb = bp[0];
1294  bp[0] = bp[1];
1295  bp[1] = tmpb;
1296  bp += data_size();
1297  }
1298  break;
1299  case 4:
1300  for ( int i=0; i<nd; i++ ) {
1301  unsigned char tmpb = bp[0];
1302  bp[0] = bp[3];
1303  bp[3] = tmpb;
1304  tmpb = bp[1];
1305  bp[1] = bp[2];
1306  bp[2] = tmpb;
1307  bp += data_size();
1308  }
1309  break;
1310  case 8:
1311  for ( int i=0; i<nd; i++ ) {
1312  unsigned char tmpb = bp[0];
1313  bp[0] = bp[7];
1314  bp[7] = tmpb;
1315  tmpb = bp[1];
1316  bp[1] = bp[6];
1317  bp[6] = tmpb;
1318  tmpb = bp[2];
1319  bp[2] = bp[5];
1320  bp[5] = tmpb;
1321  tmpb = bp[3];
1322  bp[3] = bp[4];
1323  bp[4] = tmpb;
1324  bp += data_size();
1325  }
1326  break;
1327  }
1328 }
1329 
1330 
1332 int IGBheader::endian()
1333 {
1334  float val=IGB_ENDIAN_VAL;
1335  unsigned char le_val[] = { IGB_LITTLE_END_REP },
1336  *pval = (unsigned char *)(&val);
1337 
1338  assert( sizeof(float) == 4 );
1339 
1340  if ( *pval == le_val[0] )
1341  return IGB_LITTLE_ENDIAN;
1342  else
1343  return IGB_BIG_ENDIAN;
1344 }
1345 
1346 } // namespace opencarp
opencarp::IGBheader::read
int read(bool quiet=false)
Definition: IGBheader.cc:717
opencarp::IGBheader::systemestr
const char * systemestr(void)
Definition: IGBheader.cc:1219
opencarp::IGBheader::systeme
int systeme(void)
Definition: IGBheader.h:270
opencarp::IGBheader::IGBheader
IGBheader(FILE *f=NULL, bool read=false, bool quiet=false)
Definition: IGBheader.cc:298
opencarp::IGBheader::comment
char ** comment(void)
Definition: IGBheader.h:239
opencarp::IGBheader::fileptr
FILE * fileptr(void)
Definition: IGBheader.h:232
opencarp::IGBheader::swab
void swab(void *, int nd=-1)
Definition: IGBheader.cc:1278
opencarp::UInt
unsigned int UInt
Definition: IGBheader.h:118
opencarp::Header_Type
const char * Header_Type[]
Definition: IGBheader.cc:234
opencarp::Data_Size
unsigned short Data_Size[]
Definition: IGBheader.cc:249
opencarp::Header_Message
char Header_Message[256]
Definition: IGBheader.cc:232
opencarp::deprecated
const char * deprecated[]
Definition: IGBheader.cc:244
opencarp::my_fputs
int my_fputs(FILE *, char *)
opencarp::short_float
uint16_t short_float
Definition: short_float.h:33
opencarp::Header_Systeme_No
long unsigned Header_Systeme_No[]
Definition: IGBheader.cc:267
opencarp::Num_Components
int Num_Components[]
Definition: IGBheader.cc:260
opencarp::Byte
unsigned char Byte
Definition: IGBheader.h:108
opencarp::Header_Systeme
const char * Header_Systeme[]
Definition: IGBheader.cc:274
opencarp::Header_Quiet
bool Header_Quiet
Definition: IGBheader.cc:231
GRANDEUR_INV
#define GRANDEUR_INV
Definition: IGBheader.cc:26
FF
#define FF
Definition: IGBheader.cc:43
LF
#define LF
Definition: IGBheader.cc:42
N_MAX_ITEMS
#define N_MAX_ITEMS
Definition: IGBheader.cc:219
MAX_TRAME
#define MAX_TRAME
Definition: IGBheader.cc:39
C8
#define C8
Definition: IGBheader.cc:32
HEXLINES
#define HEXLINES
Definition: IGBheader.cc:37
CR
#define CR
Definition: IGBheader.cc:44
HEX
#define HEX
Definition: IGBheader.cc:34
L_MAX_ITEM
#define L_MAX_ITEM
Definition: IGBheader.cc:220
HEXEDGES
#define HEXEDGES
Definition: IGBheader.cc:35
HEXBRIDGES
#define HEXBRIDGES
Definition: IGBheader.cc:36
MAXL
#define MAXL
Definition: IGBheader.cc:218
C4
#define C4
Definition: IGBheader.cc:33
MAKE_CONSISTENT
#define MAKE_CONSISTENT(D)
Definition: IGBheader.cc:290
HEX2
#define HEX2
Definition: IGBheader.cc:38
VRAI
#define VRAI
Definition: IGBheader.cc:222
FAUX
#define FAUX
Definition: IGBheader.cc:225
MOT_CLEF_INV
#define MOT_CLEF_INV
Definition: IGBheader.cc:25
ERR_IGB_SYNTAX
#define ERR_IGB_SYNTAX
Definition: IGBheader.h:88
IGB_LITTLE_ENDIAN
#define IGB_LITTLE_ENDIAN
Definition: IGBheader.h:35
IGB_ENDIAN_VAL
#define IGB_ENDIAN_VAL
Definition: IGBheader.h:81
N_SYSTEMES
#define N_SYSTEMES
Definition: IGBheader.h:36
ERR_UNDEFINED_X_Y_TYPE
#define ERR_UNDEFINED_X_Y_TYPE
Definition: IGBheader.h:89
IGB_RGBA
#define IGB_RGBA
Definition: IGBheader.h:48
IGB_MAX_TYPE
#define IGB_MAX_TYPE
Definition: IGBheader.h:63
IGB_STRUCTURE
#define IGB_STRUCTURE
Definition: IGBheader.h:49
WARN_DIM_INCONSISTENT
#define WARN_DIM_INCONSISTENT
Definition: IGBheader.h:92
INCONNU
#define INCONNU
Definition: IGBheader.h:32
IGB_BIG_ENDIAN
#define IGB_BIG_ENDIAN
Definition: IGBheader.h:34
ERR_EOF_IN_HEADER
#define ERR_EOF_IN_HEADER
Definition: IGBheader.h:85
IGB_MIN_TYPE
#define IGB_MIN_TYPE
Definition: IGBheader.h:62
ERR_SIZE_NOT_DEFINED
#define ERR_SIZE_NOT_DEFINED
Definition: IGBheader.h:91
ERR_LINE_TOO_LONG
#define ERR_LINE_TOO_LONG
Definition: IGBheader.h:86
NALLOC
#define NALLOC
Definition: IGBheader.h:29
ERR_UNPRINTABLE_CHAR
#define ERR_UNPRINTABLE_CHAR
Definition: IGBheader.h:87
ERR_SIZE_REDEFINED
#define ERR_SIZE_REDEFINED
Definition: IGBheader.h:90
IGB_LITTLE_END_REP
#define IGB_LITTLE_END_REP
Definition: IGBheader.h:82
Generated by doxygen 1.9.1