dcm.c File Reference

IO functions for DICOM files. More...

#include "libtpcimgio.h"

Go to the source code of this file.

Functions
int	dcmVerifyMagic (const char *filename, FILE *fp)
unsigned char	dcmVRReserved (dcmvr id)
dcmvr	dcmVRId (const char *s)
char *	dcmVRName (dcmvr id)
size_t	dcmVRVLength (dcmvr id)
char *	dcmVRDescr (dcmvr id)
char *	dcmDA2intl (const char *orig, char *intl)
char *	dcmTM2intl (const char *orig, char *intl)
char *	dcmDT2intl (const char *orig, char *intl)
unsigned int	dcmSOPIdentify (const char *s)
char *	dcmSOPName (unsigned int i)
char *	dcmSOPUID (unsigned int i)
char *	dcmSOPUIDName (const char *s)
dcmtruid	dcmTrUID (const char *s)
char *	dcmTrUIDDescr (dcmtruid id)
char *	dcmTrUIDString (dcmtruid id)
dcmtruid	dcmReadTransferSyntaxUID (FILE *fp)
int	dcmReadFileTag (FILE *fp, DCMTAG *tag)
int	dcmWriteFileTag (FILE *fp, DCMTAG *tag)
int	dcmWriteFileSQDelimItem (FILE *fp)
int	dcmWriteFileSQItemDelimTag (FILE *fp)
dcmvr	dcmReadFileVR (FILE *fp, char *vrstr)
unsigned int	dcmReadFileVL (FILE *fp, unsigned int n)
int	dcmReadFileVRVL (FILE *fp, dcmvr *vr, unsigned int *vl, unsigned int *n)
int	dcmWriteFileVRVL (FILE *fp, dcmvr vr, unsigned int vl, unsigned int *n)
void	dcmfileInit (DCMFILE *d)
void	dcmitemFree (DCMITEM *d)
void	dcmfileFree (DCMFILE *d)
unsigned short int	dcmitemMaxDepth (DCMITEM *d)
unsigned short int	dcmfileMaxDepth (DCMFILE *df)
unsigned short int	dcmitemParentNr (DCMITEM *d)
char *	dcmValueString (DCMITEM *d)
long int	dcmitemGetInt (DCMITEM *d)
double	dcmitemGetReal (DCMITEM *d)
DCMITEM *	dcmFindTag (DCMITEM *d, const short int omit, DCMTAG *tag, const int verbose)
void	dcmitemPrint (DCMITEM *d)
void	dcmTagSet (DCMTAG *tag, unsigned short int group, unsigned short int element)
int	dcmAddItem (DCMFILE *dcm, DCMITEM *d, short int aschild, DCMTAG tag, dcmvr vr, unsigned int vl, char *rd, const int verbose)
int	dcmFileReadNextElement (DCMFILE *dcm, DCMITEM *prev_item, DCMITEM *parent_item, const short int sub, const short int headerOnly, int verbose)
int	dcmFileRead (const char *filename, DCMFILE *dcm, const short int headerOnly, int verbose)
int	dcmFileWrite (const char *filename, DCMFILE *dcm, int verbose)

Detailed Description

IO functions for DICOM files.

Definition in file dcm.c.

Function Documentation

dcmAddItem()

int dcmAddItem	(	DCMFILE *	dcm,
		DCMITEM *	d,
		short int	aschild,
		DCMTAG	tag,
		dcmvr	vr,
		unsigned int	vl,
		char *	rd,
		const int	verbose )

Add an item to DCMFILE data struct.

See also

dcmfileInit, dcmfileFree

Returns

0 if successful, otherwise >0.

Parameters

dcm	Pointer to DCMFILE.
d	Pointer to a previous item in DCMFILE, into which to link this item; enter NULL to add as next item to the highest level.
aschild	Add as child; 1=yes, 0=no.
tag	Tag
vr	VR
vl	VL; enter 0xFFFFFFFF to use VR's default length.
rd	Pointer to the item value as byte array
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 1239 of file dcm.c.

  {
  if(verbose>0) {
    printf("%s(dcm, (%04X,%04X))", __func__, tag.group, tag.element);
    if(d==NULL) printf(", null"); else printf(", ptr");
    printf(", %d, %s, 0x%08X, rd", aschild, dcmVRName(vr), vl);
    printf(")\n");
  }
  if(dcm==NULL) return(1);
  if(vr==DCM_VR_INVALID) return(2);
 
  /* Check that caller has not given previous item pointer when there are none in DCMFILE */
  if(d!=NULL && dcm->item==NULL) return(3);
  /* Check that caller has not given previous item pointer that already has child */
  if(d!=NULL && aschild && d->child_item!=NULL) return(4);
 
  /* Check whether we currently support the Transfer UID */
  if(dcm->truid!=DCM_TRUID_LEE) return(5);
 
  /* Allocate memory for the new element; do not free it here, since it will be part of
     DCMFILE struct. */
  if(verbose>1) printf("  allocating memory for the item\n");
  DCMITEM *item=(DCMITEM*)malloc(sizeof(DCMITEM));
  if(item==NULL) return(11);
  item->next_item=item->child_item=(DCMITEM*)NULL;
  item->fp=dcm->fp; item->truid=dcm->truid;
  item->rd=(char*)NULL;
 
  /* Set item tag, VR, and VL */
  if(verbose>1) printf("  setting item contents\n");
  item->tag.group=tag.group;
  item->tag.element=tag.element;
  item->vr=vr;
  item->vl=vl;
  /* Allocate memory for item value */
  size_t s;
  if(vl==0xFFFFFFFF) s=dcmVRVLength(vr); else s=vl;
  if(s>0) {
    if(item->vl==0xFFFFFFFF) item->vl=(unsigned int)s;
    if(verbose>1) printf("  allocating %u bytes for the item value\n", (unsigned int)s);
    item->rd=(char*)calloc(s, sizeof(char));
    if(item->rd==NULL) {free(item); return(21);}
  } else {
    if(verbose>1) printf("zero size for item value\n");
    if(rd==NULL) {
      if(verbose>1) printf("... which is ok since value is empty, too.\n");
    } else {
      if(verbose>0) printf("... which is not ok because we have value to store.\n");
      if(item->rd==NULL) {free(item); return(22);}
    }
  }
  /* Copy the item value */
  if(rd!=NULL && s>0) {
    if(verbose>1) printf("  copying the item value\n");
    /* Special treatment for strings, because those tend to be shorter than told */
    if(vr==DCM_VR_LO || vr==DCM_VR_LT || vr==DCM_VR_PN || vr==DCM_VR_SH || vr==DCM_VR_UI || vr==DCM_VR_UR) 
    {
      unsigned int len=strnlen(rd, s);
      if(len<s) strlcpy(item->rd, rd, s);
      else memcpy(item->rd, rd, s);
    } else if(vr==DCM_VR_DS || vr==DCM_VR_IS) 
    {
      unsigned int len=strnlen(rd, s);
      if(len<s) strlcpy(item->rd, rd, s);
      else memcpy(item->rd, rd, s);
    } else {
      memcpy(item->rd, rd, s);
    }
  }
 
 
  /* If we have the item to link to, then do the linking */
  if(verbose>1) printf("  link the item.\n");
  if(d!=NULL) {
    if(aschild) {
      d->child_item=item;
      item->parent_item=d;
      item->prev_item=(DCMITEM*)NULL;
    } else if(d->next_item==NULL) {
      d->next_item=item;
      item->prev_item=d;
      item->parent_item=d->parent_item;
    } else {
      /* find the last item in the list */
      DCMITEM *ip=d; while(ip->next_item!=NULL) ip=ip->next_item;
      ip->next_item=item;
      item->prev_item=ip;
      item->parent_item=ip->parent_item;
    }
  } else if(dcm->item==NULL) {
    /* This is truly the first item ever */
    dcm->item=item;
    item->prev_item=item->parent_item=(DCMITEM*)NULL;
  } else {
    /* Caller lets us find the item to link to */
    DCMITEM *ip=dcm->item; while(ip->next_item!=NULL) ip=ip->next_item;
    ip->next_item=item;
    item->prev_item=ip;
    item->parent_item=ip->parent_item;
  }
 
  if(verbose>2) dcmitemPrint(item);
 
  if(verbose>1) printf("  all done.\n");
  return(0);
}

dcmDA2intl()

char * dcmDA2intl	(	const char *	orig,
		char *	intl )

Convert DICOM date 'DA' to international format YYYY-MM-DD.

Returns

Returns pointer to the date string, or NULL in case of an error.

Parameters

orig	Pointer to original DICOM string.
intl	Pointer to string where date in international format will be written; must be allocated for at least 11 characters.

Definition at line 299 of file dcm.c.

  {
  if(orig==NULL || intl==NULL) return(NULL);
  if(strnlen(orig, 10)<8) return(NULL);
  if(isdigit(orig[4])) { // modern format YYYYMMDD
    sprintf(intl, "%4.4s-%2.2s-%2.2s", orig, orig+4, orig+6);
  } else { // old format YYYY.MM.DD
    sprintf(intl, "%4.4s-%2.2s-%2.2s", orig, orig+5, orig+8);
  }
  if(isdate(intl)) {intl[0]=(char)0; return(NULL);}
  return(intl);
}

dcmDT2intl()

char * dcmDT2intl	(	const char *	orig,
		char *	intl )

Convert DICOM datetime 'DT' to international format YYYY-MM-DD hh:mm:ss.

Returns

Returns pointer to the time string, or NULL in case of an error.

Parameters

orig	Pointer to original DICOM string. Should be in format YYYYMMDDhhmmss.FFFFFF+hhmm
intl	Pointer to string where date and time in international format will be written; must be allocated for at least 20 characters.

