tpcdcm.h File Reference

Header file for libtpcdcm. More...

#include "tpcclibConfig.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "tpcextensions.h"
#include "tpcift.h"
#include "tpcfileutil.h"
#include "tpcisotope.h"

Go to the source code of this file.

Data Structures
struct	DCMTAG
struct	DCMITEM
struct	DCMFILE
struct	DCMMATRIX
struct	DCMML

Enumerations
enum	dcmtruid {   DCM_TRUID_UNKNOWN , DCM_TRUID_LEI , DCM_TRUID_LEE , DCM_TRUID_LEED ,   DCM_TRUID_BEE , DCM_TRUID_JPEG50 , DCM_TRUID_JPEG51 , DCM_TRUID_JPEG70 ,   DCM_TRUID_JPEG80 , DCM_TRUID_JPEG81 , DCM_TRUID_JPEG90 , DCM_TRUID_JPEG91 ,   DCM_TRUID_JPEG92 , DCM_TRUID_JPEG93 , DCM_TRUID_MPEG100 , DCM_TRUID_MPEG102 ,   DCM_TRUID_MPEG103 , DCM_TRUID_RLE , DCM_TRUID_RFC , DCM_TRUID_XML ,   DCM_TRUID_INVALID }
enum	dcmvr {   DCM_VR_AE , DCM_VR_AS , DCM_VR_AT , DCM_VR_CS ,   DCM_VR_DA , DCM_VR_DS , DCM_VR_DT , DCM_VR_FL ,   DCM_VR_FD , DCM_VR_IS , DCM_VR_LO , DCM_VR_LT ,   DCM_VR_OB , DCM_VR_OD , DCM_VR_OF , DCM_VR_OL ,   DCM_VR_OW , DCM_VR_PN , DCM_VR_SH , DCM_VR_SL ,   DCM_VR_SQ , DCM_VR_SS , DCM_VR_ST , DCM_VR_TM ,   DCM_VR_UC , DCM_VR_UI , DCM_VR_UL , DCM_VR_UN ,   DCM_VR_UR , DCM_VR_US , DCM_VR_UT , DCM_VR_INVALID }

Functions
void	dcmfileInit (DCMFILE *d)
void	dcmitemFree (DCMITEM *d)
void	dcmfileFree (DCMFILE *d)
unsigned short int	dcmfileMaxDepth (DCMFILE *df)
unsigned short int	dcmitemMaxDepth (DCMITEM *d)
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)
DCMITEM *	dcmFindDownTag (DCMITEM *d, const short int omit, DCMTAG *tag, const int verbose)
int	dcmTagIntRange (DCMITEM *d, DCMTAG *tag, int *mi, int *ma, const int verbose)
dcmtruid	dcmTrUID (const char *s)
char *	dcmTrUIDDescr (dcmtruid id)
char *	dcmTrUIDString (dcmtruid id)
unsigned int	dcmSOPIdentify (const char *s)
char *	dcmSOPName (unsigned int i)
char *	dcmSOPUID (unsigned int i)
char *	dcmSOPUIDName (const char *s)
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	dcmDictSize ()
int	dcmDictIndexTag (unsigned int i, unsigned short int *group, unsigned short int *element)
char *	dcmDictIndexVR (unsigned int i)
char *	dcmDictIndexType (unsigned int i)
char *	dcmDictIndexDescr (unsigned int i)
unsigned int	dcmDictFindTag (DCMTAG *tag)
int	dcmSameImage (const DCMFILE *d1, const DCMFILE *d2, const int verbose)
int	dcmFileList (const char *filename, IFT *ift, TPCSTATUS *status)
	List DICOM files belonging to one image.
int	dcmFileRemove (const char *filename, TPCSTATUS *status)
	Remove DICOM files belonging to one image.
int	dcmVerifyMagic (const char *filename, FILE *fp)
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)
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, TPCSTATUS *status)
int	dcmFileWrite (const char *filename, DCMFILE *dcm, TPCSTATUS *status)
int	dcmImgIsotope (DCMFILE *d, isotope *isot, decaycorrection *dc, const int verbose)
int	dcmImgPos (DCMFILE *d, double *imgpos, const int verbose)
int	dcmImgDim (DCMFILE *d, unsigned short int *imgdim, const int verbose)
int	dcmImgPxlsize (DCMFILE *d, double *pxlsize, const int verbose)
int	dcmImgOrient (DCMFILE *d, double *iop, const int verbose)
int	dcmImgXform (double *iop, double *xyzMM, double *imgPos, double *xform, const int verbose)
int	dcmXformToQuatern (double *xform, double *quatern, double *qoffset, const int verbose)
void	dcmmatrixInit (DCMMATRIX *m)
void	dcmmatrixFree (DCMMATRIX *m)
void	dcmmlInit (DCMML *d)
void	dcmmlFree (DCMML *d)
int	dcmmlAllocate (DCMML *d, int mNr)
int	dcmMListRead (IFT *ift, DCMML *ml, TPCSTATUS *status)
int	dcmmlSortByPlane (DCMML *d, TPCSTATUS *status)

Detailed Description

Header file for libtpcdcm.

Header file for library libtpcdcm.

Author

Vesa Oikonen

Copyright

(c) Turku PET Centre

Definition in file tpcdcm.h.

Enumeration Type Documentation

dcmtruid

enum dcmtruid

DICOM Transfer Syntax UID.

In case of implicit VR, elements do NOT contain VR ! Reference: DICOM PS3.5 2017a chapter 10.

Items must be the same and in the same order as the dcm_truid list in dcmuid.c.

Enumerator
DCM_TRUID_UNKNOWN	Unknown Transfer Syntax UID.
DCM_TRUID_LEI	Little Endian Implicit VR (DICOM default).
DCM_TRUID_LEE	Little Endian Explicit VR.
DCM_TRUID_LEED	Little Endian Explicit Deflated VR.
DCM_TRUID_BEE	Big Endian Explicit VR (retired).
DCM_TRUID_JPEG50	Lossy JPEG 8-bit compression.
DCM_TRUID_JPEG51	Lossy JPEG 12-bit compression.
DCM_TRUID_JPEG70	Lossless JPEG.
DCM_TRUID_JPEG80	Lossless JPEG-LS.
DCM_TRUID_JPEG81	Lossy JPEG-LS.
DCM_TRUID_JPEG90	Lossless JPEG 2000.
DCM_TRUID_JPEG91	JPEG 2000.
DCM_TRUID_JPEG92	Lossless multicomponent JPEG 2000.
DCM_TRUID_JPEG93	Multicomponent JPEG 2000.
DCM_TRUID_MPEG100	MPEG-2.
DCM_TRUID_MPEG102	MPEG-4.
DCM_TRUID_MPEG103	MPEG-4 BD-compatible.
DCM_TRUID_RLE	Lossless RLE.
DCM_TRUID_RFC	RFC 2557.
DCM_TRUID_XML	XML encoding.
DCM_TRUID_INVALID	Invalid Transfer Syntax UID.

Definition at line 57 of file tpcdcm.h.

             {
  DCM_TRUID_UNKNOWN, 
  DCM_TRUID_LEI,     
  DCM_TRUID_LEE,     
  DCM_TRUID_LEED,    
  DCM_TRUID_BEE,     
  DCM_TRUID_JPEG50,  
  DCM_TRUID_JPEG51,  
  DCM_TRUID_JPEG70,  
  DCM_TRUID_JPEG80,  
  DCM_TRUID_JPEG81,  
  DCM_TRUID_JPEG90,  
  DCM_TRUID_JPEG91,  
  DCM_TRUID_JPEG92,  
  DCM_TRUID_JPEG93,  
  DCM_TRUID_MPEG100, 
  DCM_TRUID_MPEG102, 
  DCM_TRUID_MPEG103, 
  DCM_TRUID_RLE,     
  DCM_TRUID_RFC,     
  DCM_TRUID_XML,     
  DCM_TRUID_INVALID  
} dcmtruid;

dcmvr

enum dcmvr

DICOM value representation (VR).

Reference: DICOM PS3.5 2017a chapter 6.2.

Items must be the same and in the same order as the dcm_vr list in dcmvr.c.

Enumerator
DCM_VR_AE	DICOM application entity, max 16 bytes.
DCM_VR_AS	DICOM age string, 4 bytes fixed.
DCM_VR_AT	DICOM attribute tag, 4 bytes fixed.
DCM_VR_CS	DICOM code (control) string, max 16 bytes.
DCM_VR_DA	DICOM date in format YYYYMMDD, 8 bytes fixed. Note In old standard 10 bytes fixed, in format YYYY.MM.DD
DCM_VR_DS	DICOM decimal string, max 16 bytes.
DCM_VR_DT	DICOM date time, max 26 bytes.
DCM_VR_FL	DICOM floating point single precision, 4 bytes fixed.
DCM_VR_FD	DICOM floating point double precision, 8 bytes fixed.
DCM_VR_IS	DICOM integer string, max 12 bytes.
DCM_VR_LO	DICOM long string, max 64 chars.
DCM_VR_LT	DICOM long text, max 10240 chars.
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_PN	DICOM person name, max 64 chars per component group.
DCM_VR_SH	DICOM short string, max 16 chars.
DCM_VR_SL	DICOM signed long (32-bit integer), 4 bytes fixed.
DCM_VR_SQ	DICOM sequence of zero or more elements (used for nested data).
DCM_VR_SS	DICOM signed short (16-bit integer), 2 bytes fixed.
DCM_VR_ST	DICOM short text, max 1024 chars.
DCM_VR_TM	DICOM time HHMMSS.FFFFFF, max 14 bytes. Note In old standard 16 bytes max.
DCM_VR_UC	DICOM unlimited characters.
DCM_VR_UI	DICOM unique identifier (UID), max 64 bytes.
DCM_VR_UL	DICOM unsigned long (32-bit) integer, 4 bytes fixed.
DCM_VR_UN	DICOM unknown, any valid length of another VR.
DCM_VR_UR	DICOM URI or URL, string of characters.
DCM_VR_US	DICOM unsigned short (16-bit) integer, 2 bytes fixed.
DCM_VR_UT	DICOM unlimited text, character string.
DCM_VR_INVALID	Invalid DICOM value representation.

Definition at line 91 of file tpcdcm.h.

             {
  DCM_VR_AE,        
  DCM_VR_AS,        
  DCM_VR_AT,        
  DCM_VR_CS,        
  DCM_VR_DA,        
  DCM_VR_DS,        
  DCM_VR_DT,        
  DCM_VR_FL,        
  DCM_VR_FD,        
  DCM_VR_IS,        
  DCM_VR_LO,        
  DCM_VR_LT,        
  DCM_VR_OB,        
  DCM_VR_OD,        
  DCM_VR_OF,        
  DCM_VR_OL,        
  DCM_VR_OW,        
  DCM_VR_PN,        
  DCM_VR_SH,        
  DCM_VR_SL,        
  DCM_VR_SQ,        
  DCM_VR_SS,        
  DCM_VR_ST,        
  DCM_VR_TM,        
  DCM_VR_UC,        
  DCM_VR_UI,        
  DCM_VR_UL,        
  DCM_VR_UN,        
  DCM_VR_UR,        
  DCM_VR_US,        
  DCM_VR_UT,        
  DCM_VR_INVALID    
} dcmvr;

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 501 of file dcmdata.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);
}

Referenced by imgWriteDICOM().

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 179 of file dcmvr.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(strDateValid(intl)) {intl[0]=(char)0; return(NULL);}
  return(intl);
}

Referenced by dcmMListRead().

dcmDictFindTag()

unsigned int dcmDictFindTag

(

DCMTAG *

tag

)

Get the dictionary index for given tag.

Returns

If tag is found, returns its dictionary index; otherwise returns the length of the dictionary.

See also

dcmDictSize, dcmDictIndexTag, dcmDictIndexVR, dcmDictIndexType, dcmDictIndexDescr

Parameters

tag	Pointer to DICOM tag.

Definition at line 2820 of file dcmdictionary.c.

  {
  unsigned int i, n=dcmDictSize();
  if(tag==NULL) return(n);
  for(i=0; i<n; i++)
    if(tag->group==dcmdict[i].group && tag->element==dcmdict[i].element) break;
  return(i);
}

Referenced by dcmFileReadNextElement().

dcmDictIndexDescr()

char * dcmDictIndexDescr

(

unsigned int

i

)

Get the DICOM tag description, based on given dictionary index.

Returns

Returns pointer to description string, which is 'Unknown' if index equals dictionary length, or NULL in case of an error.

See also

dcmDictSize, dcmDictIndexTag, dcmDictFindTag

Parameters

i	Dictionary index [0..n-1].

Definition at line 2780 of file dcmdictionary.c.

  {
  if(i>dcmDictSize()) return(char*)NULL;
  else return(dcmdict[i].descr);
}

