DCMTK: dcmpmap: a library for working with parametric map objects

DCMTK Version 3.6.9 OFFIS DICOM Toolkit

Loading...
Searching...
No Matches
dcmpmap: a library for working with parametric map objects

This module contains classes to create, load, access and store DICOM Parametric Map objects, which have originally been introduced to the DICOM standard with Supplement 172 in 2014.

In the standard, the data inside each Parametric Map object must rely on one of these data types:

- 16 bit unsigned integer
- 16 bit signed integer
- 32 bit floating point
- 64 bit floating point

All of them are supported by the dcmpmap library.

The main class of this module is:

- DPMParametricMapIOD

This module makes heavy use of the dcmiod module for managing common IOD attributes and the dcmfg module for functional group support. Read the "Examples" sections for more explanations.

# Examples

The following two examples show:

- How to access and dump information (including the binary data values) from a Parametric Map object
- and how to use the API to create such an object yourself.

## Dumping information from Parametric Map

The Parametric Map class uses a template in order to instantiate the correct pixel data type internally, and to offer a dedicated API for that type. Allowed types are Uint16, Sint16, Float32 and Float64.

Since internally the data types are handled in a C++ Variant, the usual concept to "switch" between these types in code is to use a Visitor which overloads the operator "()" for each data type that can occur in the Variant. This concept is also demonstrated below where the type of pixel data is printed.

The rest of the code uses the API of the dcmiod and dcmfg module in order to get basic information about Patient, Study, Series and Instance, as well as functional group information, especially the Real World Value Mapping defined in the file.

