← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/xmedcon/gutsy

« back to all changes in this revision

Viewing changes to source/m-dicm.c

  • Committer: Bazaar Package Importer
  • Author(s): Roland Marcus Rutschmann
  • Date: 2004-11-11 15:53:37 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20041111155337-tgza2ptocg0g3wsj
Tags: 0.9.8.1-1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/m-dicm.c
18
18
 *                - Mosaic support     - Roland Marcus Rutschmann          *
19
19
 *                                                                         *
20
20
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
21
 
/* $Id: m-dicm.c,v 1.151 2004/05/09 22:48:03 enlf Exp $
 
21
/* $Id: m-dicm.c,v 1.165 2004/10/31 23:16:07 enlf Exp $
22
22
 */
23
23
 
24
24
/*
71
71
#define ICOL 1
72
72
 
73
73
/* extra stuff for reading DICOM */
 
74
static void MdcDicomFixType(IMG_DATA *id, Uint32 nr, double wc, double ww
 
75
, double rs, double ri);
74
76
static char *MdcDicomContrast(IMG_DATA *id, Uint32 nr, double wc, double ww
75
77
, double rs, double ri);
76
78
static void MdcDicomInvert(IMG_DATA *id);
78
80
, IMAGE *image, Uint32 number);
79
81
static char *MdcHandleMosaic(FILEINFO *fi, MDC_DICOM_STUFF_T *dicom
80
82
, IMAGE *image);
 
83
static void MdcPrintDicomInfoDB(FILEINFO *fi);
81
84
 
82
85
/* extra stuff for writing DICOM */
83
86
static Uint32 MdcDicomMakeUID(FILEINFO *fi, Int8 uid, char str[]);
147
150
   return(MDC_FRMT_DICM);
148
151
}
149
152
 
 
153
static void MdcDicomFixType(IMG_DATA *id, Uint32 nr, double wc, double ww, double rs, double ri)
 
154
{
 
155
  Int16 newtype = id->type;
 
156
 
 
157
  /* rescale window center/width towards pixel values */
 
158
  wc = (wc - ri) / rs;
 
159
  ww = (ww / rs);
 
160
 
 
161
  /* auto correct bad unsigned types <=> negative contrast window */
 
162
  if ((wc - 0.5 - ((ww - 1.) / 2.)) < 0.) {
 
163
    switch (id->type) {
 
164
      case  BIT8_U: newtype =  BIT8_S;
 
165
          break;
 
166
      case BIT16_U: newtype = BIT16_S;
 
167
          break;
 
168
      case BIT32_U: newtype = BIT32_S;
 
169
          break;
 
170
      case BIT64_U: newtype = BIT64_S;
 
171
          break;
 
172
    }
 
173
  }
 
174
 
 
175
  /* give warning once */
 
176
  if ((newtype != id->type) && (nr == 0)) {
 
177
    MdcPrntWarn("DICM Fix wrong unsigned pixel type");
 
178
  }
 
179
 
 
180
  /* fix pixel type */
 
181
  id->type = newtype;
 
182
 
 
183
}
 
184
 