Referenced by dcmFileReadNextElement().

dcmDictIndexTag()

int dcmDictIndexTag	(	unsigned int	i,
		unsigned short int *	group,
		unsigned short int *	element )

Get the DICOM tag group and element, based on given dictionary index.

Returns

Returns 0 when successful, 1 if invalid index.

See also

dcmDictSize, dcmDictIndexVR, dcmDictIndexType, dcmDictIndexDescr, dcmDictFindTag

Parameters

i	Dictionary index [0..n-1].
group	Pointer to tag group; enter NULL if not needed.
element	Pointer to tag element; enter NULL if not needed.

Definition at line 2744 of file dcmdictionary.c.

  {
  if(group!=NULL) *group=0;
  if(element!=NULL) *element=0;
  if(i>=dcmDictSize()) return(1);
  if(group!=NULL) *group=dcmdict[i].group;
  if(element!=NULL) *element=dcmdict[i].element;
  return(0);
}

dcmDictIndexType()

char * dcmDictIndexType

(

unsigned int

i

)

Get the DICOM Tag Type, based on given dictionary index.

Tag Type is a NULL terminated string.

• 1: mandatory.
• 1C: mandatory only under certain conditions.
• 2: required to exist, but can have a null value.
• 2C: required to exist only under certain conditions.
• 3: optional.

Reference: DICOM PS3.3

Returns

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

See also

dcmDictSize, dcmDictIndexTag, dcmDictFindTag

Parameters

i	Dictionary index [0..n-1].

Definition at line 2804 of file dcmdictionary.c.

  {
  if(i>=dcmDictSize()) return(char*)NULL;
  else return(dcmdict[i].type);
}

dcmDictIndexVR()

char * dcmDictIndexVR

(

unsigned int

i

)

Get the DICOM tag VR string, based on given dictionary index.

Returns

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

See also

dcmDictSize, dcmDictIndexTag, dcmDictFindTag

Definition at line 2766 of file dcmdictionary.c.

  {
  if(i>=dcmDictSize()) return(char*)NULL;
  else return(dcmdict[i].vr);
}

Referenced by dcmFileReadNextElement().

dcmDictSize()

unsigned int dcmDictSize

(

)

Get the size of DICOM dictionary.

Returns

Returns the size of the dictionary.

Definition at line 2730 of file dcmdictionary.c.

{
  unsigned int n=1;
  while(dcmdict[n].group<0xFFFF && dcmdict[n].element<0xFFFF) n++;
  return(n);
}

Referenced by dcmDictFindTag(), dcmDictIndexDescr(), dcmDictIndexTag(), dcmDictIndexType(), and dcmDictIndexVR().

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 225 of file dcmvr.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(strDateTimeValid(intl, NULL)) {intl[0]=(char)0; return(NULL);}
  return(intl);
}

Referenced by dcmMListRead(), and imgReadDICOM().

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 67 of file dcmdata.c.

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

Referenced by dcmFileList(), dcmFileRead(), dcmMListRead(), imgReadDICOM(), and imgWriteDICOM().

dcmfileInit()

void dcmfileInit

(

DCMFILE *

d

)

Initiate the DCMFILE struct before any use.

See also

dcmfileFree

Parameters

d	Pointer to DCMFILE.

Definition at line 22 of file dcmdata.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(), dcmFileList(), dcmMListRead(), imgReadDICOM(), and imgWriteDICOM().

dcmFileList()

int dcmFileList	(	const char *	filename,
		IFT *	ift,
		TPCSTATUS *	status )

List DICOM files belonging to one image.

User can give DICOM image as a folder containing image file(s), or as a name of one of the files of the image. This function lists the files (with paths) belonging to the same image.

See also

dcmFileRemove, dcmSameImage

Returns

Code tpcerror, TPCERROR_OK (0) when successful.

Parameters

filename	Pointer to the name of DICOM directory or file.
ift	Pointer to initiated IFT structure, into which file names will be stored; any previous contents will be deleted.
status	Pointer to status data; enter NULL if not needed.

Definition at line 123 of file dcmfile.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(filename==NULL || strnlen(filename, 10)<1 || ift==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  if(verbose>1) printf("%s('%s', ...)\n", __func__, filename);
 
  /* Make the list */
  unsigned short int fileNr=0;
  if(pathExist(filename)) {
    /* We got a directory */
    if(verbose>2) printf("%s is a directory\n", filename);
    /* List all files in it */
    iftFree(ift);
    fileNr=pathFileList(filename, ift);
    if(fileNr==0) {
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_FILE);
      return(TPCERROR_NO_FILE);
    }
    /* Remove files that are not DICOM */
    int i=ift->keyNr-1;
    do {
      if(!dcmVerifyMagic(ift->item[i].value, NULL)) iftDelete(ift, i);
      i--;
    } while(i>=0);
    fileNr=ift->keyNr; if(verbose>3) printf("fileNr := %d\n", fileNr);
    if(fileNr==0) {
      iftFree(ift);
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNSUPPORTED);
      return(TPCERROR_UNSUPPORTED);
    }
    /* Check that all remaining files belong to the same image */
    DCMFILE dcm1; dcmfileInit(&dcm1);
    i=0; int ret;
    ret=dcmFileRead(ift->item[i].value, &dcm1, 1, status);
    if(ret!=TPCERROR_OK) {iftFree(ift); return(ret);}
    DCMFILE dcm2; dcmfileInit(&dcm2);
    for(i=1; i<ift->keyNr; i++) {
      ret=dcmFileRead(ift->item[i].value, &dcm2, 1, NULL /*status*/);
      if(ret!=TPCERROR_OK) {
        iftFree(ift); dcmfileFree(&dcm1);
        statusSet(status, __func__, __FILE__, __LINE__, ret);
        return(ret);
      }
      if(!dcmSameImage(&dcm1, &dcm2, verbose-10)) {
        dcmfileFree(&dcm2); iftFree(ift);
        statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INCOMPATIBLE_DATA);
        return(TPCERROR_INCOMPATIBLE_DATA);
      }
      dcmfileFree(&dcm2);
    }
    dcmfileFree(&dcm1);
  } else if(fileExist(filename)) {
    /* We got a file */
    if(verbose>2) printf("%s is a file\n", filename);
    /* Verify that it is DICOM */
    if(!dcmVerifyMagic(filename, NULL)) {
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNSUPPORTED);
      return(TPCERROR_UNSUPPORTED);
    }
    if(verbose>2) {printf("... and DICOM\n"); fflush(stdout);}
    /* Read the specified file */
    DCMFILE dcm1; dcmfileInit(&dcm1);
    int ret;
    ret=dcmFileRead(filename, &dcm1, 1, status);
    if(ret!=TPCERROR_OK) {iftFree(ift); return(ret);}
    /* Check whether Per-frame Functional Groups Sequence is set */
    DCMTAG tag; dcmTagSet(&tag, 0x5200, 0x9230);
    if(dcmFindTag(dcm1.item, 0, &tag, 0)!=NULL) {
      dcmfileFree(&dcm1);
      if(verbose>1)
        printf("Per-frame Functional Groups Sequence is available: assuming single-file.\n");
      iftFree(ift); fileNr=1;
      iftPut(ift, "", filename, 0, NULL); 
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
      return(TPCERROR_OK);
    }
 
    /* Since there is no RELIABLE way to tell how many files make up the whole
       image, we have to list files in the same path */
    char *pathname=strdup(filename); filenameRmFile(pathname);
    if(verbose>3) printf("%s is its path\n", pathname);
    iftFree(ift); 
    fileNr=pathFileList(pathname, ift); free(pathname);
    if(verbose>3) printf("fileNr := %d\n", fileNr);
    if(fileNr==0) {
      iftFree(ift);
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FILENAME);
      return(TPCERROR_INVALID_FILENAME);
    }
    /* Remove files that are not DICOM */
    int i=ift->keyNr-1;
    do {
      if(!dcmVerifyMagic(ift->item[i].value, NULL)) iftDelete(ift, i);
      i--;
    } while(i>=0);
    fileNr=ift->keyNr; if(verbose>3) printf("fileNr := %d\n", fileNr);
    if(fileNr==0) {
      iftFree(ift);
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNSUPPORTED);
      return(TPCERROR_UNSUPPORTED);
    }
    /* Remove files that do not belong to the same series as the specified file */
    DCMFILE dcm2; dcmfileInit(&dcm2);
    i=ift->keyNr-1;
    do {
      ret=dcmFileRead(ift->item[i].value, &dcm2, 1, NULL /*status*/);
      if(ret!=TPCERROR_OK || !dcmSameImage(&dcm1, &dcm2, verbose-10)) {
        if(verbose>5) {printf("  not same, removing from list\n"); fflush(stdout);}
        iftDelete(ift, i); 
      }
      dcmfileFree(&dcm2);
      i--;
    } while(i>=0);
    dcmfileFree(&dcm1);
    fileNr=ift->keyNr; if(verbose>3) printf("fileNr := %d\n", fileNr);
    if(fileNr==0) {
      iftFree(ift);
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNSUPPORTED);
      return(TPCERROR_UNSUPPORTED);
    }
  } else {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_FILE);
    return(TPCERROR_NO_FILE);
  }
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by dcmFileRemove(), and imgRead().

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 102 of file dcmdata.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,
		TPCSTATUS *	status )

Read a single DICOM file.

See also

dcmVerifyMagic, dcmfileInit, dcmfileFree, dcmReadTransferSyntaxUID, dcmFileWrite, dcmFileList

Returns

Code tpcerror, TPCERROR_OK (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).
status	Pointer to status data; enter NULL if not needed.

Definition at line 768 of file dcmio.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(filename==NULL || strnlen(filename, 10)<1 || dcm==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  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) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_OPEN);
    return TPCERROR_CANNOT_OPEN;
  }
 
  /* 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);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  /* 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);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  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 */
  switch(dcm->truid) {
    case DCM_TRUID_LEE:
    case DCM_TRUID_LEI: // actually not supported yet
      break;
    default:
      fclose(dcm->fp);
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNSUPPORTED);
      return TPCERROR_UNSUPPORTED;
  }
 
  /* Read DICOM file elements */
  int ret=TPCERROR_OK;
  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==TPCERROR_OK && !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==TPCERROR_NO_KEY) {
    if(verbose>1) printf(" eof\n");
    ret=TPCERROR_OK;
  }
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  return(ret);
}

Referenced by dcmFileList(), dcmMListRead(), and imgReadDICOM().

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