Definition at line 345 of file dcm.c.

  {
  if(orig==NULL || intl==NULL) return(NULL);
  if(strnlen(orig, 26)<14) return(NULL);
  sprintf(intl, "%4.4s-%2.2s-%2.2s %2.2s:%2.2s:%2.2s",
          orig, orig+4, orig+6, orig+8, orig+10, orig+12);
  if(isdatetime(intl, NULL)) {intl[0]=(char)0; return(NULL);}
  return(intl);
}

dcmfileFree()

void dcmfileFree

(

DCMFILE *

d

)

Free memory allocated for DCMFILE data. All contents are destroyed.

Precondition

Before first use initialize the struct with dcmfileInit().

See also

dcmfileInit

Author

Vesa Oikonen

Parameters

d	Pointer to DCMFILE.

Definition at line 868 of file dcm.c.

  {
  if(d==NULL) return;
  dcmitemFree(d->item);
  dcmfileInit(d);
}

Referenced by dcmFileRead().

dcmfileInit()

void dcmfileInit

(

DCMFILE *

d

)

Initiate the DCMFILE struct before any use.

See also

dcmfileFree

Parameters

d	Pointer to DCMFILE.

Definition at line 823 of file dcm.c.

  {
  if(d==NULL) return;
  d->filename[0]=(char)0;
  d->fp=(FILE*)NULL;
  d->truid=DCM_TRUID_UNKNOWN;
  d->item=(DCMITEM*)NULL;
}

Referenced by dcmfileFree().

dcmfileMaxDepth()

unsigned short int dcmfileMaxDepth

(

DCMFILE *

df

)

Get the maximum depth of DCMFILE items tree.

Returns

Returns the number of item levels under specified DCMFILE, or zero in case of an error or if there are no items.

See also

dcmitemParentNr, dcmitemMaxDepth

Parameters

df	Pointer to DCMFILE item.

Definition at line 903 of file dcm.c.

  {
  if(df==NULL || df->item==NULL) return(0);
  unsigned short int m=0, n=0;
  DCMITEM *sd=df->item;
  while(sd!=NULL) { // go through all sisters
    n=dcmitemMaxDepth(sd); if(n>m) m=n;
    sd=sd->next_item;
  }
  return(m+1);
}

dcmFileRead()

int dcmFileRead	(	const char *	filename,
		DCMFILE *	dcm,
		const short int	headerOnly,
		int	verbose )

Read a single DICOM file.

See also

dcmVerifyMagic, dcmfileInit, dcmfileFree, dcmReadTransferSyntaxUID, dcmFileWrite

Returns

0 when successful.

Parameters

filename	Pointer to filename.
dcm	Pointer to initiated data structure.
headerOnly	Read only header (1), or read both header and pixel data (0).
verbose	Verbose level; if zero, then nothing is printed into stdout or stderr

Definition at line 1687 of file dcm.c.

  {
  if(filename==NULL || strnlen(filename, 10)<1 || dcm==NULL) return(1);
  if(verbose>1) printf("%s('%s', %d)\n", __func__, filename, headerOnly);
 
  /* Delete any previous data */
  dcmfileFree(dcm);
 
  /* Open the file */
  strlcpy(dcm->filename, filename, FILENAME_MAX);
  dcm->fp=fopen(dcm->filename, "rb");
  if(dcm->fp==NULL) {
    return(2);
  }
 
  /* Check the magic number and move file pointer to the end of it */
  if(verbose>2) printf("checking DICOM magic number\n");
  if(dcmVerifyMagic(NULL, dcm->fp)!=1) {
    fclose(dcm->fp);
    return(2);
  }
 
  /* Get the Transfer Syntax UID */
  if(verbose>2) printf("checking Transfer Syntax UID\n");
  dcm->truid=dcmReadTransferSyntaxUID(dcm->fp);
  if(dcm->truid==DCM_TRUID_INVALID) { // not found
    fclose(dcm->fp);
    return(2);
  }
  if(verbose>0) { // print the UID
    printf("Transfer Syntax UID := %s\n", dcmTrUIDDescr(dcm->truid));
    fflush(stdout);
  }
 
  /* Check whether we currently support the Transfer UID */
  if(dcm->truid!=DCM_TRUID_LEE) {
    fclose(dcm->fp);
    return(2);
  }
 
  /* Read DICOM file elements */
  int ret=0;
  do {
    // note that the next function may need to call itself,
    // therefore counting loops here would not be useful.
    ret=dcmFileReadNextElement(dcm, NULL, NULL, 0, headerOnly, verbose-10);
  } while(ret==0 && !feof(dcm->fp));
  fclose(dcm->fp);
  /* TPCERROR_NO_KEY means that no (more) tag was found;
     other codes still mean that something bad happened. */
  if(ret==-1) {
    if(verbose>1) printf(" eof\n");
    ret=0;
  }
  return(ret);
}

dcmFileReadNextElement()

int dcmFileReadNextElement	(	DCMFILE *	dcm,
		DCMITEM *	prev_item,
		DCMITEM *	parent_item,
		const short int	sub,
		const short int	headerOnly,
		int	verbose )

Read an element from DICOM file, and add it to the given linked list. This function will be called recursively in case of sequential items.

Returns

0 when successful, >0 in case of an error, -1 when no more elements could be read.

See also

dcmFileRead

Parameters