150
185
/* see also DICOM standards: PS 3.3 - 2001 Page 505 */
151
186
char *MdcDicomContrast(IMG_DATA *id, Uint32 nr, double wc, double ww, double rs, double ri) 
152
187
{
160
195
   wc = (wc - ri) / rs;
161
196
   ww = (ww / rs);
162
197
 
163
 
#if MDC_DICM_FIX_TYPE
164
 
   /* auto correct bad unsigned types <=> negative contrast window */
165
 
   if ((wc - (ww / 2.)) < 0.) {
166
 
     switch (id->type) {
167
 
       case  BIT8_U: type =  BIT8_S;
168
 
           break;
169
 
       case BIT16_U: type = BIT16_S;
170
 
           break;
171
 
       case BIT32_U: type = BIT32_S;
172
 
           break;
173
 
       case BIT64_U: type = BIT64_S;
174
 
           break;
175
 
       default     : type = id->type;
176
 
     }
177
 
   }
178
 
 
179
 
   /* give warning only once */
180
 
   if ((type != id->type) && (nr == 0)) {
181
 
     MdcPrntWarn("DICM Fix wrong unsigned pixel type");
182
 
   }
183
 
 
184
 
#endif
185
 
 
186
198
   /* prepare range values: [0 -> +max] */
187
199
   ymin = 0.; 
188
200
   ymax = 255.;
245
257
  IMG_DATA *id;
246
258
  Uint32 img=0, i, f, bytes, t;
247
259
  Uint8 *pdata = NULL;
248
 
  double rescale_slope=1., rescale_intercept=0.;
249
 
  double window_center=0., window_width=0.;
250
 
  float quantify_slope=1., quantify_intercept=0.;
 
260
  double rs, ri;
 
261
  double wc, ww;
251
262
  char *msg=NULL;
252
263
 
253
264
  /* handle window center/width */
254
265
  if (MDC_FORCE_CONTRAST == MDC_YES) {
255
266
    /* apply user specified values */
256
 
    window_center = (double)mdc_cw_center;
257
 
    window_width  = (double)mdc_cw_width;
 
267
    wc = (double)mdc_cw_center;
 
268
    ww = (double)mdc_cw_width;
258
269
  }else{
259
270
    /* apply file specified values */
260
 
    window_center = (double)dicom->cw_center;
261
 
    window_width  = (double)dicom->cw_width;
 
271
    wc = (double)dicom->cw_center;
 
272
    ww = (double)dicom->cw_width;
262
273
  }
263
274
 
264
275
  /* handle rescale slope and intercept */
265
276
  if (MDC_FORCE_RESCALE == MDC_YES) {
266
 
    /* overide with user specified values */
267
 
    dicom->si_slope     = mdc_si_slope;
268
 
    dicom->si_intercept = mdc_si_intercept;
269
 
  }
270
 
 
271
 
  if ((window_center != 0.) && (window_width != 0.0)) {
272
 
    /* slope/intercept used for contrast remap */
273
 
    if (MDC_DICOM_CONTRAST == MDC_YES) {
274
 
      rescale_slope     = dicom->si_slope;
275
 
      rescale_intercept = dicom->si_intercept;
276
 
    }else{
277
 
    /* slope/intercept unused */
278
 
      rescale_slope = 1.; rescale_intercept = 0.;
279
 
    }
 
277
    /* apply user specified values */
 
278
    rs = (double)mdc_si_slope;
 
279
    ri = (double)mdc_si_intercept;
280
280
  }else{
281
 
    /* slope/intercept used for quantitation */
282
 
    quantify_slope     = dicom->si_slope;
283
 
    quantify_intercept = dicom->si_intercept;
 
281
    /* apply file specified values */
 
282
    rs = (double)dicom->si_slope;
 
283
    ri = (double)dicom->si_intercept; 
284
284
  }
285
285
 
 
286
  /* prevent division by zero */
 
287
  if (rs == 0.) rs = 1.;
 
288
 
286
289
  for (img=0, i=0; i<number; i++) {
287
290
     pimg = &image[i];
288
291
     for (f=0; f<image[i].frames; f++) {
297
300
        id->bits   = MdcType2Bits(id->type);
298
301
 
299
302
        if (id->type != COLRGB) {
300
 
          id->quant_scale = quantify_slope;
301
 
          id->intercept   = quantify_intercept;
 
303
          id->quant_scale = (float)rs;
 
304
          id->intercept   = (float)ri;
302
305
        }
303
306
 
304
 
        strcpy(id->image_mod,MdcGetStrModality((signed)dicom->modality));
305
 
 
306
307
        bytes = id->width*id->height*MdcType2Bytes(id->type);
307
308
        id->buf = MdcGetImgBuffer(bytes);
308
309
        if (id->buf == NULL) return("DICM Couldn't allocate image buffer");
362
363
          }
363
364
        } 
364
365
 
365
 
        /* contrast remapping */
366
366
        if (id->type != COLRGB) {
367
 
          if ((MDC_DICOM_CONTRAST == MDC_YES) && (window_width != 0.0)) {
368
 
            msg = MdcDicomContrast(id,img,window_center
369
 
                                         ,window_width
370
 
                                         ,rescale_slope
371
 
                                         ,rescale_intercept);
 
367
 
 
368
#if MDC_DICM_FIX_TYPE
 
369
          /* fix pixel type */
 
370
          MdcDicomFixType(id,img,wc,ww,rs,ri);
 
371
#endif
 
372
          /* contrast remapping */
 
373
          if ((MDC_DICOM_CONTRAST == MDC_YES) && (ww != 0.0)) {
 
374
            msg = MdcDicomContrast(id,img,wc,ww,rs,ri);
372
375
            if (msg != NULL) {
373
376
              MdcPrntWarn(msg);
374
377
            }
523
526
  return(NULL);
524
527
}
525
528
 
 
529
static void MdcPrintDicomInfoDB(FILEINFO *fi)
 
530
{
 
531
  /* make string */
 
532
  sprintf(mdcbufr,"%s+%04d%02d%02d+%02d%02d%02d",fi->patient_name
 
533
                                                ,fi->study_date_year
 
534
                                                ,fi->study_date_month
 
535
                                                ,fi->study_date_day
 
536
                                                ,fi->study_time_hour
 
537
                                                ,fi->study_time_minute
 
538
                                                ,fi->study_time_second);
 
539
  /* print string */
 
540
  MdcPrntScrn("%s\n",mdcbufr);
 
541
 
 
542
}
526
543
 
527
544
const char *MdcReadDICM(FILEINFO *fi)
528
545
{
538
555
  /* init dicom struct */
539
556
  MdcDicomInitStuff(dicom);
540
557
 
 
558
  /* init  MOD structs */
 
559
  MdcGetStructMOD(fi);
 
560
 
541
561
  if (MDC_PROGRESS) MdcProgress(MDC_PROGRESS_BEGIN,0.,"Reading DICOM:");
542
562
 
543
563
  if (MDC_VERBOSE) MdcPrntMesg("DICM Reading <%s> ...",fi->ifname);
544
564
 
545
 
  if (MDC_ECHO_ALIAS == MDC_YES) {
 
565
  if ((MDC_ECHO_ALIAS == MDC_YES) || (MDC_INFO_DB == MDC_YES)) {
546
566
    /* get one struct to fill */
547
567
    MdcGetStructID(fi,1);
548
568
    /* retrieve info from file */
549
569
    mdc_dicom_getinfo(fi);
550
 
    /* echo alias and leave */
551
 
    MdcEchoAliasName(fi); return(NULL);
 
570
    /* echo alias */
 
571
    if (MDC_ECHO_ALIAS == MDC_YES) MdcEchoAliasName(fi);
 
572
    /* print db info */
 
573
    if (MDC_INFO_DB == MDC_YES) MdcPrintDicomInfoDB(fi);
 
574
    /* leave */
 
575
    return(NULL);
552
576
  }
553
577
 
554
578
  MdcMergePath(fi->ipath,fi->idir,fi->ifname);
555
579
 
556
580
  /* first pass: limit log level to errors */
557
 
  dicom_log_level = ERROR;
 
581
  if (MDC_BLOCK_MESSAGES == MDC_LEVEL_ALL) {
 
582
    dicom_log_level = EMERGENCY; 
 
583
  }else{
 
584
    dicom_log_level = ERROR;
 
585
  }
558
586
 
559
587
  /* reading file 1st time for info printout */
560
588
  if (MDC_INFO) {
567
595
  if (MDC_PROGRESS) MdcProgress(MDC_PROGRESS_INCR,0.1,NULL);
568
596
 
569
597
  /* second pass: allow warnings */
570
 
  dicom_log_level = NOTICE;
 
598
  if (MDC_BLOCK_MESSAGES == MDC_NO) dicom_log_level = NOTICE;
571
599
 
572
600
  /* reading file 2nd time for images */
573
601
  if (mdc_dicom_read(fi,&image,(Int32 *)&nrimages)) {
598
626
  }
599
627
 
600
628
  /* third pass: limit log level back to errors */
601
 
  dicom_log_level = ERROR;
 
629
  if (MDC_BLOCK_MESSAGES == MDC_NO) dicom_log_level = ERROR;
602
630
 
603
631
  /* reading file 3rd time for info retrieving (through Acr/Nema reader) */
604
632
  if (MDC_INFO) {
606
634
    MdcPrintLine('*',MDC_HALF_LENGTH);
607
635
    MdcPrntScrn("Pass #2: through Acr/Nema reader\n");
608
636
    MdcPrintLine('*',MDC_HALF_LENGTH);
609
 
  } 
 
637
  }
610
638
 
611
639
  MdcMergePath(fi->ipath,fi->idir,fi->ifname);
612
640
  mdc_dicom_getinfo(fi); 
731
759
 
732
760
  switch (uid) {
733
761
    case MDC_TYPE_UID_CREATOR:
734
 
        sprintf(str,"%s.0.0",MDC_STR_UID_CREATOR);
 
762
        sprintf(str,"%s",MDC_STR_UID_CREATOR);
735
763
        break;
736
764
    case MDC_TYPE_UID_SOP_INSTANCE:
737
765
        series = mdc_incrinstance;
830
858
        strcpy(mdcbufr,"1.2.840.10008.5.1.4.1.1.128"); len = strlen(mdcbufr);
831
859
        mdc_dicom_write_element(fi->ofp,0x0002,0x0002,len,(Uint8 *)mdcbufr);
832
860
        break;
833
 
    case M_NM:
834
 
        strcpy(mdcbufr,"1.2.840.10008.5.1.4.1.1.20"); len = strlen(mdcbufr);
835
 
        mdc_dicom_write_element(fi->ofp,0x0002,0x0002,len,(Uint8 *)mdcbufr);
836
 
        break;
837
861
    default  : /* default to NM modality */
838
862
        strcpy(mdcbufr,"1.2.840.10008.5.1.4.1.1.20"); len = strlen(mdcbufr);
839
863
        mdc_dicom_write_element(fi->ofp,0x0002,0x0002,len,(Uint8 *)mdcbufr);
965
989
 
966
990
char *MdcDicomWriteSetModality(FILEINFO *fi, MDC_DICOM_STUFF_T *dicom)
967
991
{
968
 
  IMG_DATA *id=&fi->image[0];
969
 
  int modality;
970
 
 
971
 
  modality = MdcGetIntModality(id->image_mod);
972
 
 
973
 
  switch (modality) {
974
 
    case M_PT: /* MARK: PT modality not yet enabled */
975
 
    case M_NM:
976
 
    default  : dicom->modality = M_NM; /* default to NM modality */
 
992
  /* currently only NM writing supported */
 
993
  switch (fi->modality) {
 
994
    case M_PT:
 
995
 
 
996
    default  : dicom->modality = M_NM;
977
997
  }
978
998
 
979
999
  return(NULL);
989
1009
  strcpy(mdcbufr,"DERIVED\\PRIMARY");
990
1010
  switch (dicom->modality) {
991
1011
    case M_PT: break;
992
 
    case M_NM:
993
1012
    default  : /* default to NM modality */
994
1013
        switch (fi->acquisition_type) {
995
1014
          case MDC_ACQUISITION_TOMO: 
1035
1054
        strcpy(mdcbufr,"1.2.840.10008.5.1.4.1.1.128"); len = strlen(mdcbufr);
1036
1055
        mdc_dicom_write_element(fi->ofp,0x0008,0x0016,len,(Uint8 *)mdcbufr);
1037
1056
        break;
1038
 
    case M_NM:
1039
 
        strcpy(mdcbufr,"1.2.840.10008.5.1.4.1.1.20"); len = strlen(mdcbufr);
1040
 
        mdc_dicom_write_element(fi->ofp,0x0008,0x0016,len,(Uint8 *)mdcbufr);
1041
 
        break; 
1042
1057
    default  : /* default to NM modality */
1043
1058
        strcpy(mdcbufr,"1.2.840.10008.5.1.4.1.1.20"); len = strlen(mdcbufr);
1044
1059
        mdc_dicom_write_element(fi->ofp,0x0008,0x0016,len,(Uint8 *)mdcbufr);
1048
1063
  mdc_dicom_write_element(fi->ofp,0x0008,0x0018,len,(Uint8 *)mdcbufr);
1049
1064
 
1050
1065
  /* date settings, make sure it is conform */
1051
 
  if (fi->study_date_year == 0) {
1052
 
    pdata = NULL; bytes=0;
 
1066
  if (fi->mod != NULL) {
 
1067
    pdata = fi->mod->gn_info.study_date;       len = strlen(pdata);
 
1068
    mdc_dicom_write_element(fi->ofp,0x0008,0x0020,len,(Uint8 *)pdata);
 
1069
    pdata = fi->mod->gn_info.series_date;      len = strlen(pdata);
 
1070
    mdc_dicom_write_element(fi->ofp,0x0008,0x0021,len,(Uint8 *)pdata);
 
1071
    pdata = fi->mod->gn_info.acquisition_date; len = strlen(pdata);
 
1072
    mdc_dicom_write_element(fi->ofp,0x0008,0x0022,len,(Uint8 *)pdata);
 
1073
    pdata = fi->mod->gn_info.image_date;       len = strlen(pdata);
 
1074
    mdc_dicom_write_element(fi->ofp,0x0008,0x0023,len,(Uint8 *)pdata);
1053
1075
  }else{
1054
 
    sprintf(mdcbufr,"%04d%02d%02d",fi->study_date_year
1055
 
                                  ,fi->study_date_month
1056
 
                                  ,fi->study_date_day);
1057
 
    pdata = mdcbufr; bytes = strlen(mdcbufr);
 
1076
    if (fi->study_date_year == 0) {
 
1077
      pdata = NULL; bytes=0;
 
1078
    }else{
 
1079
      sprintf(mdcbufr,"%04d%02d%02d",fi->study_date_year
 
1080
                                    ,fi->study_date_month
 
1081
                                    ,fi->study_date_day);
 
1082
      pdata = mdcbufr; bytes = strlen(mdcbufr);
 
1083
    }
 
1084
    mdc_dicom_write_element(fi->ofp,0x0008,0x0020,bytes,(Uint8 *)pdata);
 
1085
    mdc_dicom_write_element(fi->ofp,0x0008,0x0021,bytes,(Uint8 *)pdata);
 
1086
    mdc_dicom_write_element(fi->ofp,0x0008,0x0022,bytes,(Uint8 *)pdata);
 
1087
    mdc_dicom_write_element(fi->ofp,0x0008,0x0023,bytes,(Uint8 *)pdata);
1058
1088
  }
1059
 
  mdc_dicom_write_element(fi->ofp,0x0008,0x0020,bytes,(Uint8 *)pdata);
1060
 
  mdc_dicom_write_element(fi->ofp,0x0008,0x0021,bytes,(Uint8 *)pdata);
1061
 
  mdc_dicom_write_element(fi->ofp,0x0008,0x0022,bytes,(Uint8 *)pdata);
1062
 
  mdc_dicom_write_element(fi->ofp,0x0008,0x0023,bytes,(Uint8 *)pdata);
1063
 
 
1064
1089
  /* time settings, can be full of zero's ... */ 
1065
 
  sprintf(mdcbufr,"%02d%02d%02d",fi->study_time_hour
1066
 
                                ,fi->study_time_minute
1067
 
                                ,fi->study_time_second);
1068
 
  len = strlen(mdcbufr);
1069
 
  mdc_dicom_write_element(fi->ofp,0x0008,0x0030,len,(Uint8 *)mdcbufr);
1070
 
  mdc_dicom_write_element(fi->ofp,0x0008,0x0031,len,(Uint8 *)mdcbufr);
1071
 
  if (fi->image[0].sdata != NULL) {
1072
 
    sprintf(mdcbufr,"%02d%02d%02d",fi->image[0].sdata->start_time_hour
1073
 
                                  ,fi->image[0].sdata->start_time_minute
1074
 
                                  ,fi->image[0].sdata->start_time_second);
1075
 
    len = strlen(mdcbufr);
1076
 
    mdc_dicom_write_element(fi->ofp,0x0008,0x0032,len,(Uint8 *)mdcbufr);
 
1090
  if (fi->mod != NULL) {
 
1091
    pdata = fi->mod->gn_info.study_time;       len = strlen(pdata);
 
1092
    mdc_dicom_write_element(fi->ofp,0x0008,0x0030,len,(Uint8 *)pdata);
 
1093
    pdata = fi->mod->gn_info.series_time;      len = strlen(pdata);
 
1094
    mdc_dicom_write_element(fi->ofp,0x0008,0x0031,len,(Uint8 *)pdata);
 
1095
    pdata = fi->mod->gn_info.acquisition_time; len = strlen(pdata);
 
1096
    mdc_dicom_write_element(fi->ofp,0x0008,0x0032,len,(Uint8 *)pdata);
 
1097
    pdata = fi->mod->gn_info.image_time;       len = strlen(pdata);
 
1098
    mdc_dicom_write_element(fi->ofp,0x0008,0x0033,len,(Uint8 *)pdata);
1077
1099
  }else{
1078
 
    mdc_dicom_write_element(fi->ofp,0x0008,0x0032,len,(Uint8 *)mdcbufr);
 
1100
    sprintf(mdcbufr,"%02d%02d%02d",fi->study_time_hour
 
1101
                                  ,fi->study_time_minute
 
1102
                                  ,fi->study_time_second);
 
1103
    len = strlen(mdcbufr);
 
1104
    mdc_dicom_write_element(fi->ofp,0x0008,0x0030,len,(Uint8 *)mdcbufr);
 
1105
    mdc_dicom_write_element(fi->ofp,0x0008,0x0031,len,(Uint8 *)mdcbufr);
 
1106
    if (fi->image[0].sdata != NULL) {
 
1107
      sprintf(mdcbufr,"%02d%02d%02d",fi->image[0].sdata->start_time_hour
 
1108
                                    ,fi->image[0].sdata->start_time_minute
 
1109
                                    ,fi->image[0].sdata->start_time_second);
 
1110
      len = strlen(mdcbufr);
 
1111
      mdc_dicom_write_element(fi->ofp,0x0008,0x0032,len,(Uint8 *)mdcbufr);
 
1112
    }else{
 
1113
      mdc_dicom_write_element(fi->ofp,0x0008,0x0032,len,(Uint8 *)mdcbufr);
 
1114
    }
 
1115
    sprintf(mdcbufr,"%02d%02d%02d",fi->study_time_hour
 
1116
                                  ,fi->study_time_minute
 
1117
                                  ,fi->study_time_second);
 
1118
    len = strlen(mdcbufr);
 
1119
    mdc_dicom_write_element(fi->ofp,0x0008,0x0033,len,(Uint8 *)mdcbufr);
1079
1120
  }
1080
 
  sprintf(mdcbufr,"%02d%02d%02d",fi->study_time_hour
1081
 
                                ,fi->study_time_minute
1082
 
                                ,fi->study_time_second);
1083
 
  len = strlen(mdcbufr);
1084
 
  mdc_dicom_write_element(fi->ofp,0x0008,0x0033,len,(Uint8 *)mdcbufr);
1085
1121
 
1086
1122
  len = strlen(mdc_dummy1);
1087
1123
  mdc_dicom_write_element(fi->ofp,0x0008,0x0050,len,(Uint8 *)mdc_dummy1);
1199
1235
 
1200
1236
  switch (dicom->modality) {
1201
1237
    case M_PT: break;
1202
 
    case M_NM:
1203
1238
    default  : /* default to NM modality */
1204
1239
        if ((fi->acquisition_type == MDC_ACQUISITION_UNKNOWN) ||
1205
1240
            (fi->acquisition_type == MDC_ACQUISITION_STATIC)) {
1309
1344
        mdc_dicom_write_element(fi->ofp,0x0028,0x0009,bytes,(Uint8 *)pui16);
1310
1345
        MdcFree(pui16);
1311
1346
        break;
1312
 
    case M_NM:
1313
1347
    default  : /* default to NM modality */
1314
1348
        switch (fi->acquisition_type) {
1315
1349
          case MDC_ACQUISITION_TOMO:
1529
1563
     mdc_dicom_write_element(fi->ofp,0x0018,0x0031,len,(Uint8 *)mdcbufr);
1530
1564
     strcpy(mdcbufr,"0.0"); len = strlen(mdcbufr);
1531
1565
     mdc_dicom_write_element(fi->ofp,0x0018,0x1071,len,(Uint8 *)mdcbufr);
1532
 
     /* strcpy(mdcbufr,"000000"); len = strlen(mdcbufr); start time
1533
 
     mdc_dicom_write_element(fi->ofp,0x0018,0x1072,len,(Uint8 *)mdcbufr); */
 
1566
     sprintf(mdcbufr,"%02d%02d%02d",fi->dose_time_hour
 
1567
                                   ,fi->dose_time_minute
 
1568
                                   ,fi->dose_time_second);
 
1569
     len = strlen(mdcbufr);
 
1570
     mdc_dicom_write_element(fi->ofp,0x0018,0x1072,len,(Uint8 *)mdcbufr);
1534
1571
     sprintf(mdcbufr,"%g",fi->injected_dose); len = strlen(mdcbufr);
1535
1572
     mdc_dicom_write_element(fi->ofp,0x0018,0x1074,len,(Uint8 *)mdcbufr);
1536
1573
     sprintf(mdcbufr,"%g",fi->isotope_halflife); len = strlen(mdcbufr);
2180
2217
  /* init dicom struct */
2181
2218
  MdcDicomInitStuff(dicom);
2182
2219
 
 
2220
  /* set modality to write */
 
2221
  MdcDicomWriteSetModality(fi,dicom);
 
2222
 
2183
2223
  /* check for requested pixel type */
2184
2224
  if (MDC_FORCE_INT != MDC_NO) dicom->type = MDC_FORCE_INT;
2185
2225
 
2190
2230
  }
2191
2231
 
2192
2232
  /* NM dynamic inappropriate for non-planar */
2193
 
  if (fi->acquisition_type == MDC_ACQUISITION_DYNAMIC && fi->planar == MDC_NO) {
 
2233
  if (dicom->modality == M_NM &&
 
2234
      fi->planar == MDC_NO    &&
 
2235
      fi->acquisition_type == MDC_ACQUISITION_DYNAMIC) {
2194
2236
    MdcPrntWarn("DICM Inappropriate for non-planar dynamic studies (NM)");
2195
2237
  }
2196
2238
 
2197
 
  /* MARK: set the modality to write */
2198
 
  MdcDicomWriteSetModality(fi,dicom);
2199
 
 
2200
2239
  if (MDC_DICOM_WRITE_NOMETA == MDC_NO) {
2201
2240
    msg = MdcDicomWriteMetaHeader(fi,dicom);
2202
2241
    if (msg != NULL) return(msg);
2214
2253
 
2215
2254
  switch (dicom->modality) {
2216
2255
    case M_PT:
2217
 
    case M_NM:
2218
2256
    default  : /* default to NM modality */
2219
2257
        msg = MdcDicomWriteG0054(fi,dicom); if (msg != NULL) return(msg);
2220
2258
  }