Code tpcerror, TPCERROR_OK (0) when successful, TPCERROR_NO_KEY 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 409 of file dcmio.c.

  {
  if(verbose>0) printf("%s(DCMFILE*, DCMITEM*, DCMITEM*, %d, %d)\n", __func__, sub, headerOnly);
  if(dcm==NULL || dcm->fp==NULL) return(TPCERROR_FAIL);
  if(sub!=0 && parent_item==NULL) return(TPCERROR_FAIL);
  if(feof(dcm->fp)) return(TPCERROR_NO_KEY);
 
  /* Check whether we currently support the Transfer UID */
  switch(dcm->truid) {
    case DCM_TRUID_LEE:
      break;
    case DCM_TRUID_LEI: // actually not supported yet
      break;
    default:
      return(TPCERROR_UNSUPPORTED);
  }
 
  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 sub-element\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(TPCERROR_OUT_OF_MEMORY);
  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(TPCERROR_CANNOT_READ);
  }
 
  /* Read the tag (2x2 bytes) */
  if(verbose>10) {
    long long int tagpos=ftello(dcm->fp);
    printf(" reading tag at %lld\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(TPCERROR_NO_KEY);
    return(TPCERROR_CANNOT_READ);
  }
 
  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(TPCERROR_INVALID_VALUE);
    }
    return(TPCERROR_OK);
  }
 
 
  /* Read value representation and length (VR and VL, 2x2 or 2x4 bytes) */
  if(item->tag.group==0x0002 || dcm->truid==DCM_TRUID_LEE) {
    // Group 0x0002 is always DCM_TRUID_LEE, the other groups are specified by
    // the Transfer Syntax UID 
    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!=TPCERROR_OK) {
      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);
    }
  } else if(dcm->truid==DCM_TRUID_LEI) {
    if(verbose>10) printf(" set VR based on the tag\n");
    unsigned int i=dcmDictFindTag(&item->tag);
    item->vr=dcmVRId(dcmDictIndexVR(i));
    if(item->vr!=DCM_VR_INVALID) {
      if(verbose>1) {
        printf(" VR := %s (%s)\n", dcmVRName(item->vr), dcmVRDescr(item->vr));
        fflush(stdout);
      }
    } else {
      if(verbose>1) printf(" VR not known for tag(%04x,%04x)\n",
                            item->tag.group, item->tag.element);
    }
    if(verbose>10) printf(" reading VL\n");
    item->vl=dcmReadFileVL(dcm->fp, 4); 
    if(verbose>1) {
      printf(" VL := %u (0x%08x)\n", item->vl, item->vl);
      fflush(stdout);
    }
  }
 
  /* Read value field, and add the current element to the list */
  if(item->vr==DCM_VR_SQ) {
    if(ftello(dcm->fp)<0) return(TPCERROR_INVALID_FORMAT);
    unsigned long long int sqPos=(unsigned long int)ftello(dcm->fp);
    if(verbose>10) {printf(" sequence... at %llu\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 long int tagpos=ftello(dcm->fp);
      printf(" reading first item tag at %lld\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(TPCERROR_CANNOT_READ);
    }
    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(TPCERROR_INVALID_VALUE);
      }
      if(verbose>3) printf(" ending sequence before it really started.\n");
      return(TPCERROR_OK);
    }
    /* 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(TPCERROR_INVALID_FORMAT); //return(TPCERROR_OK);
    }
    /* 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(ftello(dcm->fp)<0) return(TPCERROR_INVALID_FORMAT);
    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(TPCERROR_OK);
    }
    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!=TPCERROR_OK) {
      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(ftello(dcm->fp)<0) return(TPCERROR_INVALID_FORMAT);
      unsigned long long int cPos=(unsigned long long int)ftello(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 long int tagpos=ftello(dcm->fp);
        printf(" reading next sequence item tag at %lld, %lld after start\n", tagpos, tagpos-sqItemPos);
      }
      if(dcmReadFileTag(dcm->fp, &itemtag)) return(TPCERROR_CANNOT_READ);
      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(TPCERROR_INVALID_VALUE);
        }
        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");
        fseeko(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(TPCERROR_UNSUPPORTED);
      }
      while(child->next_item!=NULL) child=child->next_item;
      ret=dcmFileReadNextElement(dcm, child, item, 0, headerOnly, verbose-1);
      if(ret!=TPCERROR_OK) {
        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(TPCERROR_UNSUPPORTED);
    }
    /* Done. Do not free item! */
    if(verbose>10) {printf(" end of sequence.\n"); fflush(stdout);} //return(TPCERROR_OK);
  } 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(TPCERROR_OUT_OF_MEMORY);}
      if(fread(buf, 1, item->vl, item->fp)!=item->vl) {
        free(item); free(buf); return(TPCERROR_NO_VALUE);
      }
      /* 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;
    }
    /* Print tag and its value */
    if(verbose>1) {
      char *tagval=dcmValueString(item);
      printf(" (%04x,%04x) %s := %s\n", item->tag.group, item->tag.element, 
           dcmDictIndexDescr(dcmDictFindTag(&item->tag)), tagval);
      free(tagval);
    } 
    /* Done. Do no free item or buf! */
    return(TPCERROR_OK);
 
  } else { // VL=0xFFFFFFFF
    size_t s=dcmVRVLength(item->vr);
    if(s==0) {
      if(verbose>0) printf(" Unknown VL!!\n");
      free(item);
      return(TPCERROR_INVALID_VALUE); //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(TPCERROR_OUT_OF_MEMORY);}
    if(fread(buf, 1, s, item->fp)!=s) {
      free(item); free(buf); return(TPCERROR_NO_VALUE);
    }
    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;
    }
    /* Print tag and its value */
    if(verbose>1) {
      char *tagval=dcmValueString(item);
      printf(" (%04x,%04x) %s := %s\n", item->tag.group, item->tag.element, 
           dcmDictIndexDescr(dcmDictFindTag(&item->tag)), tagval);
      free(tagval);
    } 
    /* Done. Do no free item or buf! */
    return(TPCERROR_OK);
  }
 
  return(TPCERROR_OK);
}

Referenced by dcmFileRead(), and dcmFileReadNextElement().

dcmFileRemove()

int dcmFileRemove	(	const char *	filename,
		TPCSTATUS *	status )

Remove DICOM files belonging to one image.

User can give DICOM image as a folder containing image file(s), or as a name of one of the files of the image.

See also

dcmFileList, dcmSameImage, pathRemoveFiles, dcmFileWrite

Returns

Code tpcerror, TPCERROR_OK (0) when successful.

Parameters

filename	Pointer to the name of DICOM directory or file.
status	Pointer to status data; enter NULL if not needed.

Definition at line 270 of file dcmfile.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(filename==NULL || strnlen(filename, 10)<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  if(verbose>1) printf("%s('%s', ...)\n", __func__, filename);
 
  /* List files belonging to the image */
  IFT ift; iftInit(&ift);
  int ret=dcmFileList(filename, &ift, status);
  if(ret!=TPCERROR_OK) {iftFree(&ift); return(ret);}
 
  /* Remove the files */
  for(int i=0; i<ift.keyNr; i++) {
    if(remove(ift.item[i].value)) {
      iftFree(&ift);
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_DELETE);
      return(TPCERROR_CANNOT_DELETE);
    }
  }
  iftFree(&ift);
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by imgWriteDICOM().

dcmFileWrite()

int dcmFileWrite	(	const char *	filename,
		DCMFILE *	dcm,
		TPCSTATUS *	status )

Write a single DICOM file.

See also

dcmFileRead, dcmfileInit, dcmfileFree, dcmFileRemove

Returns

Code tpcerror, TPCERROR_OK (0) when successful.

Parameters

filename	Pointer to file name.
dcm	Pointer to DICOM data to be written.
status	Pointer to status data; enter NULL if not needed.

