lxdcmvr.cpp.svn-base

dicom 文件读写

#include "LXDcmVR.hpp"
#include <string.h>

#define DCMVR_PROP_NONE         0x00
#define DCMVR_PROP_NONSTANDARD  0x01
#define DCMVR_PROP_INTERNAL     0x02
#define DCMVR_PROP_EXTENDEDLENGTHENCODING 0x04
#define DCMVR_PROP_ISASTRING 0x08
const lstuint32 DCM_UndefinedLength = 0xffffffff;

struct DcmVREntry {
	VR vr;						// Enumeration Value of Value representation
	const char* vrName;         // Name of Value representation
	size_t fValWidth;           // Length of minimal unit, used for swapping
	int propertyFlags;          // Normal, internal, non-standard vr
	lstuint32 minValueLength;      // Minimum length of a single value (bytes)
	lstuint32 maxValueLength;      // Maximum length of a single value (bytes)
};


static const DcmVREntry DcmVRDict[] = {

	{ EVR_AE, "AE", sizeof(char), DCMVR_PROP_ISASTRING, 0, 16 },
	{ EVR_AS, "AS", sizeof(char), DCMVR_PROP_ISASTRING, 4, 4 },
	{ EVR_AT, "AT", sizeof(lstuint16), DCMVR_PROP_NONE, 4, 4 },
	{ EVR_CS, "CS", sizeof(char), DCMVR_PROP_ISASTRING, 0, 16 },
	{ EVR_DA, "DA", sizeof(char), DCMVR_PROP_ISASTRING, 8, 10 },
	{ EVR_DS, "DS", sizeof(char), DCMVR_PROP_ISASTRING, 0, 16 },
	{ EVR_DT, "DT", sizeof(char), DCMVR_PROP_ISASTRING, 0, 26},
	{ EVR_FL, "FL", sizeof(float), DCMVR_PROP_NONE, 4, 4 },
	{ EVR_FD, "FD", sizeof(double), DCMVR_PROP_NONE, 8, 8 },
	{ EVR_IS, "IS", sizeof(char), DCMVR_PROP_ISASTRING, 0, 12 },
	{ EVR_LO, "LO", sizeof(char), DCMVR_PROP_ISASTRING, 0, 64 },
	{ EVR_LT, "LT", sizeof(char), DCMVR_PROP_ISASTRING, 0, 10240 },
	{ EVR_OB, "OB", sizeof(lstuint8), DCMVR_PROP_EXTENDEDLENGTHENCODING, 0, DCM_UndefinedLength },
	{ EVR_OF, "OF", sizeof(float), DCMVR_PROP_EXTENDEDLENGTHENCODING, 0, DCM_UndefinedLength },
	{ EVR_OW, "OW", sizeof(lstuint16), DCMVR_PROP_EXTENDEDLENGTHENCODING, 0, DCM_UndefinedLength },
	{ EVR_PN, "PN", sizeof(char), DCMVR_PROP_ISASTRING, 0, 64 },
	{ EVR_SH, "SH", sizeof(char), DCMVR_PROP_ISASTRING, 0, 16 },
	{ EVR_SL, "SL", sizeof(int), DCMVR_PROP_NONE, 4, 4 },
	{ EVR_SQ, "SQ", 0, DCMVR_PROP_EXTENDEDLENGTHENCODING, 0, DCM_UndefinedLength },
	{ EVR_SS, "SS", sizeof(short), DCMVR_PROP_NONE, 2, 2 },
	{ EVR_ST, "ST", sizeof(char), DCMVR_PROP_ISASTRING, 0, 1024 },
	{ EVR_TM, "TM", sizeof(char), DCMVR_PROP_ISASTRING, 0, 16 },
	{ EVR_UI, "UI", sizeof(char), DCMVR_PROP_ISASTRING, 0, 64 },
	{ EVR_UL, "UL", sizeof(lstuint32), DCMVR_PROP_NONE, 4, 4 },
	{ EVR_US, "US", sizeof(lstuint16), DCMVR_PROP_NONE, 2, 2 },
	{ EVR_UT, "UT", sizeof(char), DCMVR_PROP_ISASTRING|DCMVR_PROP_EXTENDEDLENGTHENCODING, 0, DCM_UndefinedLength },
	{ EVR_ox, "ox", sizeof(lstuint8), DCMVR_PROP_NONSTANDARD | DCMVR_PROP_EXTENDEDLENGTHENCODING, 0, DCM_UndefinedLength },
	{ EVR_xs, "xs", sizeof(lstuint16), DCMVR_PROP_NONSTANDARD, 2, 2 },
	{ EVR_lt, "lt", sizeof(lstuint16), DCMVR_PROP_NONSTANDARD | DCMVR_PROP_EXTENDEDLENGTHENCODING, 0, DCM_UndefinedLength },
	{ EVR_na, "na", 0, DCMVR_PROP_NONSTANDARD, 0, 0 },
	{ EVR_up, "up", sizeof(lstuint32), DCMVR_PROP_NONSTANDARD, 4, 4 },

	/* unique prefixes have been "invented" for the following internal VRs */
	{ EVR_item, "it_EVR_item", 0,
	DCMVR_PROP_NONSTANDARD | DCMVR_PROP_INTERNAL, 0, 0 },
	{ EVR_metainfo, "mi_EVR_metainfo", 0,
	DCMVR_PROP_NONSTANDARD | DCMVR_PROP_INTERNAL, 0, 0 },
	{ EVR_dataset, "ds_EVR_dataset", 0,
	DCMVR_PROP_NONSTANDARD | DCMVR_PROP_INTERNAL, 0, 0 },
	{ EVR_fileFormat, "ff_EVR_fileFormat", 0,
	DCMVR_PROP_NONSTANDARD | DCMVR_PROP_INTERNAL, 0, 0 },
	{ EVR_dicomDir, "dd_EVR_dicomDir", 0,
	DCMVR_PROP_NONSTANDARD | DCMVR_PROP_INTERNAL, 0, 0 },
	{ EVR_dirRecord, "dr_EVR_dirRecord", 0,
	DCMVR_PROP_NONSTANDARD | DCMVR_PROP_INTERNAL, 0, 0 },

	{ EVR_pixelSQ, "ps_EVR_pixelSQ", sizeof(lstuint8),
	DCMVR_PROP_NONSTANDARD | DCMVR_PROP_INTERNAL, 0, DCM_UndefinedLength },
	/* Moved from internal use to non standard only: necessary to distinguish from "normal" OB */
	{ EVR_pixelItem, "pi", sizeof(lstuint8),
	DCMVR_PROP_NONSTANDARD, 0, DCM_UndefinedLength },

	{ EVR_UNKNOWN, "??", sizeof(lstuint8), /* EVR_UNKNOWN (i.e. "future" VRs) should be mapped to UN or OB */
	DCMVR_PROP_NONSTANDARD | DCMVR_PROP_INTERNAL | DCMVR_PROP_EXTENDEDLENGTHENCODING, 0, DCM_UndefinedLength },

	/* Unknown Value Representation - Supplement 14 */
	{ EVR_UN, "UN", sizeof(lstuint8), DCMVR_PROP_EXTENDEDLENGTHENCODING, 0, DCM_UndefinedLength },

	/* Pixel Data - only used in ident() */
	{ EVR_PixelData, "PixelData", 0, DCMVR_PROP_INTERNAL, 0, DCM_UndefinedLength },
	/* Overlay Data - only used in ident() */
	{ EVR_OverlayData, "OverlayData", 0, DCMVR_PROP_INTERNAL, 0, DCM_UndefinedLength },

	{ EVR_UNKNOWN2B, "??", sizeof(lstuint8), /* illegal VRs, we assume no extended length coding */
	DCMVR_PROP_NONSTANDARD | DCMVR_PROP_INTERNAL , 0, DCM_UndefinedLength },

};

