You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
260 lines
7.1 KiB
C++
260 lines
7.1 KiB
C++
/*=========================================================================
|
|
|
|
Program: DICOMParser
|
|
Module: DICOMParser.h
|
|
Language: C++
|
|
|
|
Copyright (c) 2003 Matt Turek
|
|
All rights reserved.
|
|
See Copyright.txt for details.
|
|
|
|
This software is distributed WITHOUT ANY WARRANTY; without even
|
|
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
PURPOSE. See the above copyright notice for more information.
|
|
|
|
=========================================================================*/
|
|
|
|
#ifndef __DICOMParser_h_
|
|
#define __DICOMParser_h_
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma warning(disable : 4514)
|
|
#pragma warning(disable : 4786)
|
|
#pragma warning(disable : 4503)
|
|
#pragma warning(disable : 4710)
|
|
#pragma warning(disable : 4702)
|
|
#pragma warning(push, 3)
|
|
#endif
|
|
|
|
#include <map>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "DICOMConfig.h"
|
|
#include "DICOMFile.h"
|
|
#include "DICOMParserMap.h"
|
|
#include "DICOMTypes.h"
|
|
|
|
class DICOMCallback;
|
|
template <class T>
|
|
class DICOMMemberCallback;
|
|
|
|
// DICOM_EXPIMP_TEMPLATE template class DICOM_EXPORT dicom_stl::vector<doublebyte>;
|
|
|
|
class DICOMParserImplementation;
|
|
|
|
//
|
|
// We should keep a map with the implicit types for the groups and elements
|
|
// separate from the callbacks. We can use this for the implicit types.
|
|
//
|
|
//
|
|
|
|
class DICOM_EXPORT DICOMParser
|
|
{
|
|
public:
|
|
//
|
|
// Default constructor
|
|
//
|
|
DICOMParser();
|
|
|
|
//
|
|
// Default destructor.
|
|
//
|
|
virtual ~DICOMParser();
|
|
|
|
//
|
|
// Opens a file and initializes the parser.
|
|
//
|
|
bool OpenFile(const dicom_stl::string& filename);
|
|
|
|
//
|
|
// Closes the currently open file.
|
|
//
|
|
void CloseFile();
|
|
|
|
//
|
|
// Return the name of the file last processed.
|
|
//
|
|
const dicom_stl::string& GetFileName();
|
|
|
|
//
|
|
// This method kicks off the parser.
|
|
// OpenFile needs to be called first.
|
|
//
|
|
bool ReadHeader();
|
|
|
|
//
|
|
// Static method that returns true if DICOMFile is opened
|
|
// to a file that contains a DICOM image.
|
|
//
|
|
static bool IsDICOMFile(DICOMFile* file);
|
|
|
|
bool IsDICOMFile()
|
|
{
|
|
if (!this->DataFile)
|
|
{
|
|
return false;
|
|
}
|
|
return DICOMParser::IsDICOMFile(this->DataFile);
|
|
}
|
|
|
|
//
|
|
// Static method that checks the DICOM magic number.
|
|
//
|
|
static bool CheckMagic(char* magic_number);
|
|
|
|
//
|
|
// Defined DICOM types.
|
|
//
|
|
enum VRTypes
|
|
{
|
|
VR_UNKNOWN = 0x0,
|
|
VR_OB = 0x424f, // Other byte string (string of bytes, insensitive to byte order)
|
|
VR_AW = 0x5741,
|
|
VR_AE = 0x4541, // Application Entity (char string)
|
|
VR_AS = 0x5341, // Age string (char string)
|
|
VR_CS = 0x5343, // Code string (char string, leading/trailing spaces insignificant)
|
|
VR_UI = 0x4955, // UID (character string)
|
|
VR_DA = 0x4144, // Date (char string)
|
|
VR_DS = 0x5344, // Decimal string (char string representing a fixed/floating pt number)
|
|
VR_DT = 0x5444, // Date Time (char string)
|
|
VR_IS = 0x5349, // Integer string (char string representing an integer)
|
|
VR_LO = 0x4f4c, // Long string (character string padded with leading/trailing spaces)
|
|
VR_LT = 0x544c, // Long text (character string with one or more paragraphs.)
|
|
VR_OW = 0x574f, // Other word string (sensitive to byte order, transfer syntax)
|
|
VR_PN = 0x4e50, // Person name (character string)
|
|
VR_ST = 0x5453, // Short text (character string, one or more paragraphs)
|
|
VR_TM = 0x4d54, // Time (character string)
|
|
VR_UN = 0x4e55,
|
|
VR_UT = 0x5455, // Unlimited text (character string)
|
|
VR_SQ = 0x5153, // Sequence of items
|
|
VR_SH = 0x4853, // Short string (character string with leading/trailing spaces).
|
|
VR_FL = 0x4c46, // Floating point single precision
|
|
VR_SL = 0x4c53, // Signed long, (signed 32bits, 2's complement form.)
|
|
VR_AT = 0x5441, // Attribute tag (ordered pair 16 bit unsigned)
|
|
VR_UL = 0x4c55, // Unsigned long (unsigned 32 bits)
|
|
VR_US = 0x5355, // Unsigned short (unsigned 16 bits)
|
|
VR_SS = 0x5353, // Signed short, (signed 16bits, 2's complement)
|
|
VR_FD = 0x4446 // Floating point double precision
|
|
};
|
|
|
|
//
|
|
// Callback for the modality tag.
|
|
//
|
|
void ModalityTag(doublebyte group, doublebyte element, VRTypes datatype, unsigned char* tempdata,
|
|
quadbyte length);
|
|
|
|
void SetDICOMTagCallbacks(doublebyte group, doublebyte element, VRTypes datatype,
|
|
dicom_stl::vector<DICOMCallback*>* cbVector);
|
|
void AddDICOMTagCallbacks(doublebyte group, doublebyte element, VRTypes datatype,
|
|
dicom_stl::vector<DICOMCallback*>* cbVector);
|
|
void AddDICOMTagCallback(
|
|
doublebyte group, doublebyte element, VRTypes datatype, DICOMCallback* cb);
|
|
void AddDICOMTagCallbackToAllTags(DICOMCallback* cb);
|
|
|
|
DICOMFile* GetDICOMFile() { return this->DataFile; }
|
|
|
|
void ClearAllDICOMTagCallbacks();
|
|
|
|
void TransferSyntaxCallback(DICOMParser* parser, doublebyte, doublebyte, DICOMParser::VRTypes,
|
|
unsigned char* val, quadbyte);
|
|
|
|
void GetGroupsElementsDatatypes(dicom_stl::vector<doublebyte>& groups,
|
|
dicom_stl::vector<doublebyte>& elements, dicom_stl::vector<VRTypes>& datatypes);
|
|
|
|
protected:
|
|
bool ParseExplicitRecord(
|
|
doublebyte group, doublebyte element, quadbyte& length, VRTypes& represent);
|
|
|
|
bool ParseImplicitRecord(
|
|
doublebyte group, doublebyte element, quadbyte& length, VRTypes& represent);
|
|
//
|
|
// Print a tag.
|
|
//
|
|
// void DumpTag(doublebyte group, doublebyte element, VRTypes datatype, unsigned char* data,
|
|
// quadbyte length);
|
|
void DumpTag(dicom_stream::ostream& out, doublebyte group, doublebyte element, VRTypes vrtype,
|
|
unsigned char* tempdata, quadbyte length);
|
|
|
|
struct DICOMRecord
|
|
{
|
|
doublebyte group;
|
|
doublebyte element;
|
|
VRTypes datatype;
|
|
};
|
|
|
|
//
|
|
// Check to see if the type is a valid DICOM type. If not, figure
|
|
// out the right thing to do next (i.e. compute the element length).
|
|
//
|
|
bool IsValidRepresentation(doublebyte rep, quadbyte& len, VRTypes& mytype);
|
|
|
|
//
|
|
// Reads a record.
|
|
//
|
|
void ReadNextRecord(doublebyte& group, doublebyte& element, DICOMParser::VRTypes& mytype);
|
|
|
|
//
|
|
// Sets up the type map.
|
|
//
|
|
void InitTypeMap();
|
|
|
|
//
|
|
// Flags for byte swapping header values and
|
|
// image data.
|
|
//
|
|
bool ByteSwap;
|
|
bool ByteSwapData;
|
|
|
|
//
|
|
// Stores a map from pair<group, element> keys to
|
|
// values of pair<vector<DICOMCallback*>, datatype>
|
|
//
|
|
// DICOMParserMap Map;
|
|
|
|
//
|
|
// Stores a map from pair<group, element> keys to
|
|
// values of datatype. We use this to store the
|
|
// datatypes for implicit keys that we are
|
|
// interested in.
|
|
//
|
|
// DICOMImplicitTypeMap TypeMap;
|
|
|
|
//
|
|
// Used for outputting debug information.
|
|
//
|
|
dicom_stream::ofstream ParserOutputFile;
|
|
|
|
//
|
|
// Pointer to the DICOMFile we're parsing.
|
|
//
|
|
DICOMFile* DataFile;
|
|
dicom_stl::string FileName;
|
|
|
|
bool ToggleByteSwapImageData;
|
|
|
|
// dicom_stl::vector<doublebyte> Groups;
|
|
// dicom_stl::vector<doublebyte> Elements;
|
|
// dicom_stl::vector<VRTypes> Datatypes;
|
|
|
|
DICOMMemberCallback<DICOMParser>* TransferSyntaxCB;
|
|
|
|
//
|
|
// Implementation contains stl templated classes that
|
|
// can't be exported from a DLL in Windows. We hide
|
|
// them in the implementation to get rid of annoying
|
|
// compile warnings.
|
|
//
|
|
DICOMParserImplementation* Implementation;
|
|
|
|
private:
|
|
DICOMParser(const DICOMParser&);
|
|
void operator=(const DICOMParser&);
|
|
};
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
#endif // __DICOMParser_h_
|