Definition at line 852 of file dcmio.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(filename==NULL || strnlen(filename, 10)<1 || dcm==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  if(verbose>1) {printf("%s('%s')\n", __func__, filename); fflush(stdout);}
 
  /* Check for the data */
  if(dcm->item==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  /* Check whether we currently support the Transfer UID */
  if(dcm->truid!=DCM_TRUID_LEE) { // Little endian explicit
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNSUPPORTED);
    return TPCERROR_UNSUPPORTED;
  }
 
 
  /* Open the file */
  if(verbose>1) printf("opening the file for writing\n");
  FILE *fp;
  fp=fopen(filename, "wb");
  if(fp==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
 
  /* 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); statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
      return TPCERROR_CANNOT_WRITE;
    }
  }
 
 
  /* 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)!=TPCERROR_OK) {ret=1; break;}
      /* Write VR and VL */
      if(dcmWriteFileVRVL(fp, iptr->vr, iptr->vl, NULL)!=TPCERROR_OK) {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)!=TPCERROR_OK) {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)!=TPCERROR_OK) {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)!=TPCERROR_OK) {ret=14; break;}
          d2il+=4;
          /* Write VR and VL */
          unsigned int s;
          if(dcmWriteFileVRVL(fp, iptr->vr, iptr->vl, &s)!=TPCERROR_OK) {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)!=TPCERROR_OK) {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)!=TPCERROR_OK) {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)!=TPCERROR_OK) {ret=34; break;}
              d3il+=4; d2il+=4;
              /* Write VR and VL */
              unsigned int s;
              if(dcmWriteFileVRVL(fp, iptr->vr, iptr->vl, &s)!=TPCERROR_OK) {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)!=TPCERROR_OK) {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(!endianLittle()) 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)!=TPCERROR_OK) {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(!endianLittle()) 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)!=TPCERROR_OK) {ret=21; break;}
 
    }
 
    d1=d1->next_item;
  } // next
  if(ret!=0) {
    if(verbose>0) fprintf(stderr, "  ret := %d\n", ret);
    fclose(fp);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
 
 
  fclose(fp);
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by imgWriteDICOM().

dcmFindDownTag()

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

Search for specified tag in DCMITEM data tree, but only downward.

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 428 of file dcmdata.c.

  {
  if(d==NULL || tag==NULL) return(NULL);
  if(verbose>0) printf("%s((%04X,%04X),%d)\n", __func__, tag->group, tag->element, omit);
  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=dcmFindDownTag(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 */
  if(iptr!=NULL) return(iptr);
  /* Stop anyway */
  return(NULL);
}

Referenced by dcmFindDownTag(), dcmFindTag(), dcmImgIsotope(), dcmImgPos(), dcmImgPxlsize(), dcmMListRead(), and imgReadDICOM().

dcmFindTag()

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

Search for specified tag in DCMITEM data tree, from left to right, down and up.

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 375 of file dcmdata.c.

  {
  if(d==NULL || tag==NULL) return(NULL);
  if(verbose>0) printf("%s((%04X,%04X),%d)\n", __func__, tag->group, tag->element, omit);
  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=dcmFindDownTag(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 */
  if(iptr!=NULL) return(iptr);
  /* Stop if we do not have parent */
  if(d->parent_item==NULL) return(NULL);
  /* Search from the parent, but not including the parent */
  if(verbose>2) printf("  going to search the parents sister...\n");
  return(dcmFindTag(d->parent_item, 1, tag, verbose));
 
#if(0)
  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));
#endif
}

Referenced by dcmFileList(), dcmFindTag(), dcmImgDim(), dcmImgIsotope(), dcmImgOrient(), dcmImgPos(), dcmImgPxlsize(), dcmMListRead(), dcmSameImage(), dcmTagIntRange(), and imgReadDICOM().

dcmImgDim()

int dcmImgDim	(	DCMFILE *	d,
		unsigned short int *	imgdim,
		const int	verbose )

Get DICOM image dimensions.

See also

dcmImgOrient, dcmImgPxlsize

Returns

0 if successful, otherwise >0.

Parameters

d	Pointer to DCMFILE.
imgdim	Pointer to imgdim array of x, y, z, and frame numbers, to be filled here.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 232 of file dcmimage.c.

  {
  if(verbose>0) {printf("%s(dcmfile, imgdim)\n", __func__); fflush(stdout);}
  if(d==NULL || d->item==NULL || imgdim==NULL) return(1);
  for(int i=0; i<4; i++) imgdim[i]=0;
 
  DCMTAG tag; DCMITEM *iptr;
 
  /* Get image row number (dimy) */
  dcmTagSet(&tag, 0x0028, 0x0010);
  iptr=dcmFindTag(d->item, 0, &tag, 0);
  if(iptr==NULL) {
    if(verbose>0) {fprintf(stderr, "Error: cannot find matrix row number.\n"); fflush(stderr);}
    return(11);
  }
  imgdim[1]=(unsigned short int)dcmitemGetInt(iptr);
 
  /* Get image column number (dimx) */
  dcmTagSet(&tag, 0x0028, 0x0011);
  iptr=dcmFindTag(d->item, 0, &tag, 0);
  if(iptr==NULL) {
    if(verbose>0) {fprintf(stderr, "Error: cannot find matrix column number.\n"); fflush(stderr);}
    return(21);
  }
  imgdim[0]=(unsigned short int)dcmitemGetInt(iptr);
 
  /* Get image plane/slice number (dimz) */
  int a, b;
  if(verbose>1) {printf("trying to read plane number as 'Number of Slices'\n"); fflush(stdout);}
  dcmTagSet(&tag, 0x0054, 0x0081);
  iptr=dcmFindTag(d->item, 0, &tag, 0);
  if(iptr!=NULL) {
    imgdim[2]=(unsigned short int)dcmitemGetInt(iptr);
    if(verbose>2) printf("planeNr := %u\n", imgdim[2]); 
  } else {
    if(verbose>1) {printf("trying to read plane number from 'In Stack Position Number'\n"); fflush(stdout);}
    dcmTagSet(&tag, 0x0020, 0x9057);
    if(dcmTagIntRange(d->item, &tag, &a, &b, verbose-100)==0) {
      imgdim[2]=(unsigned short int)b; 
      if(verbose>2) printf("planeNr := %u\n", imgdim[2]); 
    } else {
      if(verbose>1) {printf("trying to read plane number from 'Dimension Index Values'\n"); fflush(stdout);}
      dcmTagSet(&tag, 0x0020, 0x9157);
      if(dcmTagIntRange(d->item, &tag, &a, &b, verbose-1)==0) {
        imgdim[2]=(unsigned short int)b; 
        if(verbose>2) printf("planeNr := %u\n", imgdim[2]); 
      } else {
        if(verbose>0) {fprintf(stderr, "Warning: cannot find plane number.\n"); fflush(stderr);}
        imgdim[2]=1;
      }
    }
  }
 
 
  /* Get frame number */
  if(verbose>1) {printf("trying to get frame number from 'Temporal position index'\n"); fflush(stdout);}
  dcmTagSet(&tag, 0x0020, 0x9128);
  if(dcmTagIntRange(d->item, &tag, &a, &b, verbose-100)==0) {
    imgdim[3]=(unsigned short int)b; 
    if(verbose>2) printf("frameNr := %u\n", imgdim[3]); 
  } else {
    if(verbose>1) {printf("trying to get frame number from 'Number of Time Slices'\n"); fflush(stdout);}
    dcmTagSet(&tag, 0x0054, 0x0101);
    iptr=dcmFindTag(d->item, 0, &tag, 0);
    if(iptr!=NULL) {
      imgdim[3]=(unsigned short int)dcmitemGetInt(iptr);
      if(verbose>2) printf("frameNr := %u\n", imgdim[3]);
    } else {
      if(verbose>0) {fprintf(stderr, "Warning: cannot find frame number.\n"); fflush(stderr);}
      imgdim[3]=1;
    }
  }
 
  return(0);
}

Referenced by imgReadDICOM().

dcmImgIsotope()

int dcmImgIsotope	(	DCMFILE *	d,
		isotope *	isot,
		decaycorrection *	dc,
		const int	verbose )

Get isotope and status of decaycorrection from DICOM.

See also

isotopeName, lambdaFromIsotope, decayCorrectionFactorFromisotope,

Returns

0 if successful, otherwise >0.

Parameters

d	Pointer to DCMFILE.
isot	Pointer to isotope code, to be set here; enter NULL if not needed.
dc	Pointer to status of decaycorrection.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 24 of file dcmimage.c.

  {
  if(verbose>0) {printf("%s(dcmfile, *isotope, *decaycorrection)\n", __func__); fflush(stdout);}
  if(isot!=NULL) *isot=ISOTOPE_UNKNOWN;
  if(dc!=NULL) *dc=DECAY_UNKNOWN;
  if(d==NULL || d->item==NULL) return(1);
 
 
  DCMTAG tag; DCMITEM *iptr, *jptr;
 
  /* Get the status of decay correction */
  if(dc!=NULL) {
    if(verbose>1) {printf("trying to find 'Decay Correction' tag\n"); fflush(stdout);}
    dcmTagSet(&tag, 0x0054, 0x1102); iptr=dcmFindTag(d->item, 0, &tag, 0);
    if(iptr!=NULL) {
      char *buf=dcmValueString(iptr); 
      if(verbose>12) printf("Decay Correction := '%s'\n", buf);
      if(strcasestr(buf, "NONE")!=NULL) *dc=DECAY_NOTCORRECTED;
      else if(strcasestr(buf, "START")!=NULL) *dc=DECAY_CORRECTED_START;
      else if(strcasestr(buf, "ADMIN")!=NULL) *dc=DECAY_CORRECTED_ADMIN;
      free(buf);
    } else {
      if(verbose>1) {printf("  not found\ntrying to find 'Decay Corrected' tag\n"); fflush(stdout);}
      dcmTagSet(&tag, 0x0018, 0x9758); iptr=dcmFindTag(d->item, 0, &tag, 0);
      if(iptr!=NULL) {
        char *buf=dcmValueString(iptr); 
        if(verbose>12) printf("Decay Correction := '%s'\n", buf);
        if(strcasestr(buf, "YES")!=NULL) *dc=DECAY_CORRECTED;
        else if(strcasestr(buf, "NO")!=NULL) *dc=DECAY_NOTCORRECTED;
        free(buf);
      } else if(verbose>1) {printf("  not found.\n"); fflush(stdout);}
    }
    if(verbose>0 && *dc==DECAY_UNKNOWN) {
      fprintf(stderr, "Warning: status of decay correction not found.\n");
      fflush(stdout);
    }
    if(verbose>11) printf("decayCorrection := %s\n", decayDescr(*dc));
  }
 
  if(isot==NULL) return(0);
 
  /* Get the radioisotope */
  if(verbose>1) {printf("trying to find Radiopharmaceutical Information Sequence\n"); fflush(stdout);}
  dcmTagSet(&tag, 0x0054, 0x0016); iptr=dcmFindTag(d->item, 0, &tag, 0);
  if(iptr!=NULL) {
    if(verbose>1) {printf("  found.\n"); fflush(stdout);}
    iptr=iptr->child_item;
  } else {
    if(verbose>1) {printf("  not found.\n"); fflush(stdout);}
    iptr=d->item;
  }
  if(verbose>1) {printf("trying to find Radionuclide Code Sequence\n"); fflush(stdout);}
  dcmTagSet(&tag, 0x0054, 0x0300); jptr=dcmFindTag(iptr, 0, &tag, 0);
  if(jptr!=NULL) {
    if(verbose>1) {printf("  found.\n"); fflush(stdout);}
    if(verbose>1) {printf("trying to find Code Meaning\n"); fflush(stdout);}
    dcmTagSet(&tag, 0x0008, 0x0104); jptr=dcmFindDownTag(jptr, 0, &tag, 0);
    if(jptr!=NULL) {
      char *buf=dcmValueString(jptr); 
      if(verbose>12) {printf("Code Meaning := '%s'\n", buf); fflush(stdout);}
      *isot=isotopeIdentify(buf);
      free(buf);
      if(verbose>11) {printf("isotope := %s\n", isotopeName(*isot)); fflush(stdout);}
    } else if(verbose>1) {printf("  not found.\n"); fflush(stdout);}
  } else {
    if(verbose>1) {printf("  not found.\n"); fflush(stdout);}
  }
  if(*isot==ISOTOPE_UNKNOWN) {
    if(verbose>1) {printf("trying to find Radionuclide Half Life\n"); fflush(stdout);}
    dcmTagSet(&tag, 0x0018, 0x1075); jptr=dcmFindTag(iptr, 0, &tag, 0);
    if(jptr!=NULL) {
      char *buf=dcmValueString(jptr); strCleanSpaces(buf);
      if(verbose>12) {printf("Radionuclide Half Life := '%s'\n", buf); fflush(stdout);}
      double hl=atofVerified(buf);
      *isot=isotopeIdentifyHalflife(hl/60.0);
      free(buf);
      if(verbose>11) {printf("isotope := %s\n", isotopeName(*isot)); fflush(stdout);}
    } else if(verbose>1) {printf("  not found.\n"); fflush(stdout);}
  }
 
  return(0);
}

Referenced by imgReadDICOM().

dcmImgOrient()

int dcmImgOrient	(	DCMFILE *	d,
		double *	iop,
		const int	verbose )

Get DICOM image orientation (Patient).

See also

dcmImgPos, dcmImgDim, dcmImgPxlsize, dcmImgXform, dcmXformToQuatern

Returns

0 if successful, otherwise >0.

Parameters

d	Pointer to DCMFILE.
iop	Pointer to iop array of six values, to be filled here.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 387 of file dcmimage.c.

  {
  if(verbose>0) {printf("%s(dcmfile, iop)\n", __func__); fflush(stdout);}
  if(d==NULL || d->item==NULL || iop==NULL) return(1);
  for(int i=0; i<6; i++) iop[i]=nan("");
 
  DCMTAG tag; DCMITEM *iptr;
 
  if(verbose>1) {printf("reading Image Orientation (Patient)\n"); fflush(stdout);}
  dcmTagSet(&tag, 0x0020, 0x0037);
  iptr=dcmFindTag(d->item, 0, &tag, 0);
  if(iptr==NULL) {
    if(verbose>0) {fprintf(stderr, "Error: no Image Orientation (Patient)\n"); fflush(stderr);}
    return(11);
  }
  char *buf=dcmValueString(iptr);
  if(verbose>2) printf("  image_orientation := '%s'\n", buf);
  int n=sscanf(buf, "%lf\\%lf\\%lf\\%lf\\%lf\\%lf", &iop[0], &iop[1], &iop[2], 
                                                    &iop[3], &iop[4], &iop[5]);
  free(buf);
  if(n!=6) {
    if(verbose>0) {fprintf(stderr, "Error: invalid Image Orientation (Patient)\n"); fflush(stderr);}
    return(12);
  }
 
  return(0);
}

Referenced by imgReadDICOM().

dcmImgPos()

int dcmImgPos	(	DCMFILE *	d,
		double *	imgpos,
		const int	verbose )

Get DICOM Image Position (Patient).

See also

dcmImgOrient, dcmImgDim, dcmImgPxlsize, dcmImgXform, dcmXformToQuatern

Returns

0 if successful, otherwise >0.

Parameters

d	Pointer to DCMFILE.
imgpos	Pointer to imgpos array of x, y, and z coordinates of the upper left hand corner (centre of the first voxel) of the image, in mm, to be filled here.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 121 of file dcmimage.c.

  {
  if(verbose>0) {printf("%s(dcmfile, imgpos)\n", __func__); fflush(stdout);}
  if(d==NULL || d->item==NULL || imgpos==NULL) return(1);
  for(int i=0; i<3; i++) imgpos[i]=nan("");
 
  DCMTAG tag; DCMITEM *iptr, *jptr;
 
  if(verbose>1) {printf("trying to find Per Frame Functional Groups Sequence\n"); fflush(stdout);}
  dcmTagSet(&tag, 0x5200, 0x9230); // Per Frame Functional Groups Sequence
  iptr=dcmFindTag(d->item, 0, &tag, 0);
  if(iptr!=NULL) {
    if(verbose>1) {printf("  found.\n"); fflush(stdout);}
 
    /* search for Frame Content Sequences until we find one with position number 1 */
    int posnr=0; dcmTagSet(&tag, 0x0020, 0x9111);
    jptr=dcmFindDownTag(iptr->child_item, 0, &tag, 0);
    while(jptr!=NULL) {
      /* Get In Stack Position Number */
      DCMITEM *kptr; DCMTAG spostag; dcmTagSet(&spostag, 0x0020, 0x9057);
      kptr=dcmFindDownTag(jptr->child_item, 0, &spostag, 0);
      if(kptr!=NULL) {
        posnr=dcmitemGetInt(kptr); if(verbose>3) printf("  posnr=%d\n", posnr);
        if(posnr==1) break; // found stack position number 1
      }
      jptr=dcmFindDownTag(jptr->next_item, 0, &tag, 0);
    }
    /* If stack position 1 was found, then get plane position sequence */
    if(posnr==1 && jptr!=NULL) {
      dcmTagSet(&tag, 0x0020, 0x9113);
      jptr=dcmFindDownTag(jptr->next_item, 0, &tag, 0);
      if(jptr!=NULL) {
        /* Get Image Position (Patient) under it */
        DCMITEM *kptr; DCMTAG ipostag; dcmTagSet(&ipostag, 0x0020, 0x0032);
        kptr=dcmFindDownTag(jptr->child_item, 0, &ipostag, 0);
        if(kptr!=NULL) {
          char *buf=dcmValueString(kptr);
          if(verbose>4) printf("  image_position := '%s'\n", buf);
          int n=sscanf(buf, "%lf\\%lf\\%lf", &imgpos[0], &imgpos[1], &imgpos[2]);
          free(buf);
          if(n!=3) {
            if(verbose>0) fprintf(stderr, "Error: invalid Image Position (Patient)\n");
            return(131);
          }
        } else {
          if(verbose>0) fprintf(stderr, "Error: no Image Position (Patient)\n");
          return(121);
        }
      } else {
        if(verbose>0) fprintf(stderr, "Error: no Plane Position Sequence\n");
        return(111);
      }
    } else {
      if(verbose>0) {fprintf(stderr, "Error: stack position 1 not found.\n"); fflush(stderr);}
      return(101);
    }
    return(0);
  }
  if(verbose>1) {printf("  not found.\n"); fflush(stdout);}
 
  if(verbose>1) {printf("find the smallest Instance (image) Number\n"); fflush(stdout);}
  dcmTagSet(&tag, 0x0020, 0x0013);
  iptr=dcmFindTag(d->item, 0, &tag, 0);
  if(iptr==NULL) {
    if(verbose>0) {fprintf(stderr, "Error: Instance (image) Number not found.\n"); fflush(stderr);}
    return(201);
  }
  int mininr=dcmitemGetInt(iptr); if(verbose>5) printf("  inr=%d\n", mininr);
  jptr=iptr;
  while(jptr!=NULL) {
    jptr=dcmFindDownTag(jptr->next_item, 0, &tag, 0);
    if(jptr==NULL) break;
    int inr=dcmitemGetInt(jptr); if(verbose>5) printf("  inr=%d\n", inr);
    if(inr<mininr) {mininr=inr; iptr=jptr;}
  }
  if(verbose>2) {printf("  smallest Instance (image) Number: %d\n", mininr); fflush(stdout);}
 
  /* Get Image Position (Patient) after the smallest Instance Number */
  dcmTagSet(&tag, 0x0020, 0x0032);
  jptr=dcmFindDownTag(iptr, 0, &tag, 0);
  if(jptr==NULL) {
    if(verbose>0) fprintf(stderr, "Error: no Image Position (Patient)\n");
    return(211);
  } else {
    char *buf=dcmValueString(jptr);
    if(verbose>2) printf("  image_position := '%s'\n", buf);
    int n=sscanf(buf, "%lf\\%lf\\%lf", &imgpos[0], &imgpos[1], &imgpos[2]);
    free(buf);
    if(n!=3) {
      if(verbose>0) fprintf(stderr, "Error: invalid Image Position (Patient)\n");
      return(212);
    }
  }
 
  return(0);
}

Referenced by imgReadDICOM().

dcmImgPxlsize()

int dcmImgPxlsize	(	DCMFILE *	d,
		double *	pxlsize,
		const int	verbose )

Get DICOM Image voxel size.

See also

dcmImgDim, dcmImgOrient

Returns

0 if successful, otherwise >0.

Parameters

d	Pointer to DCMFILE.
pxlsize	Pointer to pxlsize array of x, y, and z sizes of image pixel, or actually, mm distance between neighbour voxel centres in x, y, and z directions.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 320 of file dcmimage.c.

  {
  if(verbose>0) {printf("%s(dcmfile, pxlsize)\n", __func__); fflush(stdout);}
  if(d==NULL || d->item==NULL || pxlsize==NULL) return(1);
  for(int i=0; i<3; i++) pxlsize[i]=nan("");
 
  DCMTAG tag; DCMITEM *iptr, *jptr, *kptr;
 
  if(verbose>1) {printf("trying to find Pixel Measures Sequence\n"); fflush(stdout);}
  dcmTagSet(&tag, 0x0028, 0x9110);
  iptr=dcmFindTag(d->item, 0, &tag, 0);
  if(iptr==NULL) {
    kptr=d->item; // search from root
    if(verbose>3) {fprintf(stdout, "Note: missing Pixel Measures Sequence.\n"); fflush(stdout);}
  } else {
    kptr=iptr->child_item; // search under this sequence
  }
  dcmTagSet(&tag, 0x0018, 0x0050);
  jptr=dcmFindDownTag(kptr, 0, &tag, 0);
  if(jptr==NULL) {
    if(verbose>0) {fprintf(stderr, "Error: missing Slice Thickness.\n"); fflush(stderr);}
    return(11);
  }
  pxlsize[2]=dcmitemGetReal(jptr);
 
  if(verbose>1) {printf("trying to find Spacing Between Slices\n"); fflush(stdout);}
  dcmTagSet(&tag, 0x0018, 0x0088);
  jptr=dcmFindDownTag(kptr, 0, &tag, 0);
  if(jptr==NULL) {
    if(verbose>1) {fprintf(stderr, "Warning: missing Spacing Between Slices.\n"); fflush(stderr);}
  } else {
    double v=dcmitemGetReal(jptr);
    if(v>pxlsize[2]) pxlsize[2]=v;
  }
 
  if(verbose>1) {printf("trying to find Pixel Spacing/Size\n"); fflush(stdout);}
  dcmTagSet(&tag, 0x0028, 0x0030);
  jptr=dcmFindDownTag(kptr, 0, &tag, 0);
  if(jptr==NULL) {
    if(verbose>0) {fprintf(stderr, "Error: missing Pixel Spacing/Size.\n"); fflush(stderr);}
    return(21);
  }
  char *buf=dcmValueString(jptr);
  int n=sscanf(buf, "%lf\\%lf", &pxlsize[1], &pxlsize[0]);
  free(buf);
  if(n!=2) {
    if(verbose>0) {fprintf(stderr, "Error: invalid Pixel Spacing/Size\n"); fflush(stderr);}
    return(22);
  }
 
  return(0);
}

Referenced by imgReadDICOM().

dcmImgXform()

int dcmImgXform	(	double *	iop,
		double *	xyzMM,
		double *	imgPos,
		double *	xform,
		const int	verbose )

Calculate xform matrix from DICOM header information.

Based on dcm2niix xform_mat(), which is based on dicm2nii. Last vector xform[3][0..4] is not yet computed.

See also

dcmImgOrient, dcmImgPxlsize, dcmImgPos, dcmImgDim

Returns

0 if successful, otherwise >0.

Parameters

iop	Array of 6 Image Orientation (Patient) parameters.
xyzMM	Array of 3 voxel sizes in mm (x, y, z).
imgPos	Array of 3 Image Position (Patient) parameters.
xform	Pointer to xform 4x4 matrix stored as an array of 16 doubles, to be filled here.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 431 of file dcmimage.c.

  {
  if(verbose>0) {printf("%s(iop[], xyzMM[], imgPos[], xform)\n", __func__); fflush(stdout);}
  if(iop==NULL || xyzMM==NULL || imgPos==NULL || xform==NULL) return(1);
  for(int i=0; i<16; i++) xform[i]=nan("");
 
 
  double readV[3], phaseV[3];
  readV[0]=iop[0]; readV[1]=iop[1]; readV[2]=iop[2];
  phaseV[0]=iop[3]; phaseV[1]=iop[4]; phaseV[2]=iop[5];
  if(verbose>3) {
    printf("readV := %g", readV[0]); for(int i=1; i<3; i++) printf(", %g", readV[i]);
    printf("\n");
    printf("phaseV := %g", phaseV[0]); for(int i=1; i<3; i++) printf(", %g", phaseV[i]);
    printf("\n");
  }
 
  /* Cross-product of vectors */
  double sliceV[3];
  sliceV[0]= readV[1]*phaseV[2] - phaseV[1]*readV[2];
  sliceV[1]=-readV[0]*phaseV[2] + phaseV[0]*readV[2];
  sliceV[2]= readV[0]*phaseV[1] - phaseV[0]*readV[1];
  if(verbose>3) {
    printf("sliceV := %g", sliceV[0]); for(int i=1; i<3; i++) printf(", %g", sliceV[i]); 
    printf("\n");
  }
 
  /* Copy vectors into a 3x3 matrix */
  double rM[3][3];
  for(int i=0; i<3; i++) rM[0][i]=readV[i];
  for(int i=0; i<3; i++) rM[1][i]=phaseV[i];
  for(int i=0; i<3; i++) rM[2][i]=sliceV[i];
  /* Transpose the matrix */
  {
    double tM[3][3];
    for(int i=0; i<3; i++) for(int j=0; j<3; j++) tM[i][j]=rM[i][j];
    for(int i=0; i<3; i++) for(int j=0; j<3; j++) rM[i][j]=tM[j][i];
  }
  if(verbose>3) {
    printf("rM :=\t%g", rM[0][0]); 
    for(int i=1; i<3; i++) printf("\t%g", rM[0][i]);
    printf("\n");
    for(int i=0; i<3; i++) printf("\t%g", rM[1][i]);
    printf("\n");
    for(int i=0; i<3; i++) printf("\t%g", rM[2][i]);
    printf("\n");
  }
  /* Max (left-over) indices */
  unsigned short int xyz[3];
  xyz[0]=0; 
  if(fabs(rM[1][0])>fabs(rM[0][0]) && fabs(rM[1][0])>fabs(rM[2][0])) xyz[0]=1;
  else if(fabs(rM[2][0])>fabs(rM[0][0]) && fabs(rM[1][0])>fabs(rM[1][0])) xyz[0]=2;
  if(xyz[0]==0)      {if(fabs(rM[2][1])>fabs(rM[1][1])) xyz[1]=2; else xyz[1]=1;}
  else if(xyz[0]==1) {if(fabs(rM[2][1])>fabs(rM[0][1])) xyz[1]=2; else xyz[1]=0;}
  else               {if(fabs(rM[1][1])>fabs(rM[0][1])) xyz[1]=1; else xyz[1]=0;}
  xyz[2]=3-xyz[0]-xyz[1];
  if(verbose>3) {
    printf("xyz := %u", xyz[0]); for(int i=1; i<3; i++) printf(", %u", xyz[i]); 
    printf("\n(0, 1, 2 for Sag/Cor/Tra slice)\n");
  }
  double cosSL=rM[xyz[2]][2];
  if(verbose>3) {printf("cosSL := %g\n", cosSL); fflush(stdout);}
 
  /* Multiply matrix with voxel sizes */
  if(verbose>3) {
    printf("xyzMM := %g", xyzMM[0]); for(int i=1; i<3; i++) printf(", %g", xyzMM[i]);
    printf("\n");
  }
  {
    double tM[3][3], sM[3][3];
    for(int i=0; i<3; i++) for(int j=0; j<3; j++) tM[i][j]=rM[i][j];
    for(int i=0; i<3; i++) for(int j=0; j<3; j++) sM[i][j]=0.0;
    sM[0][0]=xyzMM[0]; sM[1][1]=xyzMM[1]; sM[2][2]=xyzMM[2];
    for(int i=0; i<3; i++)
      for(int j=0; j<3; j++)
        rM[i][j]= tM[i][0]*sM[0][j] + tM[i][1]*sM[1][j] + tM[i][2]*sM[2][j];
  }
 
  /* Fill most part of xform */
  for(int i=0; i<3; i++)
    for(int j=0; j<3; j++)
      xform[j+4*i]=rM[i][j];
  for(int i=0; i<3; i++)
    xform[3+4*i]=imgPos[i];
 
  /* Slice normalization vector not yet done */
 
  return(0);
}

Referenced by imgReadDICOM().

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 39 of file dcmdata.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 295 of file dcmdata.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(!endianLittle()) 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(!endianLittle()) 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(!endianLittle()) 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(!endianLittle()) swap(&i, &i, 2);
    li=(long int)i;
  } else if(d->vr==DCM_VR_IS) { // integer string
    li=atol(d->rd);
  }
  return(li);
}