dcm	Pointer to DCMFILE struct; must be initiated before first call.
prev_item	Pointer to previous element; NULL if none exists (yet).
parent_item	Pointer to parent element; NULL if none exists (yet).
sub	Add as next element (0) or as child element.
headerOnly	Read only header (1), or read both header and pixel data (0).
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 1370 of file dcm.c.

  {
  if(verbose>0) printf("%s(DCMFILE*, DCMITEM*, DCMITEM*, %d, %d)\n", __func__, sub, headerOnly);
  if(dcm==NULL || dcm->fp==NULL) return(1);
  if(sub!=0 && parent_item==NULL) return(1);
  if(feof(dcm->fp)) return(-1);
 
  /* Check whether we currently support the Transfer UID */
  if(dcm->truid!=DCM_TRUID_LEE) return(2);
 
  if(verbose>10) {
    if(dcm->item==NULL) printf(" will add first element\n");
    else if(sub==0) printf(" will add next element\n");
    else printf(" will add subelement\n");
  }
 
  /* Is this a child to a sequence element? */
  int sq_child=0;
  if(parent_item!=NULL && parent_item->vr==DCM_VR_SQ) {sq_child=1;}
  if(verbose>10 && sq_child!=0) printf(" we're a child to a sequence element\n");
 
  /* Allocate memory for the new element */
  DCMITEM *item=(DCMITEM*)malloc(sizeof(DCMITEM));
  if(item==NULL) return(4);
  item->prev_item=prev_item;
  item->parent_item=parent_item;
  item->next_item=item->child_item=(DCMITEM*)NULL;
  item->fp=dcm->fp; item->truid=dcm->truid;
  item->rd=(char*)NULL;
 
  /* Save current file position (should be the start of element) */
  if(fgetpos(dcm->fp, &item->pos)) {
    free(item); return(2);
  }
 
  /* Read the tag (2x2 bytes) */
  if(verbose>10) {
    long int tagpos=ftell(dcm->fp);
    printf(" reading tag at %ld\n", tagpos);
  }
  if(dcmReadFileTag(dcm->fp, &item->tag)) {
    if(verbose>1 && !feof(dcm->fp)) printf(" error in reading the tag.\n");
    free(item);
    if(feof(dcm->fp)) return(-1);
    return(2);
  }
 
  if(verbose>2) {
    printf(" tag(%04x,%04x) with %u parents\n", 
           item->tag.group, item->tag.element, dcmitemParentNr(item));
  }
 
  /* If child, then check for item delimitation tag (although it should not be here) */
  if(dcmitemParentNr(item)>0 && item->tag.group==0xFFFE && item->tag.element==0xE00D) {
    if(verbose>10)
      printf(" item delimitation tag(%04x,%04x) found, reading VL\n", 
             item->tag.group, item->tag.element);
    unsigned long int vl=dcmReadFileVL(dcm->fp, 4); 
    if(verbose>1) printf(" item delimitation tag VL := %lu (0x%08lx)\n", vl, vl);
    if(vl!=0) {
      if(verbose>1) printf(" error: VL should have been 0\n");
      return(3);
    }
    return(0);
  }
 
 
  /* Read value representation and length (VR and VL, 2x2 or 2x4 bytes) */
  {
    if(verbose>10) printf(" reading VR and VL\n");
    int ret;
    unsigned int n;
    ret=dcmReadFileVRVL(dcm->fp, &item->vr, &item->vl, &n);
    if(ret!=0) {
      if(verbose>1) printf(" invalid VR or VL\n");
      free(item); return(ret);
    }
    if(verbose>1) {
      printf(" VR := %s (%s)\n", dcmVRName(item->vr), dcmVRDescr(item->vr));
      printf(" VL := %u (0x%08x) (%d bytes field)\n", item->vl, item->vl, n/2);
      fflush(stdout);
    }
  }
 
  /* Read value field, and add the current element to the list */
  if(item->vr==DCM_VR_SQ) {
    if(ftell(dcm->fp)<0) return(2);
    unsigned long int sqPos=(unsigned long int)ftell(dcm->fp);
    if(verbose>10) {printf(" sequence... at %ld\n", sqPos); fflush(stdout);}
    unsigned long int sqContentLength=item->vl;
    if(verbose>12) printf("    sequence contents length is %lu\n", sqContentLength);
    /* File position is now at the start of first item in the sequence */
    int ret;
    /* If parent has no previous child, then define this as its child */
    if(sq_child!=0 && parent_item->child_item==NULL) {
      parent_item->child_item=item;
    } else {
      /* else, add SQ sequence itself as next element to the list, and later
         add each sequence item as child to it */
      if(prev_item==NULL) {
        if(dcm->item==NULL) { // truly the first item
          dcm->item=item;
        } else { // search for the previous one
          DCMITEM *ip; ip=dcm->item;
          while(ip->next_item!=NULL) ip=ip->next_item;
          ip->next_item=item; item->prev_item=ip;
        }
      } else {
        prev_item->next_item=item; item->prev_item=prev_item;
      }
    }
    /* Read the first item tag and length, but there is no VR to read this time */
    if(verbose>10) {
      long int tagpos=ftell(dcm->fp);
      printf(" reading first item tag at %ld\n", tagpos);
    }
    DCMTAG itemtag;
    ret=dcmReadFileTag(dcm->fp, &itemtag);
    if(ret!=0) {
      if(verbose>1) printf(" error %d in reading the tag.\n", ret);
      return(2);
    }
    if(verbose>1) printf("  item tag(%04x,%04x)\n", itemtag.group, itemtag.element);
    /* It is common that sequence is empty; check it first */
    if(itemtag.group==0xFFFE && (itemtag.element==0xE0DD || itemtag.element==0xE00D)) {
      /* yes; then read also the 4 byte LV, which should be zero */
      if(verbose>10) 
        printf(" sequence delimitation item tag(%04x,%04x) found, reading VL\n",
          itemtag.group, itemtag.element);
      unsigned long int vl=dcmReadFileVL(dcm->fp, 4); 
      if(verbose>1) printf(" item tag VL := %lu (0x%08lx)\n", vl, vl);
      if(vl!=0) {
        if(verbose>1) printf(" error: VL should have been 0\n");
        return(2);
      }
      if(verbose>3) printf(" ending sequence before it really started.\n");
      return(0);
    }
    /* If sequence actually contains something, the Item tag must be 0xFFFE,0xE000 */
    if(itemtag.group!=0xFFFE || itemtag.element!=0xE000) {
      if(verbose>1) printf(" invalid sequence item tag(%04x,%04x)\n", itemtag.group, itemtag.element);
      return(2);
    }
    /* Read past the VL of this item (always 4 bytes) */
    unsigned long int itemvl=dcmReadFileVL(dcm->fp, 4);
    if(verbose>3) {printf(" item_VL := %lu (0x%08lx)\n", itemvl, itemvl);}
    if(ftell(dcm->fp)<0) return(2);
    unsigned long int sqItemPos=(unsigned long int)ftell(dcm->fp);
    /* Check if that is all of this sequence (probably Siemens) */
    if((sqItemPos-sqPos)>=sqContentLength) {
      if(verbose>3) printf(" ending sequence since it was found to be empty.\n");
      return(0);
    }
    if(verbose>12) printf("  sequence content start position at %ld\n", sqItemPos);
    /* Read the first item value as its own element, adding it as child to SQ */
    ret=dcmFileReadNextElement(dcm, NULL, item, 1, headerOnly, verbose-1);
    if(ret!=0) {
      if(verbose>1) printf(" error in reading the first item value dataset\n");
      return(ret);
    }
    /* Now we continue reading more items, until we reach Sequence Delimitation Item */
    while(!feof(dcm->fp)) {
      /* Do not read pass the length of the sequence data */
      if(ftell(dcm->fp)<0) return(2);
      unsigned long int cPos=(unsigned long int)ftell(dcm->fp);
      if(sqContentLength>0 && (cPos-sqPos)>=sqContentLength) {
        if(verbose>3) printf(" we reached the end of sequence VL %lu\n", sqContentLength);
        /* set fake sequence delimitation tag */
        itemtag.group=0xFFFE; itemtag.element=0xE0DD;
        break;
      }
      if(verbose>10) {
        long int tagpos=ftell(dcm->fp);
        printf(" reading next sequence item tag at %ld, %ld after start\n", tagpos, tagpos-sqItemPos);
      }
      if(dcmReadFileTag(dcm->fp, &itemtag)) return(2);
      if(verbose>1) printf(" next item tag(%04x,%04x)\n", itemtag.group, itemtag.element);
      itemvl=dcmReadFileVL(dcm->fp, 4); // delimitation tag has this too
      if(verbose>3) {printf(" item_VL := %lu (0x%08lx)\n", itemvl, itemvl);}
      /* Check if we got sequence delimitation tag */
      if(itemtag.group==0xFFFE && itemtag.element==0xE0DD) 
      {
        if(verbose>3) printf(" we got sequence delimitation tag\n");
        break;
      }
      /* Check if we got item delimitation tag from the previous item */
      if(itemtag.group==0xFFFE && itemtag.element==0xE00D) 
      {
        if(verbose>3) printf(" we got item delimitation tag\n");
        if(itemvl!=0) {
          if(verbose>1) printf(" error: VL should have been 0\n");
          return(3);
        }
        continue;
      }
      /* Otherwise this should be sequence item tag */
      if(itemtag.group!=0xFFFE || itemtag.element!=0xE000) {
        if(verbose>3) printf(" not sequence item tag, move file position back 2x4 bytes\n");
        fseek(dcm->fp, -8, SEEK_CUR);  //return(TPCERROR_INVALID_VALUE);
      }
      /* Read the item value as its own element, adding it to the SQ child list */
      DCMITEM *child=item->child_item;
      if(child==NULL) {
        if(verbose>1) printf(" error had happened in adding the child element\n");
        return(2);
      }
      while(child->next_item!=NULL) child=child->next_item;
      ret=dcmFileReadNextElement(dcm, child, item, 0, headerOnly, verbose-1);
      if(ret!=0) {
        if(verbose>1) printf(" error in reading item value dataset\n");
        return(ret);
      }
    }    
    /* Check that loop really stopped at sequence delimitation item */
    /* 0xE00D means the end of item, 0xE0DD the end of sequence. */ 
    if(itemtag.group!=0xFFFE || itemtag.element!=0xE0DD) {
      if(verbose>1)
        printf(" invalid sequence delimitation item tag(%04x,%04x)\n", itemtag.group, itemtag.element);
      return(2);
    }
    /* Done. Do not free item! */
    if(verbose>10) {printf(" end of sequence.\n"); fflush(stdout);}
  } else if(item->vl!=0xFFFFFFFF) {
    if(verbose>10) {printf(" reading value of %u bytes...\n", item->vl); fflush(stdout);}
    char *buf=NULL;
    if(item->vl>0) {
      buf=(char*)calloc(item->vl+1, sizeof(char));
      if(buf==NULL) {free(item); return(4);}
      if(fread(buf, 1, item->vl, item->fp)!=item->vl) {
        free(item); free(buf); return(3);
      }
      /* Do not store pixel data, if that was the request */
      if(headerOnly!=0 && 
         ((item->tag.group==0x7FE0 && item->tag.element>0) || item->tag.group==0x7FE1))
      {
        if(verbose>5) {printf(" ...not storing pixel data\n"); fflush(stdout);}
        free(buf); buf=(char*)NULL;
      } else {
        item->rd=buf;
      }
    } else if(verbose>4) {
      printf(" VL=0\n");
    }
    /* Add to list */
    if(sub==0) {
      if(prev_item==NULL) {
        if(dcm->item==NULL) { // truly the first item
          dcm->item=item;
        } else { // search for the previous one
          DCMITEM *ip; ip=dcm->item;
          while(ip->next_item!=NULL) ip=ip->next_item;
          ip->next_item=item; item->prev_item=ip;
        }
      } else {
        prev_item->next_item=item; item->prev_item=prev_item;
      }
    } else { // add as child
      parent_item->child_item=item; item->parent_item=parent_item;
    }
    /* Done. Do no free item or buf! */
    return(0);
 
  } else { // VL=0xFFFFFFFF
    size_t s=dcmVRVLength(item->vr);
    if(s==0) {
      if(verbose>0) printf(" Unknown VL!!\n");
      free(item);
      return(3); //return(TPCERROR_OK);
    }
    if(verbose>4) printf(" VR_based_VL=%u\n", (unsigned int)s);
    char *buf=(char*)calloc(s+1, sizeof(char));
    if(buf==NULL) {free(item); return(4);}
    if(fread(buf, 1, s, item->fp)!=s) {
      free(item); free(buf); return(3);
    }
    item->rd=buf;
    /* Add to list */
    if(sub==0) {
      if(prev_item==NULL) {
        if(dcm->item==NULL) { // truly the first item
          dcm->item=item;
        } else { // search for the previous one
          DCMITEM *ip; ip=dcm->item;
          while(ip->next_item!=NULL) ip=ip->next_item;
          ip->next_item=item; item->prev_item=ip;
        }
      } else {
        prev_item->next_item=item; item->prev_item=prev_item;
      }
    } else { // add as child
      parent_item->child_item=item; item->parent_item=parent_item;
    }
    /* Done. Do no free item or buf! */
    return(0);
  }
 
  return(0);
}

Referenced by dcmFileRead(), and dcmFileReadNextElement().

dcmFileWrite()

int dcmFileWrite	(	const char *	filename,
		DCMFILE *	dcm,
		int	verbose )

Write a single DICOM file.

See also

dcmFileRead, dcmfileInit, dcmfileFree

Returns

0 when successful.

Parameters

filename	Pointer to file name.
dcm	Pointer to DICOM data to be written.
verbose	Verbose level; if zero, then nothing is printed into stdout or stderr