static const int DcmVRDict_DIM = sizeof(DcmVRDict) / sizeof(DcmVREntry);


inline void CLXDcmVR::SetVR( const CLXDcmVR &arg )
{
	m_evr=arg.m_evr;
}

void CLXDcmVR::SetVR( const char* vrName )
{
	m_evr = EVR_UNKNOWN;   /* default */
	if ( vrName != NULL)
	{
		int found = false;
		int i = 0;
		for (i=0;  (!found && (i < DcmVRDict_DIM)); i++)
		{
			if (strncmp(vrName, DcmVRDict[i].vrName, 2) == 0)
			{
				found = true;
				m_evr = DcmVRDict[i].vr;
			}
		}
		register char c1 = *vrName;
		register char c2 = (c1)?(*(vrName+1)):('\0');
		if ((c1=='?')&&(c2=='?')) m_evr = EVR_UNKNOWN2B;
		if (!found && ((c1<'A')||(c1>'Z')||(c2<'A')||(c2>'Z'))) m_evr = EVR_UNKNOWN2B;
	}
}

VR CLXDcmVR::GetVR() const
{
	return m_evr;
}

const char* CLXDcmVR::GetVRName()
{
	return DcmVRDict[m_evr].vrName;
}

lstuint32 CLXDcmVR::GetMinValueLength()
{
	return (DcmVRDict[m_evr].minValueLength);
}


lstuint32 CLXDcmVR::GetMaxValueLength()
{
	 return (DcmVRDict[m_evr].maxValueLength);
}

CLXDcmVR::CLXDcmVR( const char* vrName )
:m_evr(EVR_UNKNOWN)
{
	SetVR(vrName);
}

bool CLXDcmVR::IsSupported()
{
	if(m_evr<26&&m_evr>1)
	{
		return true;
	}
	else
	{
		return false;
	}
}

lstuint32 CLXDcmVR::GetValueWidth()
{
	return DcmVRDict[m_evr].fValWidth;
}