Referenced by dcmImgDim(), dcmImgPos(), dcmMListRead(), dcmSameImage(), dcmTagIntRange(), and imgReadDICOM().

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 331 of file dcmdata.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(!endianLittle()) 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(!endianLittle()) 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(!endianLittle()) 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(!endianLittle()) 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(!endianLittle()) 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(!endianLittle()) swap(&i, &i, 2);
    r=(double)i;
  } else if(d->vr==DCM_VR_IS) { // integer string
    r=(double)atol(d->rd);
  }
  return(r);
}

Referenced by dcmImgPxlsize(), dcmMListRead(), and imgReadDICOM().

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 83 of file dcmdata.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 122 of file dcmdata.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 467 of file dcmdata.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(), dcmFileWrite(), dcmMListRead(), and imgReadDICOM().

dcmmatrixFree()

void dcmmatrixFree

(

DCMMATRIX *

m

)

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

Precondition

Before first use initialize the struct with dcmmatrixInit().

See also

dcmmatrixInit

Author

Vesa Oikonen

Parameters

m	Pointer to DCMMATRIX.

Definition at line 40 of file dcmmatrix.c.

  {
  if(m==NULL) return;
  if(m->filename!=NULL) free(m->filename);
  dcmmatrixInit(m);
}

Referenced by dcmmlFree().

dcmmatrixInit()

void dcmmatrixInit

(

DCMMATRIX *

m

)

Initiate the DCMMATRIX struct before any use.

See also

dcmmatrixFree

Parameters

m	Pointer to DCMMATRIX.

Definition at line 22 of file dcmmatrix.c.

  {
  if(m==NULL) return;
  m->filename=NULL;
  m->acqDate[0]=m->acqTime[0]=(char)0;
  m->frame=m->plane=0;
  m->frameStart=m->frameDur=0.0;
}

Referenced by dcmmatrixFree(), and dcmmlAllocate().

dcmmlAllocate()

int dcmmlAllocate	(	DCMML *	d,
		int	mNr )

Allocate more memory for DCMML data. Previous contents are preserved.

Returns

Returns TPCERROR status.

See also

dcmmlInit, dcmmlFree

Parameters

d	Pointer to initiated and possibly previously allocated DCMML struct data; any old contens are preserved.
mNr	Nr of additional matrices to allocate; if struct contains unused space for requested number already, then nothing is done.

Definition at line 89 of file dcmmatrix.c.

  {
  if(d==NULL) return TPCERROR_FAIL;
  /* Check if there is enough space already */
  unsigned int newNr, addNr;
  newNr=d->nr+mNr; 
  if(d->anr>=newNr) return TPCERROR_OK;
  addNr=newNr-d->anr;
 
  /* (Re)allocate memory. */
  DCMMATRIX *mptr;
  mptr=(DCMMATRIX*)realloc(d->m, sizeof(DCMMATRIX)*newNr);
  if(mptr==NULL) return TPCERROR_OUT_OF_MEMORY;
  d->m=mptr;
  mptr=d->m+d->anr; for(unsigned int i=0; i<addNr; i++) dcmmatrixInit(mptr++);
  d->anr=newNr;
  return TPCERROR_OK;
}

Referenced by dcmMListRead().

dcmmlFree()

void dcmmlFree

(

DCMML *

d

)

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

Precondition

Before first use initialize the struct with dcmmlInit().

See also

dcmmlInit

Author

Vesa Oikonen

Parameters

d	Pointer to DCMML.

Definition at line 70 of file dcmmatrix.c.

  {
  if(d==NULL) return;
  if(d->m!=NULL) {
    for(unsigned int i=0; i<d->anr; i++) dcmmatrixFree(d->m+i);
    free(d->m);
  }
  dcmmlInit(d);
}