Definition at line 1758 of file dcm.c.

  {
  if(filename==NULL || strnlen(filename, 10)<1 || dcm==NULL) return(1);
  if(verbose>1) {printf("%s('%s')\n", __func__, filename); fflush(stdout);}
 
  /* Check for the data */
  if(dcm->item==NULL) {
    return(2);
  }
 
  /* Check whether we currently support the Transfer UID */
  if(dcm->truid!=DCM_TRUID_LEE) { // Little endian explicit
    return(2);
  }
 
 
  /* Open the file */
  if(verbose>1) printf("opening the file for writing\n");
  FILE *fp;
  fp=fopen(filename, "wb");
  if(fp==NULL) return(3);
 
  /* Write preamble (just 128 zeroes) and magic number */
  {
    if(verbose>1) printf("writing preamble\n");
    char buf1[128], buf2[5]; 
    for(int i=0; i<128; i++) buf1[i]=(char)0;
    strcpy(buf2, "DICM");
    if(fwrite(buf1, 128, 1, fp)<1 || fwrite(buf2, 4, 1, fp)<1) {
      fclose(fp);
      return(3);
    }
  }
 
 
  /* Write the contents */
  if(verbose>1) printf("writing DICOM contents\n");
  int ret=0;
  DCMITEM *iptr;
  DCMITEM *d1=dcm->item;
  while(d1!=NULL) {
    if(verbose>2) {dcmitemPrint(d1);}
    /* Write */
    iptr=d1;
    {
      size_t n;
      /* Write tag */
      if(dcmWriteFileTag(fp, &iptr->tag)!=0) {ret=1; break;}
      /* Write VR and VL */
      if(dcmWriteFileVRVL(fp, iptr->vr, iptr->vl, NULL)!=0) {ret=2; break;}
      /* Write value, unless zero length, or SQ, in which case written later */
      if(iptr->vl>0 && iptr->vr!=DCM_VR_SQ) {
        size_t len;
        if(iptr->vl==0xFFFFFFFF) {
          len=dcmVRVLength(iptr->vr);
          if(verbose>30) printf("  value_len1 := %u\n", (unsigned int)len);
          n=fwrite(iptr->rd, dcmVRVLength(iptr->vr), 1, fp);
        } else {
          len=iptr->vl;
          if(verbose>30) printf("  value_len3 := %u\n", (unsigned int)len);
          n=fwrite(iptr->rd, iptr->vl, 1, fp);
        }
        if(verbose>30) printf("  value_len := %u\n", (unsigned int)len);
        if(n!=1) {ret=4; break;}
      } else if(iptr->vr==DCM_VR_SQ && d1->child_item==NULL) {
        if(verbose>1) printf("SQ, but no contents to write!\n");
        /* Write Sequence Delimitation Item */
        if(dcmWriteFileSQDelimItem(fp)!=0) {ret=6; break;}
      }
    }
 
    /* If this element (SQ) has children, then write those */
    /* Data Elements with a group of 0000, 0002 and 0006 shall not be present within Sequence Items,
       but that is not verified here */
    if(d1->child_item!=NULL) {
      DCMITEM *d2=d1->child_item;
      unsigned int d2counter=0;
      while(d2!=NULL) {
        if(verbose>2) {printf("  "); dcmitemPrint(d2);}
 
        /* Write */
        iptr=d2;
 
        /* First, write Item tag (FFFE,E000) */
        if(d2counter==0) {
          DCMTAG tag; tag.group=0xFFFE; tag.element=0xE000;
          if(dcmWriteFileTag(fp, &tag)!=0) {ret=11; break;}
        }
        /* Write item length; write 0xFFFFFFFF for now, correct later when known */
        fpos_t d2ilpos; // position for item length
        unsigned int d2il=0; // item length
        if(d2counter==0) {
          if(fgetpos(fp, &d2ilpos)) {ret=12; break;} // save position for writing later
          unsigned int ibuf;
          ibuf=0xFFFFFFFF;
          if(fwrite(&ibuf, 4, 1, fp)!=1) {ret=13; break;}
        }
        d2counter++;
 
        /* Write item value data set */
        {
          /* Write tag */
          if(dcmWriteFileTag(fp, &iptr->tag)!=0) {ret=14; break;}
          d2il+=4;
          /* Write VR and VL */
          unsigned int s;
          if(dcmWriteFileVRVL(fp, iptr->vr, iptr->vl, &s)!=0) {ret=15; break;}
          d2il+=s;
          /* Write value, unless zero length, or SQ, in which case written later */
          if(iptr->vl>0 && iptr->vr!=DCM_VR_SQ) {
            size_t len, n;
            if(iptr->vl==0xFFFFFFFF) {
              len=dcmVRVLength(iptr->vr);
              if(verbose>30) printf("  value_len1 := %u\n", (unsigned int)len);
              n=fwrite(iptr->rd, dcmVRVLength(iptr->vr), 1, fp);
              d2il+=len;
            } else {
              len=iptr->vl;
              if(verbose>30) printf("  value_len3 := %u\n", (unsigned int)len);
              n=fwrite(iptr->rd, iptr->vl, 1, fp);
              d2il+=iptr->vl;
            }
            if(verbose>30) printf("  value_len := %u\n", (unsigned int)len);
            if(n!=1) {ret=17; break;}
          } else if(iptr->vr==DCM_VR_SQ && iptr->child_item==NULL) {
            if(verbose>1) printf("SQ, but no contents to write!\n");
            /* Write Sequence Delimitation Item */
            if(dcmWriteFileSQDelimItem(fp)!=0) {ret=19; break;}
          }
        }
 
        /* If this element has children, then write those */
        if(d2->child_item!=NULL) {
          DCMITEM *d3=d2->child_item;
          unsigned int d3counter=0;
          while(d3!=NULL) {
            if(verbose>2) {printf("    "); dcmitemPrint(d3);}
 
            /* Write */
            iptr=d3;
            if(iptr->vr==DCM_VR_SQ) {d3=d3->next_item; continue;} // for now do not write SQs
 
            /* First, write Item tag (FFFE,E000) */
            if(d3counter==0) {
              DCMTAG tag; tag.group=0xFFFE; tag.element=0xE000;
              if(dcmWriteFileTag(fp, &tag)!=0) {ret=31; break;}
              d2il+=4;
            }
            /* Write item length; write 0xFFFFFFFF for now, correct later when known */
            fpos_t d3ilpos; // position for item length
            unsigned int d3il=0; // item length
            if(d3counter==0) {
              unsigned int ibuf;
              if(fgetpos(fp, &d3ilpos)) {ret=32; break;} // save position for writing later
              ibuf=0xFFFFFFFF;
              if(fwrite(&ibuf, 4, 1, fp)!=1) {ret=33; break;}
              d2il+=4;
            }
            d3counter++;
 
            /* Write item value data set */
            {
              /* Write tag */
              if(dcmWriteFileTag(fp, &iptr->tag)!=0) {ret=34; break;}
              d3il+=4; d2il+=4;
              /* Write VR and VL */
              unsigned int s;
              if(dcmWriteFileVRVL(fp, iptr->vr, iptr->vl, &s)!=0) {ret=35; break;}
              d3il+=s; d2il+=s;
              /* Write value, unless zero length, or SQ, in which case written later */
              if(iptr->vl>0 && iptr->vr!=DCM_VR_SQ) {
                size_t len, n;
                if(iptr->vl==0xFFFFFFFF) {
                  len=dcmVRVLength(iptr->vr);
                  if(verbose>30) printf("  value_len1 := %u\n", (unsigned int)len);
                  n=fwrite(iptr->rd, dcmVRVLength(iptr->vr), 1, fp);
                  d3il+=len; d2il+=len;
                } else {
                  len=iptr->vl;
                  if(verbose>30) printf("  value_len3 := %u\n", (unsigned int)len);
                  n=fwrite(iptr->rd, iptr->vl, 1, fp);
                  d3il+=iptr->vl; d2il+=iptr->vl;
                }
                if(verbose>30) printf("  value_len := %u\n", (unsigned int)len);
                if(n!=1) {ret=37; break;}
              } else if(iptr->vr==DCM_VR_SQ && iptr->child_item==NULL) {
                if(verbose>1) printf("SQ, but no contents to write!\n");
                /* Write Sequence Delimitation Item */
                if(dcmWriteFileSQDelimItem(fp)!=0) {ret=39; break;}
                d2il+=8;
              }
            }
 
            /* If this element has children, then write those */
            if(d3->child_item!=NULL) {
              //DCMITEM *d4=d3->child_item;
              if(verbose>0) fprintf(stderr, "Warning: 4th level items not written.\n");
            }
 
            /* now that we known the length, write it to the saved position */
            if(0) {
              fpos_t opos; // current position to return to
              if(fgetpos(fp, &opos)) {ret=40; break;}
              fsetpos(fp, &d3ilpos); // go to the position for item length
              char buf[4];
              memcpy(buf, &d3il, 4);
              if(!little_endian()) swabip(buf, 4);
              if(fwrite(&buf, 4, 1, fp)!=1) {ret=41; break;}
              fsetpos(fp, &opos); // back to the position where we were
            }
 
            d3=d3->next_item;
          }
          if(ret!=0) break;
 
          /* Write Item Delimitation Tag */
          if(dcmWriteFileSQItemDelimTag(fp)!=0) {ret=21; break;}
          /* End of the sequence - write Sequence Delimitation Item */
          if(dcmWriteFileSQDelimItem(fp)!=0) {ret=21; break;}
 
        }
 
 
        /* now that we known the length, write it to the saved position */
        if(0) {
          fpos_t opos; // current position to return to
          if(fgetpos(fp, &opos)) {ret=18; break;}
          fsetpos(fp, &d2ilpos); // go to the position for item length
          char buf[4];
          memcpy(buf, &d2il, 4);
          if(!little_endian()) swabip(buf, 4);
          if(fwrite(&buf, 4, 1, fp)!=1) {ret=19; break;}
          fsetpos(fp, &opos); // back to the position where we were
        }
 
        d2=d2->next_item;
      }
      if(ret!=0) break;
 
      /* Write Item Delimitation Tag */
      if(dcmWriteFileSQItemDelimTag(fp)!=0) {ret=21; break;}
      /* End of the sequence - write Sequence Delimitation Item */
      if(dcmWriteFileSQDelimItem(fp)!=0) {ret=21; break;}
 
    }
 
    d1=d1->next_item;
  } // next
  if(ret!=0) {
    if(verbose>0) fprintf(stderr, "  ret := %d\n", ret);
    fclose(fp);
    return(3);
  }
 
 
  fclose(fp);
 
  return(0);
}

