~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~

Linux Cross Reference
Tina4/src/tools/sequence/seq_tool.c

Version: ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2 
  3 seq_tool.c
  4 
  5 NAT 7/4/97
  6 
  7 Modification:  4-Oct-99 by IH, DICOM functionality  added
  8 
  9 */
 10 
 11 #include <stdio.h>
 12 #include <sys/param.h>
 13 #include <string.h>
 14 #include <tina/sys.h>
 15 #include <tina/sysfuncs.h>
 16 #include <tina/math.h>
 17 #include <tina/mathfuncs.h>
 18 #include <tina/tv.h>
 19 #include <tina/vision.h>
 20 #include <tina/visionfuncs.h>
 21 #include <tina/image.h>
 22 #include <tina/seqdefs.h>
 23 #include <tina/seqoral.h>
 24 #include <tina/seqpro.h>
 25 #include <tina/AIR.h>
 26 #include <tina/stimdef.h>
 27 #include <tina/utiltoolfuncs.h>
 28 /*
 29 #include <tina/dicom/dicom.h>
 30 #include <tina/dicom/lst.h>
 31 #include <tina/dicom/dicom_objects.h>
 32 */
 33 
 34 #define IMAGE_MASK      1
 35 #define TMPEDG_MASK     2
 36 #define AIFF_FILE       0
 37 #define ANLZ_FILE       1
 38 #define RAD_FILE        2
 39 #define NEMA_FILE       3
 40 #define MIPL_FILE       4
 41 #define AVS_FILE        5
 42 #define DICOM_FILE      6       
 43 
 44 #define DYNSTIME        451
 45 
 46 extern void scan_files(char *dir, char *file);
 47 static int file_type = AIFF_FILE;
 48 static void *pfile;
 49 static void *pframe,*pstart,*pend;
 50 static Sequence    *seq = NULL;
 51 
 52 static double iscalx=1.0,iscaly=1.0,iscalz=1.0,iscalt=1.0;
 53 static void *as1,*as2,*as3,*at;
 54 static double     TE = 0.25;
 55 static float dynsttime = 0;
 56 
 57 
 58 int    get_seq_filechoice(void)
 59 {
 60   return(file_type);
 61 }
 62 
 63 static void file_choice_proc(int val)
 64 {
 65     file_type = val;
 66 }
 67 
 68 void get_iscales(double *iscx, double *iscy, double *iscz)
 69 {
 70    *iscx = iscalx;
 71    *iscy = iscaly;
 72    *iscz = iscalz;
 73 
 74 }
 75 
 76 
 77 static void    setup_default_dynstimes(Sequence *seq, float start, float inc)
 78 {
 79   void     dynstimes_free(float *t);
 80 
 81   List  *store = (List *)get_start_el();
 82   Imrect  *im = NULL;
 83   float   *times = NULL;
 84   int      i, end;
 85 
 86   end = (seq->seq_end - seq->seq_start)+1;
 87 
 88   for(i = seq->seq_start; i <= seq->seq_end; i++)
 89     {
 90       if ((store == NULL) || (store->to == NULL))
 91         continue;
 92       times = (float *)fvector_alloc(0, end);
 93   
 94       for (i = 0; i < end; i++)
 95          times[i] = start + (float)i*inc;
 96       im = (Imrect *)(store->to);
 97 /*
 98       im->props = proplist_rm(im->props, DYNSTIME);
 99 */
100       im->props = proplist_addifnp(im->props, (void *)times, DYNSTIME, dynstimes_free, true);
101 
102       store = store->next;
103     }
104   return;
105 }
106 
107 
108 static void    setup_default_TE(Sequence *seq, float TE)
109 {
110   List  *store = (List *)get_start_el();
111   Imrect  *im = NULL;
112   float   *fp = NULL;
113   int      i, end;
114 
115   end = (seq->seq_end - seq->seq_start);
116 
117   for(i = seq->seq_start; i <= seq->seq_end; i++)
118     {
119       if ((store == NULL) || (store->to == NULL))
120         continue;
121       fp = (float *)ralloc(sizeof(float));
122       *fp = TE;
123       im = (Imrect *)(store->to);
124 /*
125       im->props = proplist_rm(im->props, TE_DATA);
126 */
127       im->props = proplist_addifnp(im->props, (void *)fp, TE_DATA, rfree, true);
128 
129       store = store->next;
130     }
131   return;
132 }
133 
134 
135 static double dynstime_interval()
136 {
137   Imrect  *im;
138   List  *store = (List *)get_start_el();
139   float   *times;
140 
141   if ((store == NULL) || (store->to == NULL))
142      return (-1.0);
143   im = (Imrect *)(store->to);
144   
145   if ((times = (float *)prop_get(im->props, DYNSTIME)) == NULL)
146     return(-1.0);
147   
148   return((double)times[1]);
149 }
150 
151 
152 static void get_dyndata_proc(void)
153 {
154   Bool      nema_hdrinfo_extract(Sequence *s, void (*func));
155   Bool      nema_hdr_dynstimes_extract(FILE *fp, Imrect *im);
156   Bool      nema_hdr_heartrate_extract(FILE *fp, Imrect *im);
157   Bool      nema_hdr_TE_extract(FILE *fp, Imrect *im);
158   Bool      nema_hdr_patientdetails_extract(FILE *fp, Imrect *im);
159   Bool      nema_hdr_voxelscale_extract(FILE *fp, Imrect *im);
160 
161   Bool      mip_hdrinfo_extract(Sequence *s, void (*func));
162   Bool      mip_hdr_dynstimes_extract(FILE *fp, Imrect *im);
163   Bool      mip_hdr_TE_extract(FILE *fp, Imrect *im);
164 
165   Bool      dicom_hdrinfo_extract(Sequence *s, void (*func));
166   Bool      dicom_hdr_dynstimes_extract      ();
167   Bool      dicom_hdr_heartrate_extract      ();
168   Bool      dicom_hdr_TE_extract             ();
169   Bool      dicom_hdr_patientdetails_extract ();
170   Bool      dicom_hdr_voxelscale_extract     ();
171 
172   double    dynstime_interval();
173   double    tempit;
174 
175   Sequence *seq = NULL;
176 
177   seq = (Sequence *)get_seq_ptr();
178  
179   switch(get_seq_filechoice())
180     {
181     case NEMA_FILE :
182       if (!nema_hdrinfo_extract(seq, nema_hdr_dynstimes_extract)) 
183         if (!nema_hdrinfo_extract(seq, nema_hdr_heartrate_extract))
184           setup_default_dynstimes(seq, (float)dynsttime, (float)iscalt);
185       if ((tempit = dynstime_interval()) > -1.0)
186         iscalt = tempit;
187 
188       if (!nema_hdrinfo_extract(seq, nema_hdr_TE_extract))
189         setup_default_TE(seq, (float)TE);
190       nema_hdrinfo_extract(seq, nema_hdr_patientdetails_extract);
191       nema_hdrinfo_extract(seq, nema_hdr_voxelscale_extract);
192       break;
193 
194     case DICOM_FILE :
195       if (!dicom_hdrinfo_extract(seq, dicom_hdr_dynstimes_extract)) 
196         if (!dicom_hdrinfo_extract(seq, dicom_hdr_heartrate_extract))
197           setup_default_dynstimes(seq, (float)dynsttime, (float)iscalt);
198       if ((tempit = dynstime_interval()) > -1.0)
199         iscalt = tempit;
200       
201       if (!dicom_hdrinfo_extract(seq, dicom_hdr_TE_extract))
202         setup_default_TE(seq, (float)TE);
203       dicom_hdrinfo_extract(seq, dicom_hdr_patientdetails_extract);
204       dicom_hdrinfo_extract(seq, dicom_hdr_voxelscale_extract);
205       break;
206 
207     case MIPL_FILE :
208       if (!mip_hdrinfo_extract(seq, mip_hdr_TE_extract))
209         setup_default_TE(seq, (float)TE);
210       if (!mip_hdrinfo_extract(seq, mip_hdr_dynstimes_extract))
211         setup_default_dynstimes(seq, (float)dynsttime, (float)iscalt);
212       if ((tempit = dynstime_interval()) > -1.0)
213         iscalt = tempit;
214       break;
215 
216     default :
217       error("dynamic format not supported: using default time scale\n", warning);
218       setup_default_TE(seq, (float)TE);
219       setup_default_dynstimes(seq, (float)dynsttime, (float)iscalt);
220       break;
221     }
222 
223   return;
224 }
225 
226 void seq_free_proc(void)
227 {
228       Sequence *get_seq_ptr();
229       Sequence *seq = get_seq_ptr();
230       List *lptr = get_start_el();
231       Tv *seq_tv = seq_tv_get();
232 
233       if(seq==NULL) return;
234 
235       dd_list_rm(lptr, (void (*) ()) im_free);
236       lptr = NULL;
237       set_current_el(NULL);
238       set_start_el(NULL);
239       set_end_el(NULL);
240 
241       seq_image_set(NULL);
242       if (seq_tv == NULL) return;
243       tv_erase(seq_tv);
244       tv_free_background(seq_tv);
245       tv_init(seq_tv);
246 }
247 
248 static Sequence     *init_seq(Sequence *t)
249 {
250   char  *tdata;
251 
252   seq_free(t);
253 
254   if ((t = (Sequence *)seq_alloc(t)) == NULL)
255     return (NULL);
256 
257   t->number = 5;
258   t->seq_delay = 1000;
259   t->seq_start = 0;
260   t->seq_end = 100;
261 
262 
263   if ((tdata = (char *)getenv("TEMP_SEQ_DIR")) == NULL)
264     {
265       error("seq_tool: cannot find TEMP_SEQ_DIR", warning);
266       strcpy(t->filename, "");
267     }
268 
269   else
270     strcpy(t->filename, tdata);
271 
272   if ((tdata = (char *)getenv("TEMP_DATA_DIR")) == NULL)
273     {
274       error("seq_tool: cannot find TEMP_DATA_DIR", warning);
275       strcpy(t->datafile, "");
276     }
277 
278   else
279     strcpy(t->datafile, tdata);
280 
281   return (t);
282 }
283 
284 
285 static Vec3 *param_update()
286 {
287   void  coreg_slice_init(Vec3 *iscale);
288   void  coreg_coords_init();
289   void  dynstimes_free(float *a);
290 
291   Sequence *seq = get_seq_ptr();
292   List   *lptr = (List *)get_start_el();
293   Vec3     *iscale = NULL;
294   Imrect   *im = NULL;
295   float    *times;
296   int       i, tend = seq->seq_end - seq->seq_start;
297               
298   if (seq == NULL || lptr == NULL)
299      return NULL;
300 
301   iscale = vec3_alloc();
302   times  = fvector_alloc(0, tend);
303 
304   iscale->el[0] = iscalx;
305   iscale->el[1] = iscaly;
306   iscale->el[2] = iscalz;
307   
308   for (i = 0; i < tend; i++)
309     times[i] = (float)(i*iscalt);
310  
311   while (lptr != NULL)
312   {
313     im = (Imrect *)(lptr->to);
314     im->props = proplist_rm(im->props, VOXELS);
315     im->props = proplist_add(im->props, (void *)vec3_copy(iscale), 
316                 VOXELS, vec3_free);
317     im->props = proplist_rm(im->props, DYNSTIME);
318     im->props = proplist_add(im->props, (void *)fvector_copy((char *)times, 
319                 0, tend), DYNSTIME, dynstimes_free);
320     lptr = lptr->next;
321   }
322   
323   coreg_slice_init(iscale);
324   coreg_coords_init();
325   
326   return(iscale);
327 }
328 
329 
330 static void       get_image_seq_proc(Sequence *data)
331 {
332   Vec3 *read_image_seq(Sequence *data, int type);
333   void coreg_slice_init(Vec3 *iscale);
334   void coreg_coords_init();
335   Tv     *seq_tv_get(void);
336   Vec3   *iscale = NULL;
337 
338   seq_image_set(NULL);
339   if ((iscale = read_image_seq(data, file_type)) != NULL)
340   {
341      iscalx = iscale->el[0];
342      iscaly = iscale->el[1];
343      iscalz = iscale->el[2];
344      tw_fglobal_reset(as1);
345      tw_fglobal_reset(as2);
346      tw_fglobal_reset(as3);
347   }
348   else
349     iscale = param_update();
350   
351   tv_init(seq_tv_get());
352   data->goto_frame  = data->seq_start;
353   (void) tw_iglobal_reset(pframe);
354   coreg_slice_init(iscale);
355   coreg_coords_init();
356   get_dyndata_proc();
357   (void) tw_fglobal_reset(at);
358 }
359 
360 
361 static void       save_image_seq_proc(Sequence *data)
362 {
363   void seq_output(Sequence *data, int file_type); 
364 
365   param_update();
366   seq_output(data, file_type);
367 }
368 
369 
370 static void     tv_choice_proc(int val)
371 {
372     switch (val)
373     {
374       case 0:
375       {
376         if (seq_tv_get()==NULL)
377         {
378           seq_tv_set(seq_tv_make());
379          }
380          tv_set_next(seq_tv());
381          seq_image_on(1);
382       }
383       break;
384     }
385 }
386 
387 
388 static void     seq_check_proc(int val)
389 {
390     seq_image_on(val & IMAGE_MASK);
391     seq_edges_on(val & TMPEDG_MASK);
392 }
393  
394 
395 static void       show_last_proc(Sequence *data)
396 {
397   Imrect *im;
398 
399   data->goto_frame--;
400   goto_frame(data);
401   (void) tw_iglobal_reset(pframe);
402 }
403 
404 
405 static void       show_next_proc(Sequence *data)
406 {
407   Imrect *im;
408  
409   data->goto_frame++;
410   goto_frame(data);
411   (void) tw_iglobal_reset(pframe);
412 }
413 
414 
415 
416 static void       show_first_proc(Sequence *data)
417 {
418   Imrect *im, *seq_image_get();
419 
420   show_first(data);
421   if ((im = seq_image_get()) !=NULL)
422   {
423      data->goto_frame = data->seq_start;
424      (void) tw_iglobal_reset(pframe);
425   }
426 }
427 
428 
429 static void       show_end_proc(Sequence *data)
430 {
431   Imrect *im, *seq_image_get();
432   int  which_frame(Sequence *data, void *tim_ptr);
433 
434   show_end(data);
435   if((im = seq_image_get()) != NULL)
436   {
437     data->goto_frame = which_frame(data, (void *)im);
438     (void) tw_iglobal_reset(pframe);
439   }
440 }
441 
442 
443 static void       goto_frame_proc(Sequence *data)
444 {
445   goto_frame(data);
446 }
447 
448 
449 static void process_seq_proc(Sequence *data)
450 {
451     int i;
452     goto_frame_proc(data);
453     for(i = data->goto_frame; i <= data->seq_end
454                            && i >= 0; i++)
455     {
456         if(process_macro_proc()==0) break;
457         show_next_proc(data);
458     }
459 }
460 
461 void set_sfile(struct air16 *air1)
462 {
463    char *filename = air1->s_file;
464 
465    strcpy(seq->filename,filename);
466    tw_sglobal_reset(pfile);
467    seq->seq_start = 0;
468    seq->goto_frame = 0;
469    seq->seq_end = air1->s.z_dim; 
470    tw_iglobal_reset(pstart);
471    tw_iglobal_reset(pframe);
472    tw_iglobal_reset(pend);
473 }
474 
475 void set_rfile(struct air16 *air1, int num)
476 {
477    char *filename = air1->r_file;
478 
479    strcpy(seq->filename,filename);
480    parse_fname(NULL,seq->filename,num);
481    tw_sglobal_reset(pfile);
482    seq->seq_start = 0;
483    seq->goto_frame = 0;
484    seq->seq_end = air1->r.z_dim;
485    tw_iglobal_reset(pstart);
486    tw_iglobal_reset(pframe);
487    tw_iglobal_reset(pend);
488 }
489 
490 static void      delete_seq_frame(Sequence *data)
491 {
492   List  *get_current_el();
493   List  *lptr = get_current_el();
494   Tv      *seq_tv_get();
495   Tv      *tv_ptr = seq_tv_get();
496 
497   if ((lptr == NULL) || (tv_ptr == NULL))
498     return;
499 
500   if (lptr == get_end_el())
501     set_end_el(lptr->last);
502 
503   if (lptr == get_start_el())
504     set_start_el(lptr->next);
505  
506   lptr = dd_list_rm_el(lptr, lptr, im_free);
507 
508   if (lptr == NULL)
509     set_current_el(get_end_el());
510 
511   else   
512     { 
513       set_current_el(lptr);
514       label_sort_dec(lptr);
515     }
516  
517   if ((lptr = get_current_el()) != NULL)
518     seq_image_set(lptr->to);
519   else
520     seq_image_set(NULL);
521 
522   tv_free_background(tv_ptr);
523   tv_repaint(tv_ptr);
524   seq_show_bits(data);
525  
526   return;        
527 }
528 
529 static void       insert_seq_frame(Sequence *data)
530 {
531   Imrect  *im = NULL;
532   Tv      *tv_ptr = seq_tv_get();
533   int      image_data = IMAGE_DATA;
534 
535 
536   if (tv_ptr == NULL)
537     return;
538 
539   if ((im = (Imrect *)pop_data(im, image_data)) == NULL)
540     return;
541   frame_insert(im, data);
542   tv_free_background(tv_ptr);
543   tv_repaint(tv_ptr);
544   seq_show_bits(data);
545   data->seq_end++;
546   tw_iglobal_reset(pend);
547 
548   return;
549 
550 }
551 
552 static void      push_seq_frame(Sequence *data)
553 {
554   if (data->goto_frame < data->seq_start || data->goto_frame > data->seq_end)
555     {
556       error("unable to push from here ", warning);
557       return;
558     }
559 
560   push_data(seq_image_get());
561   
562   return;
563 }
564 
565 
566 void      replace_seq_frame(Sequence *data)
567 {
568   Imrect *im = NULL;
569   Imrect *im1 = NULL;
570   List *lptr = get_current_el();
571   Tv     *tv_ptr = seq_tv_get();
572   int     image_data;
573 
574   image_data = IMAGE_DATA;
575 
576   if (tv_ptr == NULL)
577     return;
578 
579   if((lptr == NULL) || (lptr->to == NULL))
580     {
581       error("unable to replace here ", warning);
582       return;
583     }
584 
585   if (data->goto_frame < data->seq_start || data->goto_frame > data->seq_end)
586     {
587       error("unable to replace here ", warning);
588       return;
589     }
590 
591 
592   if ((im = (Imrect *)pop_data(im, image_data)) == NULL)
593     return;
594 
595   im1 = seq_image_get();
596   set_frame_no(im, get_frame_no(im1));
597   lptr->to = im;
598   im_free(im1);
599   seq_image_set(im);
600   tv_free_background(tv_ptr);
601   tv_repaint(tv_ptr);
602   seq_show_bits(data);
603  
604   return;
605 }
606 
607 
608 void stack_seq(Vec3 *iscale)
609 {
610         void ***coreg_slice_init(Vec3 *ptr);
611         void coreg_coords_init();
612         List *get_start_el(), *dd_el = NULL, *lptr=NULL, *mptr=NULL;
613         List *el=NULL;
614         Sequence *get_seq_ptr();
615         Sequence *seq = get_seq_ptr();
616         Imrect *im;
617         int type, no_images=0, i;
618         Tv *seq_tv = seq_tv_get();
619         List *get_stack_ptr();
620         
621         /* Delete the current sequence and move the stack into the sequence instead PAB 25/10/01 */
622         /* This probably needs to be split into subroutines: I put it all here for simplicity */
623 
624         seq_free_proc();
625         dd_el=get_start_el();
626         el = get_stack_ptr();
627         seq->seq_start=0;
628         seq->seq_end=0;
629         
630         for(el=get_stack_ptr(); el!=NULL; el=el->next) no_images++;
631         
632         if(no_images==0)
633                 return;
634 
635         for(i=no_images; i>0; i--)
636         {
637                 im = (Imrect *)stack_pop(&type);
638                 set_frame_no(im, i);
639                 dd_el = dd_ref_addtostart(dd_el, im, SEQ);
640                 seq->seq_end++;
641         }
642 
643         tw_iglobal_reset(pstart);
644         tw_iglobal_reset(pframe);
645         tw_iglobal_reset(pend);
646 
647         set_start_el(dd_el);
648         set_current_el(dd_el);
649         seq_image_set((Imrect *)dd_el->to);
650 
651         for(lptr=dd_el; lptr!=NULL; lptr=lptr->next) mptr=lptr;
652         set_end_el(mptr);
653 
654         if(iscale!=NULL)
655         {
656                 iscalx = iscale->el[0];
657                 iscaly = iscale->el[1];
658                 iscalz = iscale->el[2];
659         }
660         else
661         {
662                 if(prop_get(im->props, VOXELS)!=NULL)
663                 {
664                         iscale = (Vec3 *)prop_get(im->props, VOXELS);
665                         iscalx = iscale->el[0];
666                         iscaly = iscale->el[1];
667                         iscalz = iscale->el[2];
668                 }
669         }
670 
671         coreg_slice_init(NULL);
672         coreg_coords_init();
673         
674         if(seq_tv!=NULL)
675         {
676                 tv_erase(seq_tv);
677                 tv_free_background(seq_tv);
678                 tv_init(seq_tv);
679         }
680         tv_init(imcalc_tv_get());
681         tv_init(imcal2_tv_get());
682 }
683 
684 
685 static void stack_seq_proc()
686 {
687         stack_seq(NULL);
688 }
689 
690 
691 static void coreg_tool_proc()
692 {
693    void         coreg_tool(int x, int y);
694    coreg_tool(100, 100);
695 }
696 
697 static void scan_proc(void)
698 {
699    char temp[MAXPATHLEN] = "";
700 
701    scan_files(seq->filename,temp);
702    tw_sglobal_reset(pfile);
703 }
704 
705 void         seq_tool(int x, int y)
706 {
707   static int   tool = 0;
708 
709   if (tool)
710     {
711       tw_show_tool(tool);
712       return;
713     }
714 
715   if ((seq = init_seq(seq)) == NULL)
716     return;
717 
718   set_seq_ptr(seq);
719 
720   tool = tw_tool("Sequence Tool", x, y);
721 
722   tw_choice("Tv : ", tv_choice_proc, 0, "sequence",
723             NULL);
724   tw_button("append", init_macro_proc,NULL);
725   tw_button("close", save_macro_proc,NULL);
726   tw_button("run", process_macro_proc, NULL);
727   tw_button("loop", process_seq_proc, seq);
728   tw_label("    ");
729   tw_help_button("sequence_tool");
730   tw_newrow();
731   tw_sglobal("Macro File:", get_macro_file(), 40);
732   tw_newrow();
733 /*
734   tw_check("Disp : ", seq_check_proc, 1,
735            "image", "edges",  NULL);
736   tw_newrow();
737 */
738   tw_choice("File:    ", file_choice_proc, 0,
739             "AIFF", "ANLZ", "RAD", "NEMA", "MIPL", "AVS", "DICOM", NULL);
740   tw_button("scan", scan_proc, NULL);
741   tw_newrow();
742   pfile = (void *)tw_sglobal("Image File:", seq->filename, 40);
743 
744   tw_newrow();
745   pstart = (void *)tw_iglobal("Start :", &(seq->seq_start), 3);
746   pframe = (void *)tw_iglobal(" Offset:", &(seq->goto_frame), 3);
747   pend = (void *)tw_iglobal("  End :", &(seq->seq_end), 3);
748   tw_newrow();
749 
750   tw_button("Input", get_image_seq_proc, seq);
751   tw_button("Output", save_image_seq_proc, seq);
752   tw_button("Del All", seq_free_proc, seq);
753   tw_button("Del", delete_seq_frame, seq);
754   tw_button("Ins", insert_seq_frame, seq);
755   tw_button("Rep", replace_seq_frame, seq);
756   tw_button("Push", push_seq_frame, seq);
757   tw_newrow();
758         
759 /*  tw_sglobal("Data File:", seq->datafile, 40);
760   tw_newrow();
761 */
762   
763 
764   tw_button("First", show_first_proc, seq);
765   tw_button("<", show_last_proc, seq);
766   tw_button(">", show_next_proc, seq);
767   tw_button("Last", show_end_proc, seq);
768   tw_button("Jumpto", goto_frame_proc, seq);
769   tw_button("Stack->Seq", stack_seq_proc, NULL);
770   tw_newrow();
771   as1 = (void *) tw_fglobal("Scale x:", &iscalx, 8);
772   as2 = (void *) tw_fglobal("y", &iscaly, 8);
773   as3 = (void *) tw_fglobal("z", &iscalz, 8);
774   at = (void *) tw_fglobal("t", &iscalt, 8);
775   tw_button("update", param_update, NULL);
776 
777 
778   tw_end_tool();
779 }
780 
781 
782 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~

This page was automatically generated by the LXR engine.
Visit the LXR main site for more information.