Referenced by dcmMListRead().

dcmmlInit()

void dcmmlInit

(

DCMML *

d

)

Initiate the DCMML struct before any use.

See also

dcmmlFree

Parameters

d	Pointer to DCMMLIST.

Definition at line 54 of file dcmmatrix.c.

  {
  if(d==NULL) return;
  d->nr=d->anr=0;
  d->m=(DCMMATRIX*)NULL;
}

Referenced by dcmmlFree().

dcmMListRead()

int dcmMListRead	(	IFT *	ift,
		DCMML *	ml,
		TPCSTATUS *	status )

Read DICOM image matrix list.

See also

dcmFileList, dcmmlInit

Returns

Code tpcerror, TPCERROR_OK (0) when successful.

Parameters

ift	Pointer to IFT structure containing file names constituting a DICOM image.
ml	Pointer to initiated DICOM matrix list.
status	Pointer to status data; enter NULL if not needed.

Definition at line 120 of file dcmmatrix.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>1) printf("%s()\n", __func__);
  if(ift==NULL || ml==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  if(ift->keyNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  /* Delete any previous data */
  dcmmlFree(ml);
 
  /* 
   *  Read the first file in list
   */
  int fi=0, ret=TPCERROR_OK;
  DCMFILE dcm; dcmfileInit(&dcm);
  ret=dcmFileRead(ift->item[fi].value, &dcm, 1, status);
  if(ret!=TPCERROR_OK) {dcmfileFree(&dcm); return(ret);}
 
  /* Read some information common to the whole image */
  DCMTAG tag;
  DCMITEM *iptr;
 
  /* Get and check the Image Type */
  int dynamic=0; // 0=no, 1=yes
  tag.group=0x0008; tag.element=0x0008;
  iptr=dcmFindTag(dcm.item, 0, &tag, 0);
  if(iptr==NULL) {
    ret=TPCERROR_NO_KEY; statusSet(status, __func__, __FILE__, __LINE__, ret);
    dcmfileFree(&dcm); return(ret);
  }
  /* Check if dynamic; see DICOM 3.3 C.7.6.16.2.2.6
     https://dicom.nema.org/MEDICAL/dicom/current/output/chtml/part03/sect_C.7.6.16.2.html
   */
  {
    char *buf=dcmValueString(iptr); 
    if(verbose>2) printf("imageType := %s\n", buf); 
    if(strcasestr(buf, "DYNAMIC")!=NULL) dynamic=1; else dynamic=0;
    free(buf);
  }
  if(verbose>1) {printf("dynamic := %d\n", dynamic); fflush(stdout);}
 
  /* Check whether Per-frame Functional Groups Sequence is set */
  int multiframe=0; // 0=no, 1=yes
  tag.group=0x5200; tag.element=0x9230;
  iptr=dcmFindTag(dcm.item, 0, &tag, 0);
  if(iptr!=NULL) {
    if(verbose>1) fprintf(stderr, "Notice: Per-frame Functional Groups Sequence is available.\n");
    multiframe=1;
  }
 
 
  if(multiframe) {  /* Multi-frame file */
 
    /* Get the number of frames and planes */
    if(verbose>1) {printf("reading frame and slice number\n"); fflush(stdout);}
    unsigned short int frameNr=0;
    /* Get frame number from 'Temporal position index' */
    tag.group=0x0020; tag.element=0x9128;
    int a, b;
    if(dcmTagIntRange(dcm.item, &tag, &a, &b, verbose-100)==0) frameNr=b;
    if(verbose>1) printf("frameNr := %u\n", frameNr); 
    unsigned short int sliceNr=0;
    /* Get plane number from 'In Stack Position Number' */
    tag.group=0x0020; tag.element=0x9057;
    if(dcmTagIntRange(dcm.item, &tag, &a, &b, verbose-100)==0) sliceNr=b;
    else {
      /* Get plane number from 'Dimension Index Values' */
      tag.group=0x0020; tag.element=0x9157;
      if(dcmTagIntRange(dcm.item, &tag, &a, &b, verbose-1)==0) sliceNr=b;
    }
    if(verbose>1) printf("sliceNr := %u\n", sliceNr); 
    if(frameNr<=0 || sliceNr<=0) {
      if(verbose>0) fprintf(stderr, "Error: cannot find frame/slice number.\n");
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_KEY);
      dcmfileFree(&dcm); return(TPCERROR_NO_KEY);
    }
 
    /* Get Decay Correction */
    short unsigned int decayCorrection=0; // 0=NO, 1=YES
    tag.group=0x0018; tag.element=0x9758;
    iptr=dcmFindTag(dcm.item, 0, &tag, 0);
    if(iptr!=NULL) {
      char *buf=dcmValueString(iptr); 
      if(verbose>2) printf("Decay Correction := '%s'\n", buf);
      if(strcasestr(buf, "YES")!=NULL) decayCorrection=1;
      free(buf);
    }
    if(verbose>1) printf("decayCorrection := %d\n", decayCorrection);
 
    /* If decay is corrected, read time of decay correction; otherwise read start time */
    char zeroDateTime[32]; zeroDateTime[0]=(char)0;
    if(decayCorrection==0) {
      /* Get Acquisition DateTime */
      tag.group=0x0008; tag.element=0x002A;
      iptr=dcmFindTag(dcm.item, 0, &tag, 0);
      if(iptr!=NULL) dcmDT2intl(iptr->rd, zeroDateTime);
    } else {
      tag.group=0x0018; tag.element=0x9701;
      iptr=dcmFindTag(dcm.item, 0, &tag, 0);
      if(iptr!=NULL) dcmDT2intl(iptr->rd, zeroDateTime);
    }
    if(!zeroDateTime[0]) {
      if(verbose>0) fprintf(stderr, "Error: missing Acquisition Date and Time.\n");
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_KEY);
      dcmfileFree(&dcm); return(TPCERROR_NO_KEY);
    }
    if(verbose>4) printf("zeroDateTime := %s\n", zeroDateTime);
 
    /* Initially allocate for frameNr x sliceNr matrices */
    ret=dcmmlAllocate(ml, sliceNr*frameNr);
    if(ret!=TPCERROR_OK) {
      statusSet(status, __func__, __FILE__, __LINE__, ret);
      dcmfileFree(&dcm); return ret;
    }
 
    /*
     *  Get the information from one matrix at a time
     */
    /* Find Per Frame Functional Groups Sequence */
    tag.group=0x5200; tag.element=0x9230;
    iptr=dcmFindTag(dcm.item, 0, &tag, 0);
    if(iptr==NULL) {
      if(verbose>0) {
        fprintf(stderr, "Error: cannot find Per Frame Functional Groups Sequence.\n"); 
        fflush(stderr);
      }
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_KEY);
      dcmmlFree(ml); dcmfileFree(&dcm); return(TPCERROR_NO_KEY);
    }
    /* Loop through all Frame Content Sequences under it */
    tag.group=0x0020; tag.element=0x9111;
    DCMTAG tagstart; tagstart.group=0x0018; tagstart.element=0x9074;
    DCMTAG tagdur; tagdur.group=0x0018; tagdur.element=0x9220;
    DCMTAG tagfr; tagfr.group=0x0020; tagfr.element=0x9128;
    DCMITEM *fptr=iptr->child_item;
    while(fptr!=NULL) {
      /* Find Frame Content Sequence */
      iptr=dcmFindDownTag(fptr, 0, &tag, 0); if(iptr==NULL) break; // not an error!
      if(verbose>10) printf(" found Frame Content Sequence\n");
      /* Check that we have room */
      if(ml->nr>=ml->anr) {
        ret=dcmmlAllocate(ml, 100);
        if(ret!=TPCERROR_OK) break;
      }
      /* Set file name */
      ml->m[ml->nr].filename=strdup(ift->item[0].value);
      /* Find Temporal Position Index */
      DCMITEM *jptr;
      jptr=dcmFindDownTag(iptr->child_item, 0, &tagfr, 0);
      if(jptr==NULL) {
        if(verbose>0) {printf("cannot find Temporal Position Index.\n"); fflush(stdout);}
        ret=TPCERROR_NO_KEY; break;
      }
      if(verbose>20) dcmitemPrint(jptr);
      ml->m[ml->nr].frame=(unsigned int)dcmitemGetInt(jptr);
      //unsigned short int frameIndex=(unsigned short int)(dcmitemGetInt(jptr)-1);
      /* Find slice index */
      DCMTAG tagpl; tagpl.group=0x0020; tagpl.element=0x9057;
      jptr=dcmFindDownTag(iptr->child_item, 0, &tagpl, 0);
      if(jptr==NULL) {
        tagpl.group=0x0020; tagpl.element=0x9157;
        jptr=dcmFindDownTag(iptr->child_item, 0, &tagpl, 0);
      }
      if(jptr==NULL) {
        if(verbose>0) {printf("cannot find Slice Index.\n"); fflush(stdout);}
        ret=TPCERROR_NO_KEY; break;
      }
      if(verbose>20) dcmitemPrint(jptr);
      ml->m[ml->nr].plane=(unsigned int)dcmitemGetInt(jptr);
      /* Find Frame Acquisition DateTime */
      jptr=dcmFindDownTag(iptr->child_item, 0, &tagstart, 0);
      char facqDateTime[32]; facqDateTime[0]=(char)0;
      if(jptr!=NULL) dcmDT2intl(jptr->rd, facqDateTime);
      if(!facqDateTime[0]) {
        if(verbose>0) {printf("cannot find Frame Acquisition DateTime.\n"); fflush(stdout);}
        ret=TPCERROR_NO_KEY; break;
      }
      if(verbose>20) printf("facqDateTime := %s\n", facqDateTime);
      strlcpy(ml->m[ml->nr].acqDate, facqDateTime, 11);
      if(strlen(facqDateTime)>17) strlcpy(ml->m[ml->nr].acqTime, facqDateTime+11, 9);
      /* Calculate the Frame start time */
      ml->m[ml->nr].frameStart=strDateTimeDifference(facqDateTime, zeroDateTime);
      /* Find Frame Acquisition Duration */
      jptr=dcmFindDownTag(iptr->child_item, 0, &tagdur, 0);
      if(jptr!=NULL) ml->m[ml->nr].frameDur=0.001*dcmitemGetReal(jptr);
 
      /* prepare for the next matrix */
      fptr=iptr->next_item;
      ml->nr++;
    }
 
    dcmfileFree(&dcm);
    if(ret!=TPCERROR_OK) {
      statusSet(status, __func__, __FILE__, __LINE__, ret);
      dcmmlFree(ml); 
      return(ret);
    }
 
  } else {   /* Single-frame files */
 
    /* Get the number of frames (time slices) */
    unsigned short int frameNr=0;
    tag.group=0x0054; tag.element=0x0101;
    iptr=dcmFindTag(dcm.item, 0, &tag, 0);
    if(iptr!=NULL) { 
      frameNr=(unsigned short int)dcmitemGetInt(iptr);
    } else {
      if(dynamic!=0) { // error, if dynamic
        ret=TPCERROR_NO_KEY; statusSet(status, __func__, __FILE__, __LINE__, ret);
        dcmfileFree(&dcm); return(ret);
      } else { // assume 1, if static or whole-body
        frameNr=1;
      }
    }
    if(verbose>1) printf("frameNr := %u\n", frameNr); 
 
    /* Get the number of slices (needed to understand image index) */
    unsigned short int sliceNr=0;
    tag.group=0x0054; tag.element=0x0081;
    iptr=dcmFindTag(dcm.item, 0, &tag, 0);
    if(iptr==NULL) {
      ret=TPCERROR_NO_KEY; statusSet(status, __func__, __FILE__, __LINE__, ret);
      dcmfileFree(&dcm); return(ret);
    }
    sliceNr=(unsigned short int)dcmitemGetInt(iptr);
    if(verbose>1) printf("sliceNr := %u\n", sliceNr); 
 
    /* Get Decay correction type */
    short unsigned int decayCorrection=0; // 0=NONE, 1=START, 2=ADMIN
    tag.group=0x0054; tag.element=0x1102;
    iptr=dcmFindTag(dcm.item, 0, &tag, 0);
    if(iptr!=NULL) {
      char *buf=dcmValueString(iptr); 
      if(verbose>2) printf("Decay Correction := %s\n", buf);
      if(strcasecmp(buf, "NONE")==0) decayCorrection=0;
      else if(strcasecmp(buf, "START")==0) decayCorrection=1;
      else if(strcasecmp(buf, "ADMIN")==0) decayCorrection=2;
      free(buf);
    }
 
    /* If decay is corrected to tracer administration time, the we must read it */
    char injDateTime[32]; injDateTime[0]=(char)0;
    if(decayCorrection==2) {
      /* Get the Tracer Start DateTime */
      tag.group=0x0018; tag.element=0x1078;
      iptr=dcmFindTag(dcm.item, 0, &tag, 0);
      if(iptr!=NULL) {
        if(dcmDT2intl(iptr->rd, injDateTime)==NULL) iptr=NULL;
      }
      /* If not successful, the try other tags */
      if(iptr==NULL) {
        char s1[16], s2[16];
        /* Get the Tracer Start Time */
        tag.group=0x0018; tag.element=0x1072;
        iptr=dcmFindTag(dcm.item, 0, &tag, 0);
        if(iptr!=NULL) {
          /* Get the Series Date */
          tag.group=0x0008; tag.element=0x0021;
          DCMITEM *jptr=dcmFindTag(dcm.item, 0, &tag, 0);
          if(jptr!=NULL) {
            if(dcmDA2intl(jptr->rd, s1)!=NULL && dcmTM2intl(iptr->rd, s2)!=NULL)
              sprintf(injDateTime, "%s %s", s1, s2);
          }
        }
      }
      if(injDateTime[0] && verbose>3) printf("injection_time := %s\n", injDateTime); 
    }
 
    /* Get the Series DateTime
       https://dicom.nema.org/MEDICAL/dicom/current/output/chtml/part03/sect_C.8.9.html#figure_C.8.9.1.1.11-1a
     */
    char seriesDateTime[32]; seriesDateTime[0]=(char)0;
    tag.group=0x0008; tag.element=0x0021;
    iptr=dcmFindTag(dcm.item, 0, &tag, 0);
    if(iptr!=NULL) {
      tag.group=0x0008; tag.element=0x0031;
      DCMITEM *jptr=dcmFindTag(dcm.item, 0, &tag, 0);
      if(jptr!=NULL) {
        char s1[16], s2[16];
        if(dcmDA2intl(iptr->rd, s1)!=NULL && dcmTM2intl(jptr->rd, s2)!=NULL)
          sprintf(seriesDateTime, "%s %s", s1, s2);
      }
    }
    if(seriesDateTime[0] && verbose>3) printf("seriesDateTime := %s\n", seriesDateTime); 
 
 
    /* Initially allocate for frameNr x sliceNr matrices */
    ret=dcmmlAllocate(ml, sliceNr*frameNr);
    if(ret!=TPCERROR_OK) {
      statusSet(status, __func__, __FILE__, __LINE__, ret);
      dcmfileFree(&dcm); return ret;
    }
 
 
    /*
     *  Get the information from one file at a time
     */
    //char startDateTime[32]; startDateTime[0]=(char)0;
    //int fi=0, beds=0;
    do {
 
      /* Get the Image Index; DICOM PS3.3 C.8.9.4.1.9 */
      unsigned short int imageIndex=0;
      tag.group=0x0054; tag.element=0x1330;
      iptr=dcmFindTag(dcm.item, 0, &tag, 0);
      if(iptr==NULL) {ret=TPCERROR_NO_KEY; break;}
      imageIndex=(unsigned short int)dcmitemGetInt(iptr);
      /* Calculate the current frame and slice (index starting from 0) */
      unsigned short int frameIndex, sliceIndex; 
      {
        div_t meh=div(imageIndex-1, sliceNr);
        frameIndex=meh.quot; 
        sliceIndex=meh.rem; 
      }
      /* Set file name, plane, and frame into matrix list */
      if(ml->nr>=ml->anr) {
        ret=dcmmlAllocate(ml, 100);
        if(ret!=TPCERROR_OK) break;
      }
      ml->m[ml->nr].filename=strdup(ift->item[fi].value);
      ml->m[ml->nr].plane=1+sliceIndex;
      ml->m[ml->nr].frame=1+frameIndex;
 
      /* Get acquisition date and time */
      char acqDateTime[32]; acqDateTime[0]=(char)0;
      /* Try first Acquisition Datetime */
      tag.group=0x0008; tag.element=0x002A;
      iptr=dcmFindTag(dcm.item, 0, &tag, 0);
      if(iptr!=NULL) dcmDT2intl(iptr->rd, acqDateTime);
      /* If that did not work, try Acquisition Date and Time */
      if(!acqDateTime[0]) {
        tag.group=0x0008; tag.element=0x0022;
        iptr=dcmFindTag(dcm.item, 0, &tag, 0);
        if(iptr!=NULL) {
          tag.group=0x0008; tag.element=0x0032;
          DCMITEM *jptr=dcmFindTag(dcm.item, 0, &tag, 0);
          if(jptr!=NULL) {
            char s1[16], s2[16];
            if(dcmDA2intl(iptr->rd, s1)!=NULL && dcmTM2intl(jptr->rd, s2)!=NULL)
              sprintf(acqDateTime, "%s %s", s1, s2);
          }
        }
      }
      if(acqDateTime[0]) {
        strlcpy(ml->m[ml->nr].acqDate, acqDateTime, 11);
        if(strlen(acqDateTime)>17) strlcpy(ml->m[ml->nr].acqTime, acqDateTime+11, 9);
      }
 
      /* Calculate the Frame start time, if possible */
      if(acqDateTime[0]) {
        double t1=nan("");
        if(decayCorrection==2 && injDateTime[0]) {
          /* Injection time is the reference time */
          t1=strDateTimeDifference(acqDateTime, injDateTime);
          ml->m[ml->nr].frameStart=t1;
        } else if(seriesDateTime[0]) {
          /* Use series time, for now */
          t1=strDateTimeDifference(acqDateTime, seriesDateTime);
          ml->m[ml->nr].frameStart=t1;
        }
      }
 
      /* Get Actual Frame Duration */
      tag.group=0x0018; tag.element=0x1242;
      iptr=dcmFindTag(dcm.item, 0, &tag, 0);
      if(iptr!=NULL) ml->m[ml->nr].frameDur=0.001*dcmitemGetReal(iptr);
 
 
      /* Done with this file */
      ml->nr++;
      dcmfileFree(&dcm);
 
      /* Read the next file in list */
      fi++; if(fi>=ift->keyNr) {ret=TPCERROR_OK; break;}
      ret=dcmFileRead(ift->item[fi].value, &dcm, 1, status);
      if(ret!=TPCERROR_OK) break;
 
    } while(1);
    dcmfileFree(&dcm);
    if(ret!=TPCERROR_OK) {
      statusSet(status, __func__, __FILE__, __LINE__, ret);
      dcmmlFree(ml); 
      return(ret);
    }
  }
 
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