dcmFindTag()

DCMITEM * dcmFindTag	(	DCMITEM *	d,
		const short int	omit,
		DCMTAG *	tag,
		const int	verbose )

Search for specified tag in DCMITEM data tree.

Returns

Returns pointer to next item with the tag, or NULL if not found.

Parameters

d	Pointer to current DICOM item.
omit	Omit this item from the search.
tag	Pointer to the DICOM tag that is searched for.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 1163 of file dcm.c.

  {
  if(d==NULL || tag==NULL) return(NULL);
  if(verbose>0) printf("%s(%04X,%04X)\n", __func__, tag->group, tag->element);
  DCMITEM *iptr;
  if(omit==0) iptr=d; else iptr=d->next_item;
  while(iptr!=NULL) {
    if(verbose>2)
      printf(" checking tag(%04X,%04X)...\n", iptr->tag.group, iptr->tag.element);
    if(iptr->tag.group==tag->group && iptr->tag.element==tag->element) {
      if(verbose>2) printf("  found!\n");
      break;
    }
    /* Check if this item has children */
    if(iptr->child_item!=NULL) {
      if(verbose>2) printf("  going to search inside children...\n");
      DCMITEM *rptr=dcmFindTag(iptr->child_item, 0, tag, verbose);
      if(rptr!=NULL) return(rptr);
      if(verbose>3) printf("  nothing found in any of the children\n");
    }
    iptr=iptr->next_item;
  }
  /* Stop if we found tag, or if we do not have parent */
  if(iptr!=NULL) return(iptr);
  if(d->parent_item==NULL) return(NULL);
 
  /* Search from the parent */
  if(verbose>2) printf("  going to search inside parent...\n");
  return(dcmFindTag(d->parent_item, 1, tag, verbose));
}

Referenced by dcmFindTag().

dcmitemFree()

void dcmitemFree

(

DCMITEM *

d

)

Recursively free memory allocated for DCMITEM items and their children items.

See also

dcmfileFree

Author

Vesa Oikonen

Parameters

d	Pointer to DCMITEM.

Definition at line 840 of file dcm.c.

  {
  if(d==NULL) return;
  /* find the last item in the list */
  DCMITEM *ip=d; while(ip->next_item!=NULL) ip=ip->next_item;
  while(ip!=NULL) {
    /* Free items child and their children */
    if(ip->child_item!=NULL) dcmitemFree(ip->child_item);
    /* Free this item and move to previous item */
    if(ip->prev_item!=NULL) {
      ip=ip->prev_item; 
      free(ip->next_item->rd); free(ip->next_item); 
      ip->next_item=NULL;
    } else {
      free(ip->rd); free(ip); ip=NULL;
    }
  }
}

Referenced by dcmfileFree(), and dcmitemFree().

dcmitemGetInt()

long int dcmitemGetInt

(

DCMITEM *

d

)

Read integer value from given DICOM item.

VR must be either UL, US, SL, SS, or IS; otherwise 0 is returned.

Returns

Returns the value as long int, in order to cope with originally unsigned integers.

See also

dcmitemGetInt, dcmValueString, dcmFindTag

Parameters

d	Pointer to item.

Definition at line 1084 of file dcm.c.

  {
  if(d==NULL || d->rd==NULL) return(0);
  long int li=0;
  if(d->vr==DCM_VR_UL) { // unsigned 32-bit int
    unsigned int i;
    memcpy(&i, d->rd, 4); if(!little_endian()) swap(&i, &i, 4);
    li=(long int)i;
  } else if(d->vr==DCM_VR_US) { // unsigned 16-bit int
    unsigned short int i;
    memcpy(&i, d->rd, 2); if(!little_endian()) swap(&i, &i, 2);
    li=(long int)i;
  } else if(d->vr==DCM_VR_SL) { // signed 32-bit int
    int i;
    memcpy(&i, d->rd, 4); if(!little_endian()) swap(&i, &i, 4);
    li=(long int)i;
  } else if(d->vr==DCM_VR_SS) { // signed 16-bit int
    short int i;
    memcpy(&i, d->rd, 2); if(!little_endian()) swap(&i, &i, 2);
    li=(long int)i;
  } else if(d->vr==DCM_VR_IS) { // integer string
    li=atol(d->rd);
  }
  return(li);
}

dcmitemGetReal()

double dcmitemGetReal

(

DCMITEM *

d

)

Read floating point value from given DICOM item.

VR must be either FL, FD, DS, UL, US, SL, SS, or IS; otherwise 0 is returned.

Returns

Returns the value as double.

See also

dcmitemGetInt, dcmValueString, dcmFindTag

Parameters

d	Pointer to item.

Definition at line 1120 of file dcm.c.

  {
  if(d==NULL || d->rd==NULL) return(0);
  double r=0.0;
  if(d->vr==DCM_VR_FL) { // 32-bit float
    float f;
    memcpy(&f, d->rd, 4); if(!little_endian()) swap(&f, &f, 4);
    r=(double)f;
  } else if(d->vr==DCM_VR_FD) { // 64-bit double
    double f;
    memcpy(&f, d->rd, 8); if(!little_endian()) swap(&f, &f, 8);
    r=f;
  } else if(d->vr==DCM_VR_DS) { // decimal string
    r=atof(d->rd);
  } else if(d->vr==DCM_VR_UL) { // unsigned 32-bit int
    unsigned int i;
    memcpy(&i, d->rd, 4); if(!little_endian()) swap(&i, &i, 4);
    r=(double)i;
  } else if(d->vr==DCM_VR_US) { // unsigned 16-bit int
    unsigned short int i;
    memcpy(&i, d->rd, 2); if(!little_endian()) swap(&i, &i, 2);
    r=(double)i;
  } else if(d->vr==DCM_VR_SL) { // signed 32-bit int
    int i;
    memcpy(&i, d->rd, 4); if(!little_endian()) swap(&i, &i, 4);
    r=(double)i;
  } else if(d->vr==DCM_VR_SS) { // signed 16-bit int
    short int i;
    memcpy(&i, d->rd, 2); if(!little_endian()) swap(&i, &i, 2);
    r=(double)i;
  } else if(d->vr==DCM_VR_IS) { // integer string
    r=(double)atol(d->rd);
  }
  return(r);
}

dcmitemMaxDepth()

unsigned short int dcmitemMaxDepth

(

DCMITEM *

d

)

Get the maximum depth of DCMITEM tree.

Returns

Returns the number of levels under specified item, not including given item itself.

See also

dcmitemParentNr, dcmfileMaxDepth

Parameters

d	Pointer to DCMITEM item.

Definition at line 884 of file dcm.c.

  {
  if(d==NULL || d->child_item==NULL) return(0);
  unsigned short int m=0, n=0;
  DCMITEM *cd=d->child_item;
  /* go through all children */
  while(cd!=NULL) {
    n=dcmitemMaxDepth(cd); if(n>m) m=n;
    cd=cd->next_item;
  }
  return(m+1);
}

Referenced by dcmfileMaxDepth(), and dcmitemMaxDepth().

dcmitemParentNr()

unsigned short int dcmitemParentNr

(

DCMITEM *

d

)

Check how deep in DCMITEM tree this item is.

Returns

Returns the number of parents this item has.

See also

dcmitemMaxDepth, dcmfileMaxDepth

Parameters

d	Pointer to DCMITEM.

Definition at line 923 of file dcm.c.

  {
  if(d==NULL) return(0);
  unsigned short int n=0;
  DCMITEM *pd=d->parent_item;
  while(pd!=NULL) {n++; pd=pd->parent_item;}
  return(n);
}

Referenced by dcmFileReadNextElement().

dcmitemPrint()

void dcmitemPrint

(

DCMITEM *

d

)

Print contents of given DICOM item into stdout.

Parameters

d	Pointer to item.

Definition at line 1205 of file dcm.c.

  {
  if(d==NULL) {printf("(null)\n"); fflush(stdout); return;}
  printf("tag(%04X,%04X)", d->tag.group, d->tag.element); fflush(stdout);
  printf(" VR=%s", dcmVRName(d->vr)); fflush(stdout);
  if(d->vl==0xFFFFFFFF) printf(" VL=%08X", d->vl); else printf(" VL=%u", d->vl);
  fflush(stdout);
  char *buf=dcmValueString(d); printf(" '%s'", buf); free(buf);
  printf("\n"); fflush(stdout);
}

Referenced by dcmAddItem(), and dcmFileWrite().

dcmReadFileTag()

int dcmReadFileTag	(	FILE *	fp,
		DCMTAG *	tag )

Read DICOM tag from current file position.

Note

Tag validity is not verified here; error may be caused by end-of-file. Alternatively, read may seem to be successful, but tag contents are file padding symbols (0xFFFC).

See also

dcmReadFile, dcmReadFileElement

Returns

Returns 0 when successful, otherwise >0.

Author

Vesa Oikonen

Parameters

fp	File pointer, positioned at the start of the element (and tag).
tag	Pointer to DICOM tag struct; enter NULL if you just need to move file position over the tag.