#include "dcmtk/config/osconfig.h" /* make sure OS specific configuration is included first */
#include "dcmtk/dcmpmap/dpmparametricmapiod.h"
static void dumpRWVM(const unsigned long frameNumber,
FGInterface& fg)
{
FGRealWorldValueMapping* rw = OFstatic_cast(FGRealWorldValueMapping*, fg.get(frameNumber, DcmFGTypes::EFG_REALWORLDVALUEMAPPING));
if (rw)
{
size_t numMappings = rw->getRealWorldValueMapping().size();
COUT << " Number of Real World Value Mappings defined: " << numMappings << OFendl;
for (size_t m = 0; m < numMappings; m++)
{
FGRealWorldValueMapping::RWVMItem* item = rw->getRealWorldValueMapping()[m];
OFString label, expl;
item->getLUTLabel(label);
item->getLUTExplanation(expl);
COUT << " RWVM Mapping #" << m << ":" << OFendl;
COUT << " LUT Label: << " << label << OFendl;
COUT << " LUT Explanation: " << expl << OFendl;
COUT << " Measurement Units Code: " << item->getMeasurementUnitsCode().toString() << OFendl;
size_t numQuant = item->getEntireQuantityDefinitionSequence().size();
if (numQuant > 0)
{
COUT << " Number of Quantities defined: " << numQuant << OFendl;
for (size_t q = 0; q < numQuant; q++)
{
ContentItemMacro* macro = item->getEntireQuantityDefinitionSequence()[q];
COUT << " Quantity #" << q << ": " << macro->toString() << OFendl;
}
}
}
}
else
{
CERR << " Error: No Real World Value Mappings defined for frame #" << frameNumber << OFendl;
}
}
class DumpFramesVisitor
{
public:
DumpFramesVisitor(DPMParametricMapIOD* map,
const unsigned long numPerFrame)
: m_Map(map)
, m_numPerFrame(numPerFrame)
{
}
template<typename T>
OFBool operator()(DPMParametricMapIOD::Frames<T>& frames)
{
dumpDataType(frames);
for (unsigned long f = 0; f < m_Map->getNumberOfFrames(); f++)
{
COUT << "Dumping info of frame #" << f << ":" << OFendl;
FGInterface& fg = m_Map->getFunctionalGroups();
dumpRWVM(f, fg);
COUT << "Dumping data for frame #" << f << ": " << OFendl;
T* frame = frames.getFrame(f);
for (unsigned long p = 0; p < m_numPerFrame; p++)
{
COUT << frame[p] << " ";
}
COUT << OFendl << OFendl;
}
return 0;
}
OFBool operator()(OFCondition& cond)
{
// Avoid compiler warning
(void)cond;
CERR << "Type of data samples not supported" << OFendl;
return OFFalse;
}
OFBool dumpHeader(DPMParametricMapIOD::Frames<Float32>& frames)
{
// Avoid compiler warning
(void)frames;
COUT << "File has 32 Bit float data" << OFendl;
return OFFalse;
}
OFBool dumpHeader(DPMParametricMapIOD::Frames<Uint16>& frames)
{
// Avoid compiler warning
(void)frames;
COUT << "File has 16 Bit unsigned integer data" << OFendl;
return OFFalse;
}
OFBool dumpHeader(DPMParametricMapIOD::Frames<Sint16>& frames)
{
// Avoid compiler warning
(void)frames;
COUT << "File has 16 Bit signed integer data" << OFendl;
return OFFalse;
}
OFBool dumpHeader(DPMParametricMapIOD::Frames<Float64>& frames)
{
// Avoid compiler warning
(void)frames;
COUT << "File has 64 Bit float data" << OFendl;
return OFTrue;
}
template<typename T>
OFBool dumpDataType(DPMParametricMapIOD::Frames<T>& frames)
{
// Avoid compiler warning
(void)frames;
CERR << "Type of data samples not supported" << OFendl;
return OFFalse;
}
DPMParametricMapIOD* m_Map;
unsigned long m_numPerFrame;
};
static void dumpGeneral(DPMParametricMapIOD& map)
{
OFString patName, patID, studyUID, studyDate, seriesUID, modality, sopUID;
map.getPatient().getPatientName(patName);
map.getPatient().getPatientID(patID);
map.getStudy().getStudyInstanceUID(studyUID);
map.getStudy().getStudyDate(studyDate);
map.getSeries().getSeriesInstanceUID(seriesUID);
map.getSeries().getModality(modality);
map.getSOPCommon().getSOPInstanceUID(sopUID);
COUT << "Patient Name : " << patName << OFendl;
COUT << "Patient ID : " << patID << OFendl;
COUT << "Study Instance UID : " << studyUID << OFendl;
COUT << "Study Date : " << studyDate << OFendl;
COUT << "Series Instance UID: " << seriesUID << OFendl;
COUT << "SOP Instance UID : " << sopUID << OFendl;
COUT << "---------------------------------------------------------------" << OFendl;
OFBool isPerFrame;
map.getFunctionalGroups().get(0, DcmFGTypes::EFG_REALWORLDVALUEMAPPING, isPerFrame);
if (isPerFrame)
{
COUT << "Real World Value Mapping: Defined per-frame" << OFendl;
}
else
{
COUT << "Real World Value Mapping: Defined shared (i.e. single definition for all frames):" << OFendl;
}
COUT << "---------------------------------------------------------------" << OFendl;
}
int main (int argc, char* argv[])
{
// OFLog::configure(OFLogger::DEBUG_LOG_LEVEL);
OFString inputFile;
if (argc < 2)
{
CERR << "Usage: dump_pmp <input-file>" << std::endl;
return 1;
}
else
{
inputFile = argv[1];
if (!OFStandard::fileExists(inputFile))
{
CERR << "Input file " << inputFile << " does not exist " << OFendl;
return 1;
}
}
OFvariant<OFCondition,DPMParametricMapIOD*> result = DPMParametricMapIOD::loadFile(inputFile);
if (OFget<DPMParametricMapIOD*>(&result))
{
DPMParametricMapIOD* map = *OFget<DPMParametricMapIOD*>(&result);
dumpGeneral(*map);
COUT << "Dumping #" << map->getNumberOfFrames() << " frames of file " << inputFile << OFendl;
Uint16 rows, cols = 0;
map->getRows(rows);
map->getColumns(cols);
unsigned long numPerFrame = rows * cols;
DPMParametricMapIOD::FramesType frames = map->getFrames();
OFvisit<OFBool>(DumpFramesVisitor(map, numPerFrame), frames);
}
else
{
CERR << "Could not load parametric map: " << (*OFget<OFCondition>(&result)).text() << OFendl;
exit(1);
}
exit(0);
}
CodeSequenceMacro::toString
virtual OFString toString()
Returns string representation reflecting the coded value.
ContentItemMacro
Class representing the Content Item Macro:
Definition iodcontentitemmacro.h:50
DPMParametricMapBase::getFunctionalGroups
virtual FGInterface & getFunctionalGroups()
Get access to functional groups.
DPMParametricMapIOD::Frames::getFrame
PixelType * getFrame(const size_t frameNumber)
Type-specific getFrame() method that returns Float32, Uint16, or whatever is used in this Parametric ...
DPMParametricMapIOD
Class for managing the Parametric Map IOD attributes.
Definition dpmparametricmapiod.h:33
DPMParametricMapIOD::loadFile
static OFvariant< OFCondition, DPMParametricMapIOD * > loadFile(const OFString &filename)
Load Parametric Map object from file.
DPMParametricMapIOD::getNumberOfFrames
size_t getNumberOfFrames() const
Get number of frames, based on the number of items in the shared functional functional groups sequenc...
DPMParametricMapIOD::getFrames
FramesType getFrames()
Get access to frame data.
DPMParametricMapIOD::FramesType
OFvariant< OFCondition, Frames< Uint16 >, Frames< Sint16 >, Frames< Float32 >, Frames< Float64 > > FramesType
Frames can contain Uint16, Sint16, Float32 or Float64 data, or nothing at all (in that case OFConditi...
Definition dpmparametricmapiod.h:88
DPMParametricMapIOD::getColumns
virtual OFCondition getColumns(Uint16 &cols)
Get number of cols.
DPMParametricMapIOD::getRows
virtual OFCondition getRows(Uint16 &rows)
Get number of rows.
DcmFGTypes::EFG_REALWORLDVALUEMAPPING
@ EFG_REALWORLDVALUEMAPPING
Real World Value Mapping.
Definition fgtypes.h:191
DcmIODCommon::getSeries
IODGeneralSeriesModule & getSeries()
Get Series Module.
DcmIODCommon::getSOPCommon
IODSOPCommonModule & getSOPCommon()
Get SOP Common Module.
DcmIODCommon::getStudy
IODGeneralStudyModule & getStudy()
Get General Study Module.
DcmIODCommon::getPatient
IODPatientModule & getPatient()
Get Patient Module.
FGInterface
Main interface class to access functional groups from DICOM Enhanced objects.
Definition fginterface.h:40
FGInterface::get
virtual FGBase * get(const Uint32 frameNo, const DcmFGTypes::E_FGType fgType)
Get specific functional group for a frame, no matter whether it is stored per frame or shared.
FGRealWorldValueMapping::RWVMItem
Class representing the Real World Value Mapping Item Macro: Attribute name: (VR, VM,...
Definition fgrealworldvaluemapping.h:140
FGRealWorldValueMapping::RWVMItem::getEntireQuantityDefinitionSequence
virtual OFVector< ContentItemMacro * > & getEntireQuantityDefinitionSequence()
Get a reference to the entire ConceptNameCodeSequence, including items exceeding the value multiplici...
FGRealWorldValueMapping::RWVMItem::getLUTLabel
virtual OFCondition getLUTLabel(OFString &value, const signed long pos=0) const
Get LUT Label.
FGRealWorldValueMapping::RWVMItem::getMeasurementUnitsCode
virtual CodeSequenceMacro & getMeasurementUnitsCode()
Get Measurement Units Code Sequence (content)
FGRealWorldValueMapping::RWVMItem::getLUTExplanation
virtual OFCondition getLUTExplanation(OFString &value, const signed long pos=0) const
Get LUT Explanation.
FGRealWorldValueMapping
Class representing the Real World Value Mapping Functional Group that specifies the mapping of stored...
Definition fgrealworldvaluemapping.h:37
FGRealWorldValueMapping::getRealWorldValueMapping
virtual OFVector< RWVMItem * > & getRealWorldValueMapping()
Return references to the various items inside the Real World Value Mapping Sequence.
IODGeneralSeriesModule::getModality
virtual OFCondition getModality(OFString &value, const signed long pos=0) const
Get Modality.
IODGeneralSeriesModule::getSeriesInstanceUID
virtual OFCondition getSeriesInstanceUID(OFString &value, const signed long pos=0) const
Get series instance UID.
IODGeneralStudyModule::getStudyInstanceUID
virtual OFCondition getStudyInstanceUID(OFString &value, const signed long pos=0) const
Get Study Instance UID.
IODGeneralStudyModule::getStudyDate
virtual OFCondition getStudyDate(OFString &value, const signed long pos=0) const
Get Study Date.
IODPatientModule::getPatientID
virtual OFCondition getPatientID(OFString &value, const signed long pos=0) const
Get Patient ID.
IODPatientModule::getPatientName
virtual OFCondition getPatientName(OFString &value, const signed long pos=0) const
Get Patient's Name.
IODSOPCommonModule::getSOPInstanceUID
virtual OFCondition getSOPInstanceUID(OFString &value, const signed long pos=0) const
Get SOP Instance UID.
OFStandard::fileExists
static OFBool fileExists(const OFFilename &fileName)
check whether the given file exists.
OFString
a simple string class that implements a subset of std::string.
Definition ofstring.h:76
OFVector::size
size_type size() const
get the size of this OFVector.
Definition ofvector.h:186
OFvariant
A class template that represents a type-safe union.
Definition ofvriant.h:417

## Creation of Parametric Maps

The Parametric Map class uses a template in order to instantiate the correct pixel data type internally, and to offer a dedicated API for that type. Allowed types are Uint16, Sint16, Float32 and Float64. The example below demonstrates that the API use is generally the same for all types.

The procedure in the example (and most of it applies for the general case) is as follows:

- The main() routine calls test_pmap() four times, each time using a different Image Pixel Module as template parameter which makes sure that the right pixel data type is used within the created Parametric Map.
- test_pmap() demonstrates the overall steps to create the map:
- Create a new Parametric Map by calling DPMParametricMapIOD::create() (via create_pmap()), and then
- add shared functional groups,
- add dimensions,
- and add frames with the related per-frame functional groups to the object.
- Finally, general data regarding Patient and Study is set.
- Note that the order of these steps in test_pmap() does not matter.

Per default, DPMParametricMapIOD::create() creates a new DICOM instance, within a brand-new DICOM Series that belongs to a brand-new DICOM Study. All minimal information for Patient, Study and Series will be set (e.g. Study, Series and SOP Instance UID as well as other information that is handed over to the create() call, like Series Number). Patient Name and ID are left empty per default.

Of course, often you might want to put the new instance into an existing Series instead, or place the brand-new Series into an existing Study or at least assign it to an existing Patient. The easiest way to to do that is to use the call import() that imports Patient or even Study, Series and Frame of Reference information from an existing file, i.e. place it under an existing Patient, Study and/or Series.

When adding information to the Parametric Map using the public API, some basic checks are usually performed on the data. Finally, when calling saveFile(), some further checks take place, e.g. validating the structure of the functional groups or making sure that all required element values are set.

#include "dcmtk/config/osconfig.h" /* make sure OS specific configuration is included first */
#include "dcmtk/ofstd/oftest.h"
#include "dcmtk/dcmiod/iodutil.h"
#include "dcmtk/dcmpmap/dpmparametricmapiod.h"
#include "dcmtk/dcmfg/fgpixmsr.h"
#include "dcmtk/dcmfg/fgplanpo.h"
#include "dcmtk/dcmfg/fgplanor.h"
#include "dcmtk/dcmfg/fgfracon.h"
#include "dcmtk/dcmfg/fgframeanatomy.h"
#include "dcmtk/dcmfg/fgidentpixeltransform.h"
#include "dcmtk/dcmfg/fgframevoilut.h"
#include "dcmtk/dcmfg/fgrealworldvaluemapping.h"
#include "dcmtk/dcmfg/fgparametricmapframetype.h"
const size_t NUM_FRAMES = 10;
const Uint16 ROWS = 10;
const Uint16 COLS = 10;
const unsigned long NUM_VALUES_PER_FRAME = ROWS * COLS;
// Set Patient and Study example data
static void setGenericData(DPMParametricMapIOD& map)
{
map.getPatient().setPatientName("Onken^Michael");
map.getPatient().setPatientID("007");
map.getStudy().setStudyDate("20160721");
map.getStudy().setStudyTime("111200");
map.getStudy().setStudyID("4711");
}
// Create Parametric Map
template<typename ImagePixel>
static OFvariant<OFCondition,DPMParametricMapIOD> create_pmap()
{
return DPMParametricMapIOD::create<ImagePixel>
(
"MR", // Modality
"1", // Series Number
"1", // Instance Number
ROWS,
COLS,
IODEnhGeneralEquipmentModule::EquipmentInfo("Open Connections GmbH", "make_pmp", "SN_0815", "0.1"),
ContentIdentificationMacro("1", "PARAMAP_LABEL", "Example description from test program", "Onken^Michael"),
"VOLUME", // Image Flavor
"MTT", // Derived Pixel Contrast
DPMTypes::CQ_RESEARCH // Content Qualification
);
}
// Add those functional groups that are common for all frames
static OFCondition addSharedFunctionalGroups(DPMParametricMapIOD& map)
{
FGPixelMeasures pixelMeasures;
pixelMeasures.setPixelSpacing("1\\1");
pixelMeasures.setSliceThickness("0.1");
pixelMeasures.setSpacingBetweenSlices("0.1");
FGPlaneOrientationPatient planeOrientPatientFG;
planeOrientPatientFG.setImageOrientationPatient("1", "0", "0", "0", "1", "0");
FGFrameAnatomy frameAnaFG;
frameAnaFG.setLaterality(FGFrameAnatomy::LATERALITY_UNPAIRED);
frameAnaFG.getAnatomy().getAnatomicRegion().set("T-A0100", "SRT", "Brain");
FGIdentityPixelValueTransformation idTransFG;
FGParametricMapFrameType frameTypeFG;
frameTypeFG.setFrameType("DERIVED\\PRIMARY\\VOLUME\\MTT");
// Add groups to Parametric Map
OFCondition result;
if ((result = map.addForAllFrames(pixelMeasures)).good())
if ((result = map.addForAllFrames(planeOrientPatientFG)).good())
if ((result = map.addForAllFrames(frameAnaFG)).good())
if ((result = map.addForAllFrames(idTransFG)).good())
result = map.addForAllFrames(frameTypeFG);
return result;
}
// Add a single dimension for demonstration purposes based on "Image Position Patient"
static OFCondition addDimensions(DPMParametricMapIOD& map)
{
IODMultiframeDimensionModule& mod = map.getIODMultiframeDimensionModule();
OFString dimUID = DcmIODUtil::createUID(0);
OFCondition result = mod.addDimensionIndex(DCM_ImagePositionPatient, dimUID, DCM_RealWorldValueMappingSequence, "Frame position");
return result;
}
// Add one frame to parametric map. Frame number is used to compute some
// varying example data values differing from frame to frame
template <typename PixelType>
static OFCondition addFrame(DPMParametricMapIOD& map,
const unsigned long frameNo)
{
// Create example data
OFVector<PixelType> data(NUM_VALUES_PER_FRAME);
for (size_t n=0; n < data.size(); ++n)
{
data[n] = (n*frameNo+n) + (0.1 * (frameNo % 10));
}
Uint16 rows, cols;
OFCondition cond = map.getImagePixel().getRows(rows);
cond = map.getImagePixel().getColumns(cols);
// Create functional groups
OFVector<FGBase*> groups;
OFunique_ptr<FGPlanePosPatient> fgPlanePos(new FGPlanePosPatient);
OFunique_ptr<FGFrameContent > fgFracon(new FGFrameContent);
OFunique_ptr<FGRealWorldValueMapping> fgRVWM(new FGRealWorldValueMapping());
FGRealWorldValueMapping::RWVMItem* rvwmItemSimple = new FGRealWorldValueMapping::RWVMItem();
if (!fgPlanePos || !fgFracon || !fgRVWM || !rvwmItemSimple )
return EC_MemoryExhausted;
// Fill in functional group values
// Real World Value Mapping
rvwmItemSimple->setRealWorldValueSlope(10);
rvwmItemSimple->setRealWorldValueIntercept(0);
rvwmItemSimple->setDoubleFloatRealWorldValueFirstValueMapped(0.12345);
rvwmItemSimple->setDoubleFloatRealWorldValueLastValueMapped(98.7654);
rvwmItemSimple->getMeasurementUnitsCode().set("{counts}/s", "UCUM", "Counts per second");
rvwmItemSimple->setLUTExplanation("We are mapping trash to junk.");
rvwmItemSimple->setLUTLabel("Just testing");
CodeSequenceMacro* qCodeName = new CodeSequenceMacro("G-C1C6", "SRT", "Quantity");
CodeSequenceMacro* qSpec = new CodeSequenceMacro("110805", "SRT", "T2 Weighted MR Signal Intensity");
ContentItemMacro* quantity = new ContentItemMacro;
if (!quantity || !qSpec || !quantity)
return EC_MemoryExhausted;
quantity->getEntireConceptNameCodeSequence().push_back(qCodeName);
quantity->getEntireConceptCodeSequence().push_back(qSpec);
rvwmItemSimple->getEntireQuantityDefinitionSequence().push_back(quantity);
quantity->setValueType(ContentItemMacro::VT_CODE);
fgRVWM->getRealWorldValueMapping().push_back(rvwmItemSimple);
// Plane Position
OFStringStream ss;
ss << frameNo;
OFSTRINGSTREAM_GETOFSTRING(ss, framestr) // convert number to string
fgPlanePos->setImagePositionPatient("0", "0", framestr);
// Frame Content
OFCondition result = fgFracon->setDimensionIndexValues(frameNo+1 /* value within dimension */, 0 /* first dimension */);
// Add frame with related groups
if (result.good())
{
// Add frame
groups.push_back(fgPlanePos.get());
groups.push_back(fgFracon.get());
groups.push_back(fgRVWM.get());
groups.push_back(fgPlanePos.get());
DPMParametricMapIOD::FramesType frames = map.getFrames();
result = OFget<DPMParametricMapIOD::Frames<PixelType> >(&frames)->addFrame(&*data.begin(), NUM_VALUES_PER_FRAME, groups);
}
return result;
}
// Main routine that creates Parametric Maps
template<typename ImagePixel>
static OFCondition test_pmap(const OFString& saveDestination)
{
OFvariant<OFCondition,DPMParametricMapIOD> obj = create_pmap<ImagePixel>();
if (OFCondition* pCondition = OFget<OFCondition>(&obj))
return *pCondition;
DPMParametricMapIOD& map = *OFget<DPMParametricMapIOD>(&obj);
OFCondition result;
if ((result = addSharedFunctionalGroups(map)).good())
if ((result = addDimensions(map)).good())
{
// Add frames (parametric map data), and per-frame functional groups
for (unsigned long f = 0; result.good() && (f < NUM_FRAMES); f++)
result = addFrame<OFTypename ImagePixel::value_type>(map, f);
}
// Set some generic data (keep dciodvfy happy on DICOMDIR warnings)
if (result.good())
{
setGenericData(map);
}
// Save
if (result.good())
{
return map.saveFile(saveDestination.c_str());
}
else
{
return result;
}
}
int main (int argc, char* argv[])
{
OFString outputDir;
if (argc < 2)
{
CERR << "Usage: make_pmp <output-dir>" << std::endl;
return 1;
}
else
{
outputDir = argv[1];
if (!OFStandard::dirExists(outputDir))
{
CERR << "Output directory " << outputDir << " does not exist " << OFendl;
return 1;
}
}
//OFLog::configure(OFLogger::DEBUG_LOG_LEVEL);
// Test all possible parametric map types (signed and unsigned integer, floating point
// and double floating point)
test_pmap<IODImagePixelModule<Uint16> >(outputDir + "/uint_paramap.dcm");
test_pmap<IODImagePixelModule<Sint16> >(outputDir + "/sint_paramap.dcm");
test_pmap<IODFloatingPointImagePixelModule>(outputDir + "/float_paramap.dcm");
test_pmap<IODDoubleFloatingPointImagePixelModule>(outputDir + "/double_paramap.dcm");
return 0;
}
CodeSequenceMacro
Class representing a Code Sequence Macro.
Definition iodmacro.h:41
CodeSequenceMacro::set
virtual OFCondition set(const OFString &value, const OFString &scheme, const OFString &meaning, const OFString &schemeVersion="", const OFBool checkValue=OFTrue, const OFBool autoTag=OFTrue)
Set all values in this class conveniently.
ContentIdentificationMacro
Content Identification Macro.
Definition iodmacro.h:968
ContentItemMacro::setValueType
virtual OFCondition setValueType(const OFString &value, const OFBool checkValue=OFTrue)
Set ValueType.
ContentItemMacro::getEntireConceptNameCodeSequence
virtual OFVector< CodeSequenceMacro * > & getEntireConceptNameCodeSequence()
Get a reference to the entire ConceptNameCodeSequence, including items exceeding the value multiplici...
ContentItemMacro::getEntireConceptCodeSequence
virtual OFVector< CodeSequenceMacro * > & getEntireConceptCodeSequence()
Get a reference to the entire ConceptCodeSequence, including items exceeding the value multiplicity r...
DPMParametricMapBase::saveFile
virtual OFCondition saveFile(const OFString &filename, const E_TransferSyntax writeXfer=EXS_LittleEndianExplicit)
Save current object to given filename.
DPMParametricMapBase::getIODMultiframeDimensionModule
virtual IODMultiframeDimensionModule & getIODMultiframeDimensionModule()
Get Multi-frame Dimension Module.
DPMParametricMapIOD::create
static OFvariant< OFCondition, DPMParametricMapIOD > create(const OFString &modality, const OFString &seriesNumber, const OFString &instanceNumber, const Uint16 rows, const Uint16 columns, const IODEnhGeneralEquipmentModule::EquipmentInfo &equipmentInfo, const ContentIdentificationMacro &contentIdentification, const OFString &imageFlavor, const OFString &derivedPixelContrast, const DPMTypes::ContentQualification &contentQualification)
Create new Parametric Map object.
DPMParametricMapIOD::addForAllFrames
virtual OFCondition addForAllFrames(const FGBase &group)
Add a functional group for all frames.
DPMTypes::CQ_RESEARCH
@ CQ_RESEARCH
RESEARCH.
Definition dpmtypes.h:69
DcmIODImage::getImagePixel
IODImagePixelModuleType & getImagePixel()
Get Image Pixel Module (variant)
Definition iodimage.h:134
DcmIODUtil::createUID
static OFString createUID(const Uint8 level=0)
Create new Unique Identifier (UID)
FGFrameAnatomy
Class representing the Frame Anatomy Functional Group Macro.
Definition fgframeanatomy.h:34
FGFrameAnatomy::getAnatomy
virtual GeneralAnatomyMacro & getAnatomy()
Get anatomy information.
FGFrameAnatomy::LATERALITY_UNPAIRED
@ LATERALITY_UNPAIRED
Unpaired body part.
Definition fgframeanatomy.h:49
FGFrameAnatomy::setLaterality
virtual OFCondition setLaterality(const LATERALITY &value)
Set Laterality.
FGFrameContent
Class representing the "Frame Content" Functional Group Macro.
Definition fgfracon.h:42
FGParametricMapFrameType
Class representing the Parametric Map Frame Type Functional Group Macro.
Definition fgparametricmapframetype.h:34
FGParametricMapFrameType::setFrameType
virtual OFCondition setFrameType(const OFString &value, const OFBool checkValue=OFTrue)
Set FrameType.
FGPixelMeasures
Class representing the Pixel Measures Functional Group Macro.
Definition fgpixmsr.h:34
FGPixelMeasures::setPixelSpacing
virtual OFCondition setPixelSpacing(const OFString &value, const OFBool checkValue=OFTrue)
Set Pixel Spacing.
FGPixelMeasures::setSliceThickness
virtual OFCondition setSliceThickness(const OFString &value, const OFBool checkValue=OFTrue)
Set Slice Thickness.
FGPixelMeasures::setSpacingBetweenSlices
virtual OFCondition setSpacingBetweenSlices(const OFString &value, const OFBool checkValue=OFTrue)
Set Spacing between Slices.
FGPlaneOrientationPatient
Class representing the Plane Orientation (Patient) Functional Group Macro.
Definition fgplanor.h:34
FGPlaneOrientationPatient::setImageOrientationPatient
virtual OFCondition setImageOrientationPatient(const OFString &rowX, const OFString &rowY, const OFString &rowZ, const OFString &colX, const OFString &colY, const OFString &colZ, const OFBool checkValue=OFTrue)
Set all values of Image Orientation Patient at once.
FGPlanePosPatient
Class representing the Plane Position (Patient) Functional Group containing the x,...
Definition fgplanpo.h:35
FGRealWorldValueMapping::RWVMItem::setRealWorldValueIntercept
virtual OFCondition setRealWorldValueIntercept(const Float64 value, const OFBool checkValue=OFTrue)
Set Real World Value Intercept.
FGRealWorldValueMapping::RWVMItem::setRealWorldValueSlope
virtual OFCondition setRealWorldValueSlope(const Float64 value, const OFBool checkValue=OFTrue)
Set Real World Value Slope.
FGRealWorldValueMapping::RWVMItem::setDoubleFloatRealWorldValueFirstValueMapped
virtual OFCondition setDoubleFloatRealWorldValueFirstValueMapped(const Float64 value, const OFBool checkValue=OFTrue)
Set Double Float Real World Value First Value Mapped.
FGRealWorldValueMapping::RWVMItem::setLUTLabel
virtual OFCondition setLUTLabel(const OFString &value, const OFBool checkValue=OFTrue)
Set LUT Label.
FGRealWorldValueMapping::RWVMItem::setLUTExplanation
virtual OFCondition setLUTExplanation(const OFString &value, const OFBool checkValue=OFTrue)
Set LUT Explanation.
FGRealWorldValueMapping::RWVMItem::setDoubleFloatRealWorldValueLastValueMapped
virtual OFCondition setDoubleFloatRealWorldValueLastValueMapped(const Float64 value, const OFBool checkValue=OFTrue)
Set Double Float Real World Value Last Value Mapped.
GeneralAnatomyMacro::getAnatomicRegion
virtual CodeSequenceMacro & getAnatomicRegion()
Return Anatomic Region.
IODGeneralStudyModule::setStudyDate
virtual OFCondition setStudyDate(const OFString &value, const OFBool checkValue=OFTrue)
Set Study Date.
IODGeneralStudyModule::setStudyTime
virtual OFCondition setStudyTime(const OFString &value, const OFBool checkValue=OFTrue)
set study time
IODGeneralStudyModule::setStudyID
virtual OFCondition setStudyID(const OFString &value, const OFBool checkValue=OFTrue)
Set Study ID.
IODImagePixelVariant::getRows
OFCondition getRows(Uint16 &value, const unsigned long pos=0)
Get Rows.
Definition modimagepixelvariant.h:150
IODImagePixelVariant::getColumns
OFCondition getColumns(Uint16 &value, const unsigned long pos=0)
Get Columns.
Definition modimagepixelvariant.h:162
IODMultiframeDimensionModule
Class representing the Multi-Frame Dimension Module:
Definition modmultiframedimension.h:47
IODMultiframeDimensionModule::addDimensionIndex
virtual OFCondition addDimensionIndex(const DcmTagKey &dimensionIndexPointer, const OFString &dimensionOrganizationUID, const DcmTagKey &functionalGroupPointer, const OFString &dimensionDescriptionLabel="", const OFString &dimensionIndexPrivateCreator="", const OFString &functionalGroupPrivateCreator="")
Convenience method to add Dimension Index.
IODPatientModule::setPatientID
virtual OFCondition setPatientID(const OFString &value, const OFBool checkValue=OFTrue)
Set Patient ID.
IODPatientModule::setPatientName
virtual OFCondition setPatientName(const OFString &value, const OFBool checkValue=OFTrue)
Set Patient's Name.
OFCondition
General purpose class for condition codes.
Definition ofcond.h:176
OFCondition::good
OFBool good() const
check if the status is OK.
Definition ofcond.h:312
OFStandard::dirExists
static OFBool dirExists(const OFFilename &dirName)
check whether the given directory exists.
OFString::c_str
const char * c_str() const
returns a pointer to the initial element of an array of length size()+1 whose first size() elements e...
Definition ofstring.h:388
OFVector
this is a resizable array.
Definition ofvector.h:50
OFVector::push_back
void push_back(const T &v)
insert an entry at the end of this object
Definition ofvector.h:297
OFunique_ptr
OFunique_ptr is a smart pointer that retains sole ownership of an object through a pointer and destro...
Definition ofmem.h:289
EC_MemoryExhausted
DCMTK_OFSTD_EXPORT const OFConditionConst EC_MemoryExhausted
condition constant: failure, memory exhausted
oftest.h
A simple framework for writing and running test cases.
IODEnhGeneralEquipmentModule::EquipmentInfo
Convenient struct containing all information required for setting enhanced equipment information (for...
Definition modenhequipment.h:45

Generated on Wed Apr 30 2025 for DCMTK Version 3.6.9 by Doxygen 1.13.2