dcmmlSortByPlane()

int dcmmlSortByPlane	(	DCMML *	d,
		TPCSTATUS *	status )

Sort matrices in DCMML (DICOM matrix list) struct by plane (slice) number.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

Parameters

d	Pointer to DCMML struct
status	Pointer to status data; enter NULL if not needed

Definition at line 540 of file dcmmatrix.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
  /* Check that required data exists */
  if(d==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  if(d->nr<2) return TPCERROR_OK;
  qsort(d->m, d->nr, sizeof(DCMMATRIX), dcmmlQSortPlane);
  return TPCERROR_OK;
}

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 135 of file dcmio.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(!endianLittle()) { // 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 274 of file dcmio.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(!endianLittle()) swap(&si, &si, 2);
    vl=si;
  } else if(n==4) {
    unsigned int li;
    if(fread(&li, 4, 1, fp)!=1) return(vl);
    if(!endianLittle()) 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 237 of file dcmio.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

Code tpcerror, TPCERROR_OK (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 306 of file dcmio.c.

  {
  if(vr!=NULL) *vr=DCM_VR_INVALID;
  if(vl!=NULL) *vl=0;
  if(n!=NULL) *n=0;
  if(fp==NULL) return(TPCERROR_FAIL);
 
  /* Read the first two bytes */
  char buf[3];
  if(fread(&buf, 1, 2, fp)!=2) return(TPCERROR_CANNOT_READ); 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(TPCERROR_UNSUPPORTED);
 
  /* 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(TPCERROR_CANNOT_READ);
    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(TPCERROR_CANNOT_READ);
    if(!endianLittle()) swap(&si, &si, 2);
    lvl=si;
  } else {
    unsigned int li;
    if(fread(&li, 4, 1, fp)!=1) return(TPCERROR_CANNOT_READ);
    if(!endianLittle()) swap(&li, &li, 4);
    lvl=li;
  }
  if(n!=NULL) *n+=bsize;
  if(vl!=NULL) *vl=lvl;
 
  return(TPCERROR_OK);
}

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 73 of file dcmio.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)) {
    //printf("reading tag\n");
    if(dcmReadFileTag(fp, &tag)) break;
    //printf(" -> (%04x,%04x)\n", tag.group, tag.element);
    if(tag.group==0x0002 && tag.element==0x0010) {tag_found=1; break;}
    /* not the tag that we want, so just go through this item */
    //printf("reading vr etc\n");
    dcmvr vr=dcmReadFileVR(fp, NULL);
    //printf("-> %s\n", dcmVRName(vr));
    unsigned int vl=0;
    if(dcmVRReserved(vr)==0) vl=dcmReadFileVL(fp, 2); 
    else vl=dcmReadFileVL(fp, 4); 
    //printf("reserved=%d\n", dcmVRReserved(vr));
    if(vr==DCM_VR_SQ) break;
    //printf("huuh\n");
    if(vl==0xFFFFFFFF) break;
    char buf[vl+1];
    //printf("read buf length %d\n", vl);
    if(fread(buf, 1, vl, fp)!=vl) break;
  } // get next tag
  //printf("end of loop\n");
  if(!tag_found) {fsetpos(fp, &opos); return(DCM_TRUID_INVALID);}
  /* Read the UID */
  //printf("reading vr\n");
  if(dcmReadFileVR(fp, NULL)!=DCM_VR_UI) {
    fsetpos(fp, &opos); return(DCM_TRUID_INVALID);
  }
  //printf("reading vl\n");
  unsigned int vl=dcmReadFileVL(fp, 2); 
  if(vl==0 || vl==0xFFFFFFFF) {fsetpos(fp, &opos); return(DCM_TRUID_INVALID);}
  char uid[vl+1];
  //printf("reading uid\n");
  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().

dcmSameImage()

int dcmSameImage	(	const DCMFILE *	d1,
		const DCMFILE *	d2,
		const int	verbose )

Check that two DICOM files belong to the same image.

Defaults to yes, if the needed tags are missing.

See also

dcmFileList, dcmVerifyMagic

Returns

Returns 1 if they are part of the same image, 0 if not.

Parameters

d1	Pointer to the first DICOM file data (pixel data not necessary).
d2	Pointer to the second DICOM file data (pixel data not necessary).
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 24 of file dcmfile.c.

  {
  if(verbose>0) printf("%s()\n", __func__);
  if(d1==NULL || d2==NULL) return(0);
 
  DCMTAG tag;
  DCMITEM *iptr;
 
  /* Check the similarity of Series Instance UID */
  char siuid1[64], siuid2[64];
  siuid1[0]=siuid2[0]=(char)0;
  dcmTagSet(&tag, 0x0020, 0x000E);
  iptr=dcmFindTag(d1->item, 0, &tag, 0);
  if(iptr!=NULL) strlcpy(siuid1, iptr->rd, 64);
  iptr=dcmFindTag(d2->item, 0, &tag, 0);
  if(iptr!=NULL) strlcpy(siuid2, iptr->rd, 64);
  if(verbose>1) {
    printf("Series Instance UID [1] := %s\n", siuid1);
    printf("Series Instance UID [2] := %s\n", siuid2);
  }
  if(strcmp(siuid1, siuid2)) return(0);
 
  /* Check the similarity of Study ID */
  char sid1[16], sid2[16];
  sid1[0]=sid2[0]=(char)0;
  dcmTagSet(&tag, 0x0020, 0x0010);
  iptr=dcmFindTag(d1->item, 0, &tag, 0);
  if(iptr!=NULL) strlcpy(sid1, iptr->rd, 16);
  iptr=dcmFindTag(d2->item, 0, &tag, 0);
  if(iptr!=NULL) strlcpy(sid2, iptr->rd, 16);
  if(verbose>1) {
    printf("Study ID [1] := %s\n", sid1);
    printf("Study ID [2] := %s\n", sid2);
  }
  if(strcmp(sid1, sid2)) return(0);
 
  /* Check the series number */
  char snr1[12], snr2[12];
  snr1[0]=snr2[0]=(char)0;
  dcmTagSet(&tag, 0x0020, 0x0011);
  iptr=dcmFindTag(d1->item, 0, &tag, 0);
  if(iptr!=NULL) strlcpy(snr1, iptr->rd, 12);
  iptr=dcmFindTag(d2->item, 0, &tag, 0);
  if(iptr!=NULL) strlcpy(snr2, iptr->rd, 12);
  if(verbose>1) {
    printf("Series Number [1] := %s\n", snr1);
    printf("Series Number [2] := %s\n", snr2);
  }
  if(strcmp(snr1, snr2)) return(0);
 
  /* The rest of checks should not be necessary... */
  if(verbose>2) {printf("  ... still looks the same...\n"); fflush(stdout);}
 
  /* Check the number of frames (time slices) */
  unsigned short int frameNr1=0, frameNr2=0;
  dcmTagSet(&tag, 0x0054, 0x0101);
  iptr=dcmFindTag(d1->item, 0, &tag, 0);
  if(iptr!=NULL) frameNr1=(unsigned short int)dcmitemGetInt(iptr);
  iptr=dcmFindTag(d2->item, 0, &tag, 0);
  if(iptr!=NULL) frameNr2=(unsigned short int)dcmitemGetInt(iptr);
  if(verbose>1) {
    printf("frameNr [1] := %u\n", frameNr1);
    printf("frameNr [2] := %u\n", frameNr2);
  }
  if(frameNr1!=frameNr2) return(0);
  if(verbose>2) {printf("  ... still looks the same...\n"); fflush(stdout);}
 
  /* Check the number of slices */
  unsigned short int sliceNr1=0, sliceNr2=0;
  dcmTagSet(&tag, 0x0054, 0x0081);
  iptr=dcmFindTag(d1->item, 0, &tag, 0);
  if(iptr!=NULL) sliceNr1=(unsigned short int)dcmitemGetInt(iptr);
  iptr=dcmFindTag(d2->item, 0, &tag, 0);
  if(iptr!=NULL) sliceNr2=(unsigned short int)dcmitemGetInt(iptr);
  if(verbose>1) {
    printf("sliceNr [1] := %u\n", sliceNr1);
    printf("sliceNr [2] := %u\n", sliceNr2);
  }
  if(sliceNr1!=sliceNr2) return(0);
 
  if(verbose>2) {printf("  ... the same.\n"); fflush(stdout);}
  return(1);
}

Referenced by dcmFileList().

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 62 of file dcmsop.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 83 of file dcmsop.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 101 of file dcmsop.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 119 of file dcmsop.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);
}