Definition at line 553 of file dcm.c.

  {
  if(tag!=NULL) {tag->group=tag->element=0xFFFC;} // padding
  if(fp==NULL || feof(fp)) return(1);
  unsigned short int buf[2];
  size_t n=fread(&buf, 2, 2, fp);
  if(n!=2) return(2+n);
  if(tag!=NULL) {
    tag->group=buf[0];
    tag->element=buf[1];
    if(!little_endian()) { // tag is by default little endian
      swap(&tag->group, &tag->group, 2);
      swap(&tag->element, &tag->element, 2);
    }
  }
  return(0);
}

Referenced by dcmFileReadNextElement(), and dcmReadTransferSyntaxUID().

dcmReadFileVL()

unsigned int dcmReadFileVL	(	FILE *	fp,
		unsigned int	n )

Read DICOM value length (2 or 4 bytes, depending on VR) from current file position.

See also

dcmReadFileTag, dcmReadFileVR, dcmReadFileElement

Returns

Returns the value length.

Author

Vesa Oikonen

Parameters

fp	File pointer, positioned at the VL start.
n	Number of bytes (2 or 4) in the VL representation.

Definition at line 692 of file dcm.c.

  {
  unsigned int vl=0;
  if(fp==NULL || (n!=2 && n!=4)) return(vl);
 
  /* Read 2 or 4 bytes */
  if(n==2) {
    unsigned short int si;
    if(fread(&si, 2, 1, fp)!=1) return(vl);
    if(!little_endian()) swap(&si, &si, 2);
    vl=si;
  } else if(n==4) {
    unsigned int li;
    if(fread(&li, 4, 1, fp)!=1) return(vl);
    if(!little_endian()) swap(&li, &li, 4);
    vl=li;
  }
  return(vl);
}

Referenced by dcmFileReadNextElement(), and dcmReadTransferSyntaxUID().

dcmReadFileVR()

dcmvr dcmReadFileVR	(	FILE *	fp,
		char *	vrstr )

Read DICOM value representation (2 or 4 bytes) from current file position.

See also

dcmReadFileTag, dcmReadFileElement

Returns

Returns the enumerated VR number, DCM_VR_INVALID in case of an error.

Author

Vesa Oikonen

Parameters

fp	File pointer, positioned at the VR start.
vrstr	Pointer for VR string, allocated for at least 3 characters to have space for the trailing null; enter NULL if not needed.

Definition at line 655 of file dcm.c.

  {
  if(vrstr!=NULL) vrstr[0]=(char)0;
  if(fp==NULL) return(DCM_VR_INVALID);
 
  /* Read the first two bytes */
  char buf[3];
  if(fread(&buf, 1, 2, fp)!=2) return(DCM_VR_INVALID);
  buf[2]=(char)0;
 
  /* Identify the VR */
  dcmvr lvr=dcmVRId(buf);
  if(vrstr!=NULL) {
    if(lvr!=DCM_VR_INVALID) strcpy(vrstr, dcmVRName(lvr));
    else strcpy(vrstr, buf);
  }
 
  /* If this VR has extra 2 byte reserved space, then
     we need to read but do not use the next 2 bytes. */
  if(dcmVRReserved(lvr)!=0) {
    if(fread(&buf, 1, 2, fp)!=2) return(DCM_VR_INVALID);
  }
  return(lvr);
}

Referenced by dcmReadTransferSyntaxUID().

dcmReadFileVRVL()

int dcmReadFileVRVL	(	FILE *	fp,
		dcmvr *	vr,
		unsigned int *	vl,
		unsigned int *	n )

Read DICOM Value Representation (VR, 2 or 4 bytes) and Value Length (VL, 2 or 4 bytes) from current file position.

See also

dcmReadFileVR, dcmReadFileVL, dcmReadFileTag, dcmReadFileElement, dcmWriteFileVRVL

Returns

0 when successful.

Author

Vesa Oikonen

Parameters

fp	File pointer, positioned at the VR start.
vr	Pointer for enumerated VR value; enter NULL if not needed (file pointer moved anyway).
vl	Pointer for VL; enter NULL if not needed (file pointer moved anyway).
n	Pointer for number of bytes read from file; enter NULL if not needed.

Definition at line 724 of file dcm.c.

  {
  if(vr!=NULL) *vr=DCM_VR_INVALID;
  if(vl!=NULL) *vl=0;
  if(n!=NULL) *n=0;
  if(fp==NULL) return(1);
 
  /* Read the first two bytes */
  char buf[3];
  if(fread(&buf, 1, 2, fp)!=2) return(2); else if(n!=NULL) *n+=2;
  buf[2]=(char)0;
 
  /* Identify the VR */
  dcmvr lvr=dcmVRId(buf);
  if(vr!=NULL) *vr=lvr;
  if(lvr==DCM_VR_INVALID) return(3);
 
  /* If this VR has extra 2 byte reserved space, then
     we need to read but do not use the next 2 bytes. */
  unsigned int bsize=2+dcmVRReserved(lvr);
  if(bsize==4) {
    if(fread(&buf, 1, 2, fp)!=2) return(2);
    if(n!=NULL) *n+=2;
  }
 
  /* Read VL from the next 2 or 4 bytes */
  unsigned int lvl=0;
  if(bsize==2) {
    unsigned short int si;
    if(fread(&si, 2, 1, fp)!=1) return(2);
    if(!little_endian()) swap(&si, &si, 2);
    lvl=si;
  } else {
    unsigned int li;
    if(fread(&li, 4, 1, fp)!=1) return(2);
    if(!little_endian()) swap(&li, &li, 4);
    lvl=li;
  }
  if(n!=NULL) *n+=bsize;
  if(vl!=NULL) *vl=lvl;
 
  return(0);
}

Referenced by dcmFileReadNextElement().

dcmReadTransferSyntaxUID()

dcmtruid dcmReadTransferSyntaxUID

(

FILE *

fp

)

Read and identify the DICOM Transfer Syntax UID.

Returns

Returns the enumerated UID, or DCM_TRUID_INVALID.

See also

dcmVerifyMagic

Parameters

fp	Pointer to DICOM file opened in binary format, and positioned right after the Magic number. Position will be returned to this position.

Definition at line 502 of file dcm.c.

  {
  if(fp==NULL || feof(fp)) return(DCM_TRUID_INVALID);
  /* Save original file position */
  fpos_t opos;
  if(fgetpos(fp, &opos)) return(DCM_TRUID_INVALID);
  /* Read file until we find DICOM tag 0x0002,0x0010 */
  DCMTAG tag;
  int tag_found=0;
  while(!tag_found && !feof(fp)) {
    if(dcmReadFileTag(fp, &tag)) break;
    if(tag.group==0x0002 && tag.element==0x0010) {tag_found=1; break;}
    /* not the tag that we want, so just go through this item */
    dcmvr vr=dcmReadFileVR(fp, NULL);
    unsigned int vl=0;
    if(dcmVRReserved(vr)==0) vl=dcmReadFileVL(fp, 2); 
    else vl=dcmReadFileVL(fp, 4); 
    if(vr==DCM_VR_SQ) break;
    if(vl==0xFFFFFFFF) break;
    char buf[vl+1];
    if(fread(buf, 1, vl, fp)!=vl) break;
  } // get next tag
  if(!tag_found) {fsetpos(fp, &opos); return(DCM_TRUID_INVALID);}
  /* Read the UID */
  if(dcmReadFileVR(fp, NULL)!=DCM_VR_UI) {
    fsetpos(fp, &opos); return(DCM_TRUID_INVALID);
  }
  unsigned int vl=dcmReadFileVL(fp, 2); 
  if(vl==0 || vl==0xFFFFFFFF) {fsetpos(fp, &opos); return(DCM_TRUID_INVALID);}
  char uid[vl+1];
  if(fread(uid, 1, vl, fp)!=vl) {fsetpos(fp, &opos); return(DCM_TRUID_INVALID);}
  /* Return file position to the original */
  fsetpos(fp, &opos);
  /* Identify the UID */
  return(dcmTrUID(uid));
}

Referenced by dcmFileRead().

dcmSOPIdentify()

unsigned int dcmSOPIdentify

(

const char *

s

)

Identify the DICOM SOP UID.

Returns

Returns the SOP UID list index.

See also

dcmSOPName, dcmSOPUID

Parameters

s	SOP UID string.

Definition at line 367 of file dcm.c.

  {
  if(s==NULL || strnlen(s, 3)<3) return(0);
 
  /* Identify the SOP UID */
  unsigned int i=0;
  while(strcmp(dcm_sop[i].uid, "unknown")!=0) {
    if(strcmp(dcm_sop[i].uid, s)==0) return(i);
    i++;
  }
  return(i);
}

dcmSOPName()

char * dcmSOPName

(

unsigned int

i

)

Get the DICOM SOP UID Name.

Returns

Returns pointer to the SOP Name string.

See also

dcmSOPIdentify, dcmSOPUID

Parameters

i	SOP UID list index.

Definition at line 388 of file dcm.c.

  {
  unsigned int j=0;
  while(strcmp(dcm_sop[j].uid, "unknown")!=0) {
    if(i==j) return(dcm_sop[j].name);
    j++;
  }
  return(dcm_sop[j].name);
}

dcmSOPUID()

char * dcmSOPUID

(

unsigned int

i

)

Get the DICOM SOP UID.

Returns

Returns pointer to the UID string.

See also

dcmSOPIdentify, dcmSOPName

Parameters

i	SOP UID list index.

Definition at line 406 of file dcm.c.

  {
  unsigned int j=0;
  while(strcmp(dcm_sop[j].uid, "unknown")!=0) {
    if(i==j) return(dcm_sop[j].uid);
    j++;
  }
  return(dcm_sop[j].uid);
}