dcmTagIntRange()

int dcmTagIntRange	(	DCMITEM *	d,
		DCMTAG *	tag,
		int *	mi,
		int *	ma,
		const int	verbose )

Search the range of integer values for specified tag in DCMITEM data tree.

Returns

0 if successful, otherwise >0.

Parameters

d	Pointer to top DICOM item.
tag	Pointer to the DICOM tag that is searched for.
mi	Pointer to int where min value is written; NULL if not needed.
ma	Pointer to int where max value is written; NULL if not needed.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 631 of file dcmdata.c.

  {
  if(d==NULL || tag==NULL) return(1);
  if(verbose>0) printf("%s(%04X,%04X)\n", __func__, tag->group, tag->element);
 
  /* Find the first occurrence of tag */
  DCMITEM *iptr=dcmFindTag(d, 0, tag, 0);
  if(iptr==NULL) {
    if(verbose>1) printf("  tag not found.\n");
    return(2);
  }
  int iv=dcmitemGetInt(iptr); if(verbose>2) printf("  value := %d\n", iv);
  int mini=iv;
  int maxi=iv;
  /* Find the rest of occurrences */
  while(iptr!=NULL) {
    iptr=dcmFindTag(iptr, 1, tag, 0);
    if(iptr!=NULL) {
      iv=dcmitemGetInt(iptr); if(verbose>2) printf("  value := %d\n", iv);
      if(iv>maxi) maxi=iv; else if(iv<mini) mini=iv;
    }
  }
  if(verbose>1) {
    printf("  minimum_value := %d\n", mini);
    printf("  maximum_value := %d\n", maxi);
  }
  if(mi!=NULL) *mi=mini;
  if(ma!=NULL) *ma=maxi;
  return(0);
}

Referenced by dcmImgDim(), and dcmMListRead().

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 483 of file dcmdata.c.

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

Referenced by dcmFileList(), dcmImgDim(), dcmImgIsotope(), dcmImgOrient(), dcmImgPos(), dcmImgPxlsize(), dcmSameImage(), imgReadDICOM(), and imgWriteDICOM().

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 202 of file dcmvr.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(strTimeValid(intl)) {intl[0]=(char)0; return(NULL);}
  return(intl);
}

Referenced by dcmMListRead().

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 66 of file dcmuid.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 87 of file dcmuid.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 105 of file dcmuid.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);
}

Referenced by imgWriteDICOM().

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 141 of file dcmdata.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(!endianLittle()) {
      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(!endianLittle()) swap(&f, &f, 4);
    char *s=malloc(16);
    sprintf(s, "%g", f);
    return(s);
  }

  if(d->vr==DCM_VR_FD) {
    char *s=malloc(32);
    /*if(d->vl==2) {
      printf("\nFD VL=%d\n", d->vl);
      float f;
      memcpy(&f, d->rd+4, 4);
      if(!endianLittle()) swap(&f, &f, 4);
      sprintf(s, "%g", f);
    } else {
      double f;
      memcpy(&f, d->rd, 8);
      if(!endianLittle()) swap(&f, &f, 8);
      sprintf(s, "%g", f);
    }
    */
    double f;
    memcpy(&f, d->rd, 8);
    if(!endianLittle()) 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(!endianLittle()) 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(!endianLittle()) 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(!endianLittle()) 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(!endianLittle()) 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 dcmFileReadNextElement(), dcmImgIsotope(), dcmImgOrient(), dcmImgPos(), dcmImgPxlsize(), dcmitemPrint(), dcmMListRead(), and imgReadDICOM().

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 25 of file dcmio.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(fp==NULL) fclose(lfp); else rewind(lfp);
  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 dcmFileList(), dcmFileRead(), and imgRead().

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 162 of file dcmvr.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 103 of file dcmvr.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 dcmFileReadNextElement(), 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 126 of file dcmvr.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 85 of file dcmvr.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 144 of file dcmvr.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

Code tpcerror, TPCERROR_OK (0) when successful.

Author

Vesa Oikonen

Parameters

fp	File pointer, at the write position.

Definition at line 191 of file dcmio.c.

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

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

Code tpcerror, TPCERROR_OK (0) when successful.

Author

Vesa Oikonen

Parameters

fp	File pointer, at the write position.

Definition at line 216 of file dcmio.c.

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

Referenced by dcmFileWrite().

dcmWriteFileTag()

int dcmWriteFileTag	(	FILE *	fp,
		DCMTAG *	tag )

Write DICOM tag into current file position.

See also

dcmWriteFile, dcmReadFileTag

Returns

Code tpcerror, TPCERROR_OK (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 165 of file dcmio.c.

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

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

Code tpcerror, TPCERROR_OK (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 366 of file dcmio.c.

  {
  if(n!=NULL) *n=0;
  if(fp==NULL || vr==DCM_VR_INVALID) return(TPCERROR_FAIL);
 
  /* 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(TPCERROR_CANNOT_WRITE);
  if(n!=NULL) *n+=bsize;
 
  /* Write VL */
  memcpy(buf, &vl, bsize);
  if(bsize==2) buf[2]=buf[3]=(char)0;
//  if(!endianLittle()) swabip(buf, bsize);
  if(!endianLittle()) swap(buf, buf, bsize);
  if(fwrite(buf, bsize, 1, fp)!=1) return(TPCERROR_CANNOT_WRITE);
  if(n!=NULL) *n+=bsize;
 
  return(TPCERROR_OK);
}

Referenced by dcmFileWrite().

dcmXformToQuatern()

int dcmXformToQuatern	(	double *	xform,
		double *	quatern,
		double *	qoffset,
		const int	verbose )

Calculate quatern parameters for NIfTI from xform matrix.

Based on dcm2niix, but results are compatible with TPC ImageConverter.

See also

dcmImgXform, dcmImgOrient, dcmImgPxlsize, dcmImgPos, dcmImgDim

Returns

0 if successful, otherwise >0.

Parameters

xform	Pointer to xform 4x4 matrix stored as an array of 16 doubles; not modified.
quatern	Pointer to quatern parameter b, c, and d array (size of 3); filled here; enter NULL, if not needed.
qoffset	Pointer to qoffset parameter x, y, and z array (size of 3); filled here; enter NULL, if not needed.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 540 of file dcmimage.c.

  {
  if(verbose>0) {printf("%s(xform[16], quatern[3], qoffset[3])\n", __func__); fflush(stdout);}
  if(xform==NULL) return(1);
  if(quatern!=NULL) for(int i=0; i<3; i++) quatern[i]=nan("");
  if(qoffset!=NULL) for(int i=0; i<3; i++) qoffset[i]=nan("");
 
  /* Copy array to matrix */
  double xformM[4][4];
  for(int i=0; i<4; i++)
    for(int j=0; j<4; j++)
      xformM[i][j]=xform[j+4*i];
  /* DICOM LPS to NIfTI RAS */
  for(int i=0; i<2; i++)
    for(int j=0; j<4; j++)
      xformM[i][j]=-xformM[i][j];
 
  /* Set quatern offsets */
  if(qoffset!=NULL) for(int i=0; i<3; i++) qoffset[i]=xformM[i][3];
 
  /* Ready, if quatern parameters not needed */
  if(quatern==NULL) return(0);
 
  // compute lengths
  double mt[3][3];
  for(int i=0; i<3; i++)
    for(int j=0; j<3; j++)
      mt[i][j]=xformM[i][j];
  double xd, yd, zd;
  xd=sqrt(mt[0][0]*mt[0][0] + mt[1][0]*mt[1][0] + mt[2][0]*mt[2][0]);
  yd=sqrt(mt[0][1]*mt[0][1] + mt[1][1]*mt[1][1] + mt[2][1]*mt[2][1]);
  zd=sqrt(mt[0][2]*mt[0][2] + mt[1][2]*mt[1][2] + mt[2][2]*mt[2][2]);
  if(!(xd>0.0)) {mt[0][0]=1.0; mt[1][0]=mt[2][0]=0.0; xd=1.0;}
  if(!(yd>0.0)) {mt[1][1]=1.0; mt[0][1]=mt[2][1]=0.0; yd=1.0;}
  if(!(zd>0.0)) {mt[2][2]=1.0; mt[0][2]=mt[1][2]=0.0; zd=1.0;}
  // normalize
  for(int i=0; i<3; i++) mt[i][0]/=xd;
  for(int i=0; i<3; i++) mt[i][1]/=yd;
  for(int i=0; i<3; i++) mt[i][2]/=zd;
  // check orthogonality (to be added)
 
  // determinant
  double dt;
  dt=  mt[0][0]*mt[1][1]*mt[2][2] - mt[0][0]*mt[2][1]*mt[1][2] - mt[1][0]*mt[0][1]*mt[2][2]
      +mt[1][0]*mt[2][1]*mt[0][2] + mt[2][0]*mt[0][1]*mt[1][2] - mt[2][0]*mt[1][1]*mt[0][2];
  if(verbose>3) printf("determinant=%g\n", dt);
  if(dt<0.0) for(int i=0; i<3; i++) mt[i][2]=-mt[i][2];
 
  // Calculate quatern parameters
  double a, b, c, d;
  a=1.0+mt[0][0]+mt[1][1]+mt[2][2];
  if(a>0.5) {
    a=0.5*sqrt(a);
    b=0.25*(mt[2][1]-mt[1][2])/a;
    c=0.25*(mt[0][2]-mt[2][0])/a;
    d=0.25*(mt[1][0]-mt[0][1])/a;
  } else {
    xd=1.0+mt[0][0]-(mt[1][1]+mt[2][2]);
    yd=1.0+mt[1][1]-(mt[0][0]+mt[2][2]);
    zd=1.0+mt[2][2]-(mt[0][0]+mt[1][1]);
    if(xd>1.0) {
      b=0.50*sqrt(xd);
      c=0.25*(mt[0][1]+mt[1][0])/b;
      d=0.25*(mt[0][2]+mt[2][0])/b;
      a=0.25*(mt[2][1]-mt[1][2])/b;
    } else if(yd>1.0) {
      c=0.50*sqrt(yd);
      b=0.25*(mt[0][1]+mt[1][0])/c;
      d=0.25*(mt[1][2]+mt[2][0])/c;
      a=0.25*(mt[0][2]-mt[2][0])/c;
    } else {
      d=0.50*sqrt(zd);
      b=0.25*(mt[0][2]+mt[2][0])/d;
      c=0.25*(mt[1][2]+mt[2][1])/d;
      a=0.25*(mt[1][0]-mt[0][1])/d;
    }
  }
  if(a<0.0) {b=-b; c=-c; d=-d;}
  quatern[0]=b;
  quatern[1]=c;
  quatern[2]=d;
 
  return(0);
}

Referenced by imgReadDICOM().