dcmSOPUIDName()

char * dcmSOPUIDName

(

const char *

s

)

Get the name of DICOM SOP UID.

Returns

Returns pointer to the SOP UID name string.

See also

dcmSOPName, dcmSOPUID

Parameters

s	SOP UID string.

Definition at line 424 of file dcm.c.

  {
  if(s==NULL || strnlen(s, 3)<3) return(dcm_sop[0].name);
 
  /* Identify the SOP UID */
  unsigned int i=0;
  while(strcmp(dcm_sop[i].uid, "unknown")!=0) {
    if(strcmp(dcm_sop[i].uid, s)==0) return(dcm_sop[i].name);
    i++;
  }
  return(dcm_sop[i].name);
}

dcmTagSet()

void dcmTagSet	(	DCMTAG *	tag,
		unsigned short int	group,
		unsigned short int	element )

Set DICOM Tag group and element.

Parameters

tag	Pointer to Tag to set.
group	Tag Group
element	Tag Element

Definition at line 1221 of file dcm.c.

  {
  tag->group=group;
  tag->element=element;
}

dcmTM2intl()

char * dcmTM2intl	(	const char *	orig,
		char *	intl )

Convert DICOM time 'TM' to international format hh:mm:ss.

Returns

Returns pointer to the time string, or NULL in case of an error.

Parameters

orig	Pointer to original DICOM string.
intl	Pointer to string where time in international format will be written; must be allocated for at least 9 characters.

Definition at line 322 of file dcm.c.

  {
  if(orig==NULL || intl==NULL) return(NULL);
  if(strnlen(orig, 14)<6) return(NULL);
  if(isdigit(orig[2])) { // modern format hhmmss.fract
    sprintf(intl, "%2.2s:%2.2s:%2.2s", orig, orig+2, orig+4);
  } else { // old format hh.mm.ss
    sprintf(intl, "%2.2s:%2.2s:%2.2s", orig, orig+3, orig+6);
  }
  if(istime(intl)) {intl[0]=(char)0; return(NULL);}
  return(intl);
}

dcmTrUID()

dcmtruid dcmTrUID

(

const char *

s

)

Identify the DICOM Transfer Syntax UID.

Returns

Returns the enumerated id.

See also

dcmTrUIDDescr

Parameters

s	UID string.

Definition at line 445 of file dcm.c.

  {
  if(s==NULL || strnlen(s, 5)<5) return(DCM_TRUID_INVALID);
 
  /* Identify the UID */
  unsigned short int i=1;  // 1 because 0 is unknown
  while(dcm_truid[i].id!=DCM_TRUID_INVALID) {
    if(strcmp(dcm_truid[i].uid, s)==0) return(dcm_truid[i].id);
    i++;
  }
  return(DCM_TRUID_UNKNOWN);
}

Referenced by dcmReadTransferSyntaxUID().

dcmTrUIDDescr()

char * dcmTrUIDDescr

(

dcmtruid

id

)

Get the DICOM Transfer Syntax UID description.

Returns

Returns pointer to the description string.

See also

dcmTrUID

Parameters

id	Transfer Syntax UID id (DCM_TRUID_LEI, ...).

Definition at line 466 of file dcm.c.

  {
  unsigned short int i=0;
  while(dcm_truid[i].id!=DCM_TRUID_INVALID) {
    if(id==dcm_truid[i].id) return(dcm_truid[i].descr);
    i++;
  }
  return(dcm_truid[DCM_TRUID_INVALID].descr);
}

Referenced by dcmFileRead().

dcmTrUIDString()

char * dcmTrUIDString

(

dcmtruid

id

)

Get the DICOM Transfer Syntax UID string.

Returns

Returns pointer to the description string.

See also

dcmTrUID

Parameters

id	Transfer Syntax UID id (DCM_TRUID_LEI, ...).

Definition at line 484 of file dcm.c.

  {
  unsigned short int i=0;
  while(dcm_truid[i].id!=DCM_TRUID_INVALID) {
    if(id==dcm_truid[i].id) return(dcm_truid[i].uid);
    i++;
  }
  return(dcm_truid[DCM_TRUID_INVALID].uid);
}

dcmValueString()

char * dcmValueString

(

DCMITEM *

d

)

Pre-process the DICOM element value into format suitable for printing.

Note

Use only for printing information for the user.

Returns

Returns pointer to locally allocated null-terminated string.

Postcondition

Free the pointer after use.

See also

dcmitemGetInt, dcmitemGetReal, dcmFindTag

Attribute tag

Float

Double

Unsigned 32-bit int

Unsigned 16-bit int

Signed 32-bit int

Signed 16-bit int

Parameters

d	Pointer to item containing the value to print.

Definition at line 942 of file dcm.c.

  {
  if(d==NULL) return((char*)NULL);
 
  /* For sequence, return string 'na' */
  if(d->vr==DCM_VR_SQ) {
    char *s=malloc(3); strcpy(s, "na"); // do not write char *s="na";
    return(s);
  }
 
  /* If there is no value, then return string 'empty', or
     'na', if value just was not stored (pixel data) */
  if(d->vl==0) {
    char *s=malloc(6); strcpy(s, "empty"); 
    return(s);
  } else if(d->rd==NULL) {
    char *s=malloc(3); strcpy(s, "na"); 
    return(s);
  }
 
  unsigned int len;
  if(d->vl==0xFFFFFFFF) len=(unsigned int)dcmVRVLength(d->vr); else len=d->vl;
 
  /* String values */
  if(d->vr==DCM_VR_CS || d->vr==DCM_VR_DS || d->vr==DCM_VR_IS || 
     d->vr==DCM_VR_LO || d->vr==DCM_VR_LT || d->vr==DCM_VR_PN || 
     d->vr==DCM_VR_SH || d->vr==DCM_VR_ST)
  {
    char *s=malloc(len+1);
    memcpy(s, d->rd, len); s[len]=(char)0;
    return(s);
  }
 
  /* More string values */
  if(d->vr==DCM_VR_AS || d->vr==DCM_VR_PN || 
     d->vr==DCM_VR_DA || d->vr==DCM_VR_DT || d->vr==DCM_VR_TM || 
     d->vr==DCM_VR_UT || d->vr==DCM_VR_AE || 
     d->vr==DCM_VR_UI || d->vr==DCM_VR_UR)
  {
    char *s=malloc(len+1);
    memcpy(s, d->rd, len); s[len]=(char)0;
    return(s);
  }

  if(d->vr==DCM_VR_AT) {
    DCMTAG tag;
    memcpy(&tag.group, d->rd, 2);
    memcpy(&tag.element, d->rd+2, 2);
    if(!little_endian()) {
      swap(&tag.group, &tag.group, 2);
      swap(&tag.element, &tag.element, 2);
    }
    char *s=malloc(14);
    sprintf(s, "0x%04x,0x%04x", tag.group, tag.element);
    return(s);
  }

  if(d->vr==DCM_VR_FL) {
    float f;
    memcpy(&f, d->rd, 4);
    if(!little_endian()) swap(&f, &f, 4);
    char *s=malloc(16);
    sprintf(s, "%g", f);
    return(s);
  }

  if(d->vr==DCM_VR_FD) {
    char *s=malloc(32);
    double f;
    memcpy(&f, d->rd, 8);
    if(!little_endian()) swap(&f, &f, 8);
    sprintf(s, "%g", f);
    return(s);
  }

  if(d->vr==DCM_VR_UL) {
    unsigned int i;
    memcpy(&i, d->rd, 4);
    if(!little_endian()) swap(&i, &i, 4);
    char *s=malloc(16);
    sprintf(s, "%u", i);
    return(s);
  }

  if(d->vr==DCM_VR_US) {
    unsigned short int i;
    memcpy(&i, d->rd, 2);
    if(!little_endian()) swap(&i, &i, 2);
    char *s=malloc(8);
    sprintf(s, "%u", i);
    return(s);
  }

  if(d->vr==DCM_VR_SL) {
    int i;
    memcpy(&i, d->rd, 4);
    if(!little_endian()) swap(&i, &i, 4);
    char *s=malloc(16);
    sprintf(s, "%d", i);
    return(s);
  }

  if(d->vr==DCM_VR_SS) {
    short int i;
    memcpy(&i, d->rd, 2);
    if(!little_endian()) swap(&i, &i, 2);
    char *s=malloc(8);
    sprintf(s, "%d", i);
    return(s);
  }
 
/* Not (yet) printed:
  DCM_VR_OB,        ///< DICOM other byte string, even bytes, endian insensitive.
  DCM_VR_OD,        ///< DICOM other double (64-bit) stream, endian sensitive.
  DCM_VR_OF,        ///< DICOM other float (32-bit) stream, endian sensitive.
  DCM_VR_OL,        ///< DICOM other long (32-bit) stream, endian sensitive.
  DCM_VR_OW,        ///< DICOM other word (16-bit) stream, even bytes, endian sensitive.
  DCM_VR_UC,        ///< DICOM unlimited characters.
  DCM_VR_UN,        ///< DICOM unknown, any valid length of another VR.
  DCM_VR_INVALID    ///< Invalid DICOM value representation.
*/
  char *s=malloc(3); strcpy(s, "na"); // do not write char *s="na";
  return(s);
}

Referenced by dcmitemPrint().

dcmVerifyMagic()

int dcmVerifyMagic	(	const char *	filename,
		FILE *	fp )

Verify that given file (either file name or file pointer) appears to be DICOM file, based on the magic number.

See also

dcmReadFile, dcmReadTransferSyntaxUID

Returns

Returns 1 if DICOM magic number can be found, or 0 if not.

Author

Vesa Oikonen

Parameters

filename	Name of file to open and to verify for the magic number; enter NULL to use the file pointer (next argument) instead.
fp	File pointer of file to check, opened with fp=fopen(filename, "rb"); enter NULL to open file (previous argument) locally. Previously opened file pointer is first rewound to start; if DICOM magic number is found, then file pointer is left to the end of magic number, and if not, it is rewound to the file start.

Definition at line 157 of file dcm.c.

  {
  FILE *lfp;
 
  if(filename==NULL && fp==NULL) return(0);
  if(fp!=NULL) {
    lfp=fp; rewind(lfp);
  } else {
    lfp=fopen(filename, "rb");
  }
  if(lfp==NULL) return(0);
 
  /* Skip the first 128 bytes */
  if(fseek(lfp, 128, SEEK_SET)) {if(fp==NULL) fclose(lfp); return(0);}
 
  /* Read the next 4 bytes as characters */
  char buf[5];
  size_t n=fread(&buf, 1, 4, lfp);
  buf[4]=(char)0;
  if(n!=(size_t)4) {rewind(lfp); return(0);}
 
  /* Check the magic number */
  if(strncmp(buf, "DICM", 4)==0) {
    if(fp==NULL) fclose(lfp);
    return(1);
  } else {
    if(fp==NULL) fclose(lfp); else rewind(lfp);
    return(0);
  }
}

Referenced by dcmFileRead(), and imgFormatDetermine().

dcmVRDescr()

char * dcmVRDescr

(

dcmvr

id

)

Get the DICOM VR description.

Returns

Returns pointer to the description string.

See also

dcmIdentifyVR

Parameters

id	VR id (DCM_VR_AE, ...).

Definition at line 282 of file dcm.c.

  {
  unsigned short int i=0;
  while(dcm_vr[i].vr!=DCM_VR_INVALID) {
    if(id==dcm_vr[i].vr) return(dcm_vr[i].descr);
    i++;
  }
  return(dcm_vr[DCM_VR_INVALID].descr);
}

Referenced by dcmFileReadNextElement().

dcmVRId()

dcmvr dcmVRId

(

const char *

s

)

Identify the DICOM VR based on the two-character long string.

Returns

Returns the VR id.

See also

dcmVRName

Parameters

s	VR string. Two first characters are used. String does not need to be null-terminated.

Definition at line 223 of file dcm.c.

  {
  if(s==NULL) return(DCM_VR_INVALID);
  char buf[3]; buf[0]=s[0]; buf[1]=s[1]; buf[2]=(char)0;
 
  /* Identify the VR */
  unsigned short int i=0;
  while(dcm_vr[i].vr!=DCM_VR_INVALID) {
    if(strncmp(dcm_vr[i].name, buf, 2)==0) return(dcm_vr[i].vr);
    i++;
  }
  return(DCM_VR_INVALID);
}

Referenced by dcmReadFileVR(), and dcmReadFileVRVL().

dcmVRName()

char * dcmVRName

(

dcmvr

id

)

Get the DICOM VR name.

Returns

Returns pointer to the name string.

See also

dcmIdentifyVR

Parameters

id	VR id (DCM_VR_AE, ...).

Definition at line 246 of file dcm.c.

  {
  unsigned short int i=0;
  while(dcm_vr[i].vr!=DCM_VR_INVALID) {
    if(id==dcm_vr[i].vr) return(dcm_vr[i].name);
    i++;
  }
  return(dcm_vr[DCM_VR_INVALID].name);
}

Referenced by dcmAddItem(), dcmFileReadNextElement(), dcmitemPrint(), dcmReadFileVR(), and dcmWriteFileVRVL().

dcmVRReserved()

unsigned char dcmVRReserved

(

dcmvr

id

)

Is the explicit VR (2 bytes) followed by reserved 2 bytes? If yes, then the following Value Length is also given as 32-byte integer, if no, then as 16-bit integer.

Returns

Returns 0, if not, and 2, if it is.

Parameters

id	VR id (DCM_VR_AE, ...).

Definition at line 205 of file dcm.c.

  {
  unsigned short int i=0;
  while(dcm_vr[i].vr!=DCM_VR_INVALID) {
    if(id==dcm_vr[i].vr) return(dcm_vr[i].res);
    i++;
  }
  return(2);
}

Referenced by dcmReadFileVR(), dcmReadFileVRVL(), dcmReadTransferSyntaxUID(), and dcmWriteFileVRVL().

dcmVRVLength()

size_t dcmVRVLength

(

dcmvr

id

)

Get the DICOM VR max value length in bytes; 0 if not defined.

Returns

Returns the length in bytes.

See also

dcmIdentifyVR

Parameters

id	VR id (DCM_VR_AE, ...).

Definition at line 264 of file dcm.c.

  {
  unsigned short int i=0;
  while(dcm_vr[i].vr!=DCM_VR_INVALID) {
    if(id==dcm_vr[i].vr) return(dcm_vr[i].s);
    i++;
  }
  return(dcm_vr[DCM_VR_INVALID].s);
}

Referenced by dcmAddItem(), dcmFileReadNextElement(), dcmFileWrite(), and dcmValueString().

dcmWriteFileSQDelimItem()

int dcmWriteFileSQDelimItem

(

FILE *

fp

)

Write DICOM Sequence delimitation item into current file position.

This item consists of four byte sequence delimitation tag (0xFFFE, 0xE0DD) and four byte item length (0x00000000), i.e. together 8 bytes.

See also

dcmWriteFileTag, dcmReadFileTag, dcmWriteFileSQItemDelimTag

Returns

0 when successful.

Author

Vesa Oikonen

Parameters

fp	File pointer, at the write position.

Definition at line 609 of file dcm.c.

  {
  if(fp==NULL) return(1);
  int ret;
  DCMTAG tag; 
  tag.group=0xFFFE; tag.element=0xE0DD;
  ret=dcmWriteFileTag(fp, &tag); if(ret!=0) return(ret);
  tag.group=0x0000; tag.element=0x0000;
  ret=dcmWriteFileTag(fp, &tag); if(ret!=0) return(ret);
  return(0);
}

Referenced by dcmFileWrite().

dcmWriteFileSQItemDelimTag()

int dcmWriteFileSQItemDelimTag

(

FILE *

fp

)

Write DICOM Sequence Item Delimitation Tag with VL into current file position.

This tag consists of four bytes, sequence item delimitation tag (0xFFFE, 0xE00D), followed by four byte item length (0x00000000), i.e. together 8 bytes.

See also

dcmWriteFileTag, dcmReadFileTag, dcmWriteFileSQDelimItem

Returns

0 when successful.

Author

Vesa Oikonen

Parameters

fp	File pointer, at the write position.

Definition at line 634 of file dcm.c.

  {
  if(fp==NULL) return(1);
  int ret;
  DCMTAG tag; 
  tag.group=0xFFFE; tag.element=0xE00D;
  ret=dcmWriteFileTag(fp, &tag); if(ret!=0) return(ret);
  tag.group=0x0000; tag.element=0x0000;
  ret=dcmWriteFileTag(fp, &tag); if(ret!=0) return(ret);
  return(0);
}

Referenced by dcmFileWrite().

dcmWriteFileTag()

int dcmWriteFileTag	(	FILE *	fp,
		DCMTAG *	tag )

Write DICOM tag into current file position.

See also

dcmWriteFile, dcmReadFileTag

Returns

0 when successful.

Author

Vesa Oikonen

Parameters

fp	File pointer, at the write position.
tag	Pointer to DICOM tag struct to write.

Definition at line 583 of file dcm.c.

  {
  if(fp==NULL || tag==NULL) return(1);
  unsigned short int buf[2];
  buf[0]=tag->group;
  buf[1]=tag->element;
  if(!little_endian()) swabip(buf, 4); // tag is by default little endian
  if(fwrite(&buf, 2, 2, fp)!=2) return(2);
  return(0);
}

Referenced by dcmFileWrite(), dcmWriteFileSQDelimItem(), and dcmWriteFileSQItemDelimTag().

dcmWriteFileVRVL()

int dcmWriteFileVRVL	(	FILE *	fp,
		dcmvr	vr,
		unsigned int	vl,
		unsigned int *	n )

Write DICOM Value Representation (VR, 2 or 4 bytes) and Value Length (VL, 2 or 4 bytes) into current file position.

See also

dcmWriteFileTag, dcmReadFileElement, dcmWriteFileVRVL

Returns

0 when successful.

Author

Vesa Oikonen

Parameters

fp	File pointer, opened fro writing in binary mode.
vr	Enumerated VR value.
vl	VL
n	Pointer for number of bytes written into file; enter NULL if not needed.

Definition at line 784 of file dcm.c.

  {
  if(n!=NULL) *n=0;
  if(fp==NULL || vr==DCM_VR_INVALID) return(1);
 
  /* If this VR has extra 2 byte reserved space, then
     we need to write VR and VL with 4 bytes each, other wise with 2 bytes each. */
  unsigned int bsize=2+dcmVRReserved(vr);
 
  char buf[10];
 
  /* Write VR */
  memcpy(buf, dcmVRName(vr), 2); buf[2]=buf[3]=(char)0;
  if(fwrite(buf, bsize, 1, fp)!=1) return(2);
  if(n!=NULL) *n+=bsize;
 
  /* Write VL */
  memcpy(buf, &vl, bsize);
  if(bsize==2) buf[2]=buf[3]=(char)0;
  if(!little_endian()) swap(buf, buf, bsize);
  if(fwrite(buf, bsize, 1, fp)!=1) return(2);
  if(n!=NULL) *n+=bsize;
 
  return(0);
}

Referenced by dcmFileWrite().