mlDRTDoseIODBase.h

Go to the documentation of this file.

// Copyright (c) Fraunhofer MEVIS, Germany. All rights reserved.
// **InsertLicense** code
//----------------------------------------------------------------------------------
//
// NOTE: 
// This file has been generated automatically by
//   FMEwork/ReleaseMeVis/Configuration/CodeGenerators/dcmtkToMLConverter/convertDcmtkToML.py
// using the template file
//   FMEwork/ReleaseMeVis/Configuration/CodeGenerators/dcmtkToMLConverter/MLDcmtkBaseObjectsNew/templates/DcmIODBase.h
//
// Destination project: 
//   FMEwork/ReleaseMeVis/Sources/Shared/MLDcmtkBaseObjectsNew
//
//----------------------------------------------------------------------------------
 
//----------------------------------------------------------------------------------
 
#ifndef __mlDRTDoseIODBase_H
#define __mlDRTDoseIODBase_H
 
// Local includes
#include "MLDcmtkBaseObjectsSystem.h"
#include "mlRTBase.h"
 
// ML includes
#ifndef __mlModuleIncludes_H
#include "mlModuleIncludes.h"
#endif
 
// DcmtkAccessories includes
#include <mlDcmtkAccessories.h>
#include "DcmSequenceInterfaces/mlDcmDRTDerivationCodeSequenceInterface.h"  //DRTDerivationCodeSequence
#include "DcmSequenceInterfaces/mlDcmDRTIconImageSequenceInterface.h"  //DRTIconImageSequence
#include "DcmSequenceInterfaces/mlDcmDRTReferencedImageSequenceInterface.h"  //DRTReferencedImageSequence
#include "DcmSequenceInterfaces/mlDcmDRTReferencedInstanceSequenceInterface.h"  //DRTReferencedInstanceSequence
#include "DcmSequenceInterfaces/mlDcmDRTSourceImageSequenceInterface.h"  //DRTSourceImageSequence
#include "DcmSequenceInterfaces/mlDcmDRTPhysiciansOfRecordIdentificationSequenceInterface.h"  //DRTPhysiciansOfRecordIdentificationSequence
#include "DcmSequenceInterfaces/mlDcmDRTPhysiciansReadingStudyIdentificationSequenceInterface.h"  //DRTPhysiciansReadingStudyIdentificationSequence
#include "DcmSequenceInterfaces/mlDcmDRTProcedureCodeSequenceInterface.h"  //DRTProcedureCodeSequence
#include "DcmSequenceInterfaces/mlDcmDRTReferencedStudySequenceInterface.h"  //DRTReferencedStudySequence
#include "DcmSequenceInterfaces/mlDcmDRTReferringPhysicianIdentificationSequenceInterface.h"  //DRTReferringPhysicianIdentificationSequence
#include "DcmSequenceInterfaces/mlDcmDRTModalityLUTSequenceInterface.h"  //DRTModalityLUTSequence
#include "DcmSequenceInterfaces/mlDcmDRTBreedRegistrationSequenceInterface.h"  //DRTBreedRegistrationSequence
#include "DcmSequenceInterfaces/mlDcmDRTDeidentificationMethodCodeSequenceInterface.h"  //DRTDeidentificationMethodCodeSequence
#include "DcmSequenceInterfaces/mlDcmDRTOtherPatientIDsSequenceInterface.h"  //DRTOtherPatientIDsSequence
#include "DcmSequenceInterfaces/mlDcmDRTPatientBreedCodeSequenceInterface.h"  //DRTPatientBreedCodeSequence
#include "DcmSequenceInterfaces/mlDcmDRTPatientSpeciesCodeSequenceInterface.h"  //DRTPatientSpeciesCodeSequence
#include "DcmSequenceInterfaces/mlDcmDRTReferencedPatientSequenceInterface.h"  //DRTReferencedPatientSequence
#include "DcmSequenceInterfaces/mlDcmDRTAdmittingDiagnosesCodeSequenceInterface.h"  //DRTAdmittingDiagnosesCodeSequence
#include "DcmSequenceInterfaces/mlDcmDRTROIContourSequenceInterface.h"  //DRTROIContourSequence
#include "DcmSequenceInterfaces/mlDcmDRTDVHSequenceInterface.h"  //DRTDVHSequence
#include "DcmSequenceInterfaces/mlDcmDRTReferencedStructureSetSequenceInterface.h"  //DRTReferencedStructureSetSequence
#include "DcmSequenceInterfaces/mlDcmDRTReferencedRTPlanSequenceInterface.h"  //DRTReferencedRTPlanSequence
#include "DcmSequenceInterfaces/mlDcmDRTRTDoseROISequenceInterface.h"  //DRTRTDoseROISequence
#include "DcmSequenceInterfaces/mlDcmDRTPerformedProtocolCodeSequenceInterface.h"  //DRTPerformedProtocolCodeSequence
#include "DcmSequenceInterfaces/mlDcmDRTReferencedPerformedProcedureStepSequenceInterface.h"  //DRTReferencedPerformedProcedureStepSequence
#include "DcmSequenceInterfaces/mlDcmDRTRequestAttributesSequenceInterface.h"  //DRTRequestAttributesSequence
#include "DcmSequenceInterfaces/mlDcmDRTCodingSchemeIdentificationSequenceInterface.h"  //DRTCodingSchemeIdentificationSequence
#include "DcmSequenceInterfaces/mlDcmDRTContributingEquipmentSequenceInterface.h"  //DRTContributingEquipmentSequence
#include "DcmSequenceInterfaces/mlDcmDRTDigitalSignaturesSequenceInterface.h"  //DRTDigitalSignaturesSequence
#include "DcmSequenceInterfaces/mlDcmDRTEncryptedAttributesSequenceInterface.h"  //DRTEncryptedAttributesSequence
#include "DcmSequenceInterfaces/mlDcmDRTHL7StructuredDocumentReferenceSequenceInterface.h"  //DRTHL7StructuredDocumentReferenceSequence
#include "DcmSequenceInterfaces/mlDcmDRTMACParametersSequenceInterface.h"  //DRTMACParametersSequence
#include "DcmSequenceInterfaces/mlDcmDRTOriginalAttributesSequenceInterface.h"  //DRTOriginalAttributesSequence
#include "DcmSequenceInterfaces/mlDcmDRTReferencedFrameOfReferenceSequenceInterface.h"  //DRTReferencedFrameOfReferenceSequence
#include "DcmSequenceInterfaces/mlDcmDRTStructureSetROISequenceInterface.h"  //DRTStructureSetROISequence
 
 
ML_START_NAMESPACE
 
// ------------------------------------------------------------------
// ------------------------------------------------------------------
class MLDCMTKBASEOBJECTS_EXPORT DRTDoseIODBase : public RTBase
{
public:
 
  DRTDoseIODBase();
 
  DRTDoseIODBase(DCMTree::TreePtr dicomTree):RTBase(dicomTree) { };
 
  typedef std::vector<DcmModuleType> dcmModuleTypeVec;
  typedef std::vector<DcmModuleType>::iterator dcmModuleTypeVecIter;
 
   bool containsModule(DcmModuleType moduleType) {
      dcmModuleTypeVecIter iter = find(_dcmModuleTypes.begin(), _dcmModuleTypes.end(), moduleType);
      return iter != _dcmModuleTypes.end();
    }
    
  dcmModuleTypeVec getModuleTypes() { return _dcmModuleTypes; }
 
  virtual ~DRTDoseIODBase () {}
 
  void setDcmTree(DCMTree::TreePtr dcmTree) { setMutableTree(dcmTree); }
 
  DCMTree::TreePtr getDCMTree() { return getMutableTree(); }
 
  bool isValid() { return getMutableTree() != NULL; }
 
 
    // ClinicalTrialCoordinatingCenterName (0012,0060) vr=LO, vm=1, type=2
    bool getClinicalTrialCoordinatingCenterName(std::string& parameter) const;
    bool setClinicalTrialCoordinatingCenterName(const std::string parameter);
    std::string getClinicalTrialCoordinatingCenterNameVR() const { return "LO"; }
    std::string getClinicalTrialCoordinatingCenterNameVM() const { return "1"; }
    std::string getClinicalTrialCoordinatingCenterNameTag() const { return std::string("(0012,0060)"); }
    
    // ClinicalTrialTimePointDescription (0012,0051) vr=ST, vm=1, type=3
    bool getClinicalTrialTimePointDescription(std::string& parameter) const;
    bool setClinicalTrialTimePointDescription(const std::string parameter);
    std::string getClinicalTrialTimePointDescriptionVR() const { return "ST"; }
    std::string getClinicalTrialTimePointDescriptionVM() const { return "1"; }
    std::string getClinicalTrialTimePointDescriptionTag() const { return std::string("(0012,0051)"); }
    
    // ClinicalTrialTimePointID (0012,0050) vr=LO, vm=1, type=2
    bool getClinicalTrialTimePointID(std::string& parameter) const;
    bool setClinicalTrialTimePointID(const std::string parameter);
    std::string getClinicalTrialTimePointIDVR() const { return "LO"; }
    std::string getClinicalTrialTimePointIDVM() const { return "1"; }
    std::string getClinicalTrialTimePointIDTag() const { return std::string("(0012,0050)"); }
    
    // ClinicalTrialProtocolID (0012,0020) vr=LO, vm=1, type=1
    bool getClinicalTrialProtocolID(std::string& parameter) const;
    bool setClinicalTrialProtocolID(const std::string parameter);
    std::string getClinicalTrialProtocolIDVR() const { return "LO"; }
    std::string getClinicalTrialProtocolIDVM() const { return "1"; }
    std::string getClinicalTrialProtocolIDTag() const { return std::string("(0012,0020)"); }
    
    // ClinicalTrialProtocolName (0012,0021) vr=LO, vm=1, type=2
    bool getClinicalTrialProtocolName(std::string& parameter) const;
    bool setClinicalTrialProtocolName(const std::string parameter);
    std::string getClinicalTrialProtocolNameVR() const { return "LO"; }
    std::string getClinicalTrialProtocolNameVM() const { return "1"; }
    std::string getClinicalTrialProtocolNameTag() const { return std::string("(0012,0021)"); }
    
    // ClinicalTrialSiteID (0012,0030) vr=LO, vm=1, type=2
    bool getClinicalTrialSiteID(std::string& parameter) const;
    bool setClinicalTrialSiteID(const std::string parameter);
    std::string getClinicalTrialSiteIDVR() const { return "LO"; }
    std::string getClinicalTrialSiteIDVM() const { return "1"; }
    std::string getClinicalTrialSiteIDTag() const { return std::string("(0012,0030)"); }
    
    // ClinicalTrialSiteName (0012,0031) vr=LO, vm=1, type=2
    bool getClinicalTrialSiteName(std::string& parameter) const;
    bool setClinicalTrialSiteName(const std::string parameter);
    std::string getClinicalTrialSiteNameVR() const { return "LO"; }
    std::string getClinicalTrialSiteNameVM() const { return "1"; }
    std::string getClinicalTrialSiteNameTag() const { return std::string("(0012,0031)"); }
    
    // ClinicalTrialSponsorName (0012,0010) vr=LO, vm=1, type=1
    bool getClinicalTrialSponsorName(std::string& parameter) const;
    bool setClinicalTrialSponsorName(const std::string parameter);
    std::string getClinicalTrialSponsorNameVR() const { return "LO"; }
    std::string getClinicalTrialSponsorNameVM() const { return "1"; }
    std::string getClinicalTrialSponsorNameTag() const { return std::string("(0012,0010)"); }
    
    // ClinicalTrialSubjectID (0012,0040) vr=LO, vm=1, type=1C
    bool getClinicalTrialSubjectID(std::string& parameter) const;
    bool setClinicalTrialSubjectID(const std::string parameter);
    std::string getClinicalTrialSubjectIDVR() const { return "LO"; }
    std::string getClinicalTrialSubjectIDVM() const { return "1"; }
    std::string getClinicalTrialSubjectIDTag() const { return std::string("(0012,0040)"); }
    
    // ClinicalTrialSubjectReadingID (0012,0042) vr=LO, vm=1, type=1C
    bool getClinicalTrialSubjectReadingID(std::string& parameter) const;
    bool setClinicalTrialSubjectReadingID(const std::string parameter);
    std::string getClinicalTrialSubjectReadingIDVR() const { return "LO"; }
    std::string getClinicalTrialSubjectReadingIDVM() const { return "1"; }
    std::string getClinicalTrialSubjectReadingIDTag() const { return std::string("(0012,0042)"); }
    
    // FrameOfReferenceUID (0020,0052) vr=UI, vm=1, type=1
    bool getFrameOfReferenceUID(std::string& parameter) const;
    bool setFrameOfReferenceUID(const std::string parameter);
    std::string getFrameOfReferenceUIDVR() const { return "UI"; }
    std::string getFrameOfReferenceUIDVM() const { return "1"; }
    std::string getFrameOfReferenceUIDTag() const { return std::string("(0020,0052)"); }
    
    // PositionReferenceIndicator (0020,1040) vr=LO, vm=1, type=2
    bool getPositionReferenceIndicator(std::string& parameter) const;
    bool setPositionReferenceIndicator(const std::string parameter);
    std::string getPositionReferenceIndicatorVR() const { return "LO"; }
    std::string getPositionReferenceIndicatorVM() const { return "1"; }
    std::string getPositionReferenceIndicatorTag() const { return std::string("(0020,1040)"); }
    
    // DateOfLastCalibration (0018,1200) vr=DA, vm=1-n, type=3
    bool getDateOfLastCalibration(std::string& parameter) const;
    bool setDateOfLastCalibration(const std::string parameter);
    std::string getDateOfLastCalibrationVR() const { return "DA"; }
    std::string getDateOfLastCalibrationVM() const { return "1-n"; }
    std::string getDateOfLastCalibrationTag() const { return std::string("(0018,1200)"); }
    
    // DeviceSerialNumber (0018,1000) vr=LO, vm=1, type=3
    bool getDeviceSerialNumber(std::string& parameter) const;
    bool setDeviceSerialNumber(const std::string parameter);
    std::string getDeviceSerialNumberVR() const { return "LO"; }
    std::string getDeviceSerialNumberVM() const { return "1"; }
    std::string getDeviceSerialNumberTag() const { return std::string("(0018,1000)"); }
    
    // GantryID (0018,1008) vr=LO, vm=1, type=3
    bool getGantryID(std::string& parameter) const;
    bool setGantryID(const std::string parameter);
    std::string getGantryIDVR() const { return "LO"; }
    std::string getGantryIDVM() const { return "1"; }
    std::string getGantryIDTag() const { return std::string("(0018,1008)"); }
    
    // InstitutionAddress (0008,0081) vr=ST, vm=1, type=3
    bool getInstitutionAddress(std::string& parameter) const;
    bool setInstitutionAddress(const std::string parameter);
    std::string getInstitutionAddressVR() const { return "ST"; }
    std::string getInstitutionAddressVM() const { return "1"; }
    std::string getInstitutionAddressTag() const { return std::string("(0008,0081)"); }
    
    // InstitutionName (0008,0080) vr=LO, vm=1, type=3
    bool getInstitutionName(std::string& parameter) const;
    bool setInstitutionName(const std::string parameter);
    std::string getInstitutionNameVR() const { return "LO"; }
    std::string getInstitutionNameVM() const { return "1"; }
    std::string getInstitutionNameTag() const { return std::string("(0008,0080)"); }
    
    // InstitutionalDepartmentName (0008,1040) vr=LO, vm=1, type=3
    bool getInstitutionalDepartmentName(std::string& parameter) const;
    bool setInstitutionalDepartmentName(const std::string parameter);
    std::string getInstitutionalDepartmentNameVR() const { return "LO"; }
    std::string getInstitutionalDepartmentNameVM() const { return "1"; }
    std::string getInstitutionalDepartmentNameTag() const { return std::string("(0008,1040)"); }
    
    // Manufacturer (0008,0070) vr=LO, vm=1, type=2
    bool getManufacturer(std::string& parameter) const;
    bool setManufacturer(const std::string parameter);
    std::string getManufacturerVR() const { return "LO"; }
    std::string getManufacturerVM() const { return "1"; }
    std::string getManufacturerTag() const { return std::string("(0008,0070)"); }
    
    // ManufacturerModelName (0008,1090) vr=LO, vm=1, type=3
    bool getManufacturerModelName(std::string& parameter) const;
    bool setManufacturerModelName(const std::string parameter);
    std::string getManufacturerModelNameVR() const { return "LO"; }
    std::string getManufacturerModelNameVM() const { return "1"; }
    std::string getManufacturerModelNameTag() const { return std::string("(0008,1090)"); }
    
    // PixelPaddingValue (0028,0120) vr=US_SS, vm=1, type=3
    bool getPixelPaddingValue(MLuint16& parameter) const;
    bool setPixelPaddingValue(const MLuint16 parameter);
    std::string getPixelPaddingValueVR() const { return "US_SS"; }
    std::string getPixelPaddingValueVM() const { return "1"; }
    std::string getPixelPaddingValueTag() const { return std::string("(0028,0120)"); }
    
    // SoftwareVersions (0018,1020) vr=LO, vm=1-n, type=3
    bool getSoftwareVersions(std::string& parameter) const;
    bool setSoftwareVersions(const std::string parameter);
    std::string getSoftwareVersionsVR() const { return "LO"; }
    std::string getSoftwareVersionsVM() const { return "1-n"; }
    std::string getSoftwareVersionsTag() const { return std::string("(0018,1020)"); }
    
    // SpatialResolution (0018,1050) vr=DS, vm=1, type=3
    bool getSpatialResolution(std::string& parameter) const;
    bool setSpatialResolution(const std::string parameter);
    std::string getSpatialResolutionVR() const { return "DS"; }
    std::string getSpatialResolutionVM() const { return "1"; }
    std::string getSpatialResolutionTag() const { return std::string("(0018,1050)"); }
    
    // StationName (0008,1010) vr=SH, vm=1, type=3
    bool getStationName(std::string& parameter) const;
    bool setStationName(const std::string parameter);
    std::string getStationNameVR() const { return "SH"; }
    std::string getStationNameVM() const { return "1"; }
    std::string getStationNameTag() const { return std::string("(0008,1010)"); }
    
    // TimeOfLastCalibration (0018,1201) vr=TM, vm=1-n, type=3
    bool getTimeOfLastCalibration(std::string& parameter) const;
    bool setTimeOfLastCalibration(const std::string parameter);
    std::string getTimeOfLastCalibrationVR() const { return "TM"; }
    std::string getTimeOfLastCalibrationVM() const { return "1-n"; }
    std::string getTimeOfLastCalibrationTag() const { return std::string("(0018,1201)"); }
    
    // AcquisitionDate (0008,0022) vr=DA, vm=1, type=3
    bool getAcquisitionDate(std::string& parameter) const;
    bool setAcquisitionDate(const std::string parameter);
    std::string getAcquisitionDateVR() const { return "DA"; }
    std::string getAcquisitionDateVM() const { return "1"; }
    std::string getAcquisitionDateTag() const { return std::string("(0008,0022)"); }
    
    // AcquisitionDateTime (0008,002a) vr=DT, vm=1, type=3
    bool getAcquisitionDateTime(std::string& parameter) const;
    bool setAcquisitionDateTime(const std::string parameter);
    std::string getAcquisitionDateTimeVR() const { return "DT"; }
    std::string getAcquisitionDateTimeVM() const { return "1"; }
    std::string getAcquisitionDateTimeTag() const { return std::string("(0008,002a)"); }
    
    // AcquisitionNumber (0020,0012) vr=IS, vm=1, type=3
    bool getAcquisitionNumber(std::string& parameter) const;
    bool setAcquisitionNumber(const std::string parameter);
    std::string getAcquisitionNumberVR() const { return "IS"; }
    std::string getAcquisitionNumberVM() const { return "1"; }
    std::string getAcquisitionNumberTag() const { return std::string("(0020,0012)"); }
    
    // AcquisitionTime (0008,0032) vr=TM, vm=1, type=3
    bool getAcquisitionTime(std::string& parameter) const;
    bool setAcquisitionTime(const std::string parameter);
    std::string getAcquisitionTimeVR() const { return "TM"; }
    std::string getAcquisitionTimeVM() const { return "1"; }
    std::string getAcquisitionTimeTag() const { return std::string("(0008,0032)"); }
    
    // BurnedInAnnotation (0028,0301) vr=CS, vm=1, type=3
    bool getBurnedInAnnotation(std::string& parameter) const;
    bool setBurnedInAnnotation(const std::string parameter);
    std::string getBurnedInAnnotationVR() const { return "CS"; }
    std::string getBurnedInAnnotationVM() const { return "1"; }
    std::string getBurnedInAnnotationTag() const { return std::string("(0028,0301)"); }
    
    // ContentDate (0008,0023) vr=DA, vm=1, type=2C
    bool getContentDate(std::string& parameter) const;
    bool setContentDate(const std::string parameter);
    std::string getContentDateVR() const { return "DA"; }
    std::string getContentDateVM() const { return "1"; }
    std::string getContentDateTag() const { return std::string("(0008,0023)"); }
    
    // ContentTime (0008,0033) vr=TM, vm=1, type=2C
    bool getContentTime(std::string& parameter) const;
    bool setContentTime(const std::string parameter);
    std::string getContentTimeVR() const { return "TM"; }
    std::string getContentTimeVM() const { return "1"; }
    std::string getContentTimeTag() const { return std::string("(0008,0033)"); }
    
    // DerivationDescription (0008,2111) vr=ST, vm=1, type=3
    bool getDerivationDescription(std::string& parameter) const;
    bool setDerivationDescription(const std::string parameter);
    std::string getDerivationDescriptionVR() const { return "ST"; }
    std::string getDerivationDescriptionVM() const { return "1"; }
    std::string getDerivationDescriptionTag() const { return std::string("(0008,2111)"); }
    
    // ImageComments (0020,4000) vr=LT, vm=1, type=3
    bool getImageComments(std::string& parameter) const;
    bool setImageComments(const std::string parameter);
    std::string getImageCommentsVR() const { return "LT"; }
    std::string getImageCommentsVM() const { return "1"; }
    std::string getImageCommentsTag() const { return std::string("(0020,4000)"); }
    
    // ImageType (0008,0008) vr=CS, vm=2-n, type=3
    bool getImageType(std::string& parameter) const;
    bool setImageType(const std::string parameter);
    std::string getImageTypeVR() const { return "CS"; }
    std::string getImageTypeVM() const { return "2-n"; }
    std::string getImageTypeTag() const { return std::string("(0008,0008)"); }
    
    // ImagesInAcquisition (0020,1002) vr=IS, vm=1, type=3
    bool getImagesInAcquisition(std::string& parameter) const;
    bool setImagesInAcquisition(const std::string parameter);
    std::string getImagesInAcquisitionVR() const { return "IS"; }
    std::string getImagesInAcquisitionVM() const { return "1"; }
    std::string getImagesInAcquisitionTag() const { return std::string("(0020,1002)"); }
    
    // IrradiationEventUID (0008,3010) vr=UI, vm=1, type=3
    bool getIrradiationEventUID(std::string& parameter) const;
    bool setIrradiationEventUID(const std::string parameter);
    std::string getIrradiationEventUIDVR() const { return "UI"; }
    std::string getIrradiationEventUIDVM() const { return "1"; }
    std::string getIrradiationEventUIDTag() const { return std::string("(0008,3010)"); }
    
    // LossyImageCompression (0028,2110) vr=CS, vm=1, type=3
    bool getLossyImageCompression(std::string& parameter) const;
    bool setLossyImageCompression(const std::string parameter);
    std::string getLossyImageCompressionVR() const { return "CS"; }
    std::string getLossyImageCompressionVM() const { return "1"; }
    std::string getLossyImageCompressionTag() const { return std::string("(0028,2110)"); }
    
    // LossyImageCompressionMethod (0028,2114) vr=CS, vm=1-n, type=3
    bool getLossyImageCompressionMethod(std::string& parameter) const;
    bool setLossyImageCompressionMethod(const std::string parameter);
    std::string getLossyImageCompressionMethodVR() const { return "CS"; }
    std::string getLossyImageCompressionMethodVM() const { return "1-n"; }
    std::string getLossyImageCompressionMethodTag() const { return std::string("(0028,2114)"); }
    
    // LossyImageCompressionRatio (0028,2112) vr=DS, vm=1-n, type=3
    bool getLossyImageCompressionRatio(std::string& parameter) const;
    bool setLossyImageCompressionRatio(const std::string parameter);
    std::string getLossyImageCompressionRatioVR() const { return "DS"; }
    std::string getLossyImageCompressionRatioVM() const { return "1-n"; }
    std::string getLossyImageCompressionRatioTag() const { return std::string("(0028,2112)"); }
    
    // PatientOrientation (0020,0020) vr=CS, vm=2, type=2C
    bool getPatientOrientation(std::string& parameter) const;
    bool setPatientOrientation(const std::string parameter);
    std::string getPatientOrientationVR() const { return "CS"; }
    std::string getPatientOrientationVM() const { return "2"; }
    std::string getPatientOrientationTag() const { return std::string("(0020,0020)"); }
    
    // PresentationLUTShape (2050,0020) vr=CS, vm=1, type=3
    bool getPresentationLUTShape(std::string& parameter) const;
    bool setPresentationLUTShape(const std::string parameter);
    std::string getPresentationLUTShapeVR() const { return "CS"; }
    std::string getPresentationLUTShapeVM() const { return "1"; }
    std::string getPresentationLUTShapeTag() const { return std::string("(2050,0020)"); }
    
    // QualityControlImage (0028,0300) vr=CS, vm=1, type=3
    bool getQualityControlImage(std::string& parameter) const;
    bool setQualityControlImage(const std::string parameter);
    std::string getQualityControlImageVR() const { return "CS"; }
    std::string getQualityControlImageVM() const { return "1"; }
    std::string getQualityControlImageTag() const { return std::string("(0028,0300)"); }
    
    // AccessionNumber (0008,0050) vr=SH, vm=1, type=2
    bool getAccessionNumber(std::string& parameter) const;
    bool setAccessionNumber(const std::string parameter);
    std::string getAccessionNumberVR() const { return "SH"; }
    std::string getAccessionNumberVM() const { return "1"; }
    std::string getAccessionNumberTag() const { return std::string("(0008,0050)"); }
    
    // NameOfPhysiciansReadingStudy (0008,1060) vr=PN, vm=1-n, type=3
    bool getNameOfPhysiciansReadingStudy(std::string& parameter) const;
    bool setNameOfPhysiciansReadingStudy(const std::string parameter);
    std::string getNameOfPhysiciansReadingStudyVR() const { return "PN"; }
    std::string getNameOfPhysiciansReadingStudyVM() const { return "1-n"; }
    std::string getNameOfPhysiciansReadingStudyTag() const { return std::string("(0008,1060)"); }
    
    // PhysiciansOfRecord (0008,1048) vr=PN, vm=1-n, type=3
    bool getPhysiciansOfRecord(std::string& parameter) const;
    bool setPhysiciansOfRecord(const std::string parameter);
    std::string getPhysiciansOfRecordVR() const { return "PN"; }
    std::string getPhysiciansOfRecordVM() const { return "1-n"; }
    std::string getPhysiciansOfRecordTag() const { return std::string("(0008,1048)"); }
    
    // ReferringPhysicianName (0008,0090) vr=PN, vm=1, type=2
    bool getReferringPhysicianName(std::string& parameter) const;
    bool setReferringPhysicianName(const std::string parameter);
    std::string getReferringPhysicianNameVR() const { return "PN"; }
    std::string getReferringPhysicianNameVM() const { return "1"; }
    std::string getReferringPhysicianNameTag() const { return std::string("(0008,0090)"); }
    
    // StudyDate (0008,0020) vr=DA, vm=1, type=2
    bool getStudyDate(std::string& parameter) const;
    bool setStudyDate(const std::string parameter);
    std::string getStudyDateVR() const { return "DA"; }
    std::string getStudyDateVM() const { return "1"; }
    std::string getStudyDateTag() const { return std::string("(0008,0020)"); }
    
    // StudyDescription (0008,1030) vr=LO, vm=1, type=3
    bool getStudyDescription(std::string& parameter) const;
    bool setStudyDescription(const std::string parameter);
    std::string getStudyDescriptionVR() const { return "LO"; }
    std::string getStudyDescriptionVM() const { return "1"; }
    std::string getStudyDescriptionTag() const { return std::string("(0008,1030)"); }
    
    // StudyID (0020,0010) vr=SH, vm=1, type=2
    bool getStudyID(std::string& parameter) const;
    bool setStudyID(const std::string parameter);
    std::string getStudyIDVR() const { return "SH"; }
    std::string getStudyIDVM() const { return "1"; }
    std::string getStudyIDTag() const { return std::string("(0020,0010)"); }
    
    // StudyInstanceUID (0020,000d) vr=UI, vm=1, type=1
    bool getStudyInstanceUID(std::string& parameter) const;
    bool setStudyInstanceUID(const std::string parameter);
    std::string getStudyInstanceUIDVR() const { return "UI"; }
    std::string getStudyInstanceUIDVM() const { return "1"; }
    std::string getStudyInstanceUIDTag() const { return std::string("(0020,000d)"); }
    
    // StudyTime (0008,0030) vr=TM, vm=1, type=2
    bool getStudyTime(std::string& parameter) const;
    bool setStudyTime(const std::string parameter);
    std::string getStudyTimeVR() const { return "TM"; }
    std::string getStudyTimeVM() const { return "1"; }
    std::string getStudyTimeTag() const { return std::string("(0008,0030)"); }
    
    // BluePaletteColorLookupTableDescriptor (0028,1103) vr=US_SS, vm=3, type=1C
    bool getBluePaletteColorLookupTableDescriptor(MLuint16& parameter) const;
    bool setBluePaletteColorLookupTableDescriptor(const MLuint16 parameter);
    std::string getBluePaletteColorLookupTableDescriptorVR() const { return "US_SS"; }
    std::string getBluePaletteColorLookupTableDescriptorVM() const { return "3"; }
    std::string getBluePaletteColorLookupTableDescriptorTag() const { return std::string("(0028,1103)"); }
    
    // Columns (0028,0011) vr=US, vm=1, type=1
    bool getColumns(MLuint16& parameter) const;
    bool setColumns(const MLuint16 parameter);
    std::string getColumnsVR() const { return "US"; }
    std::string getColumnsVM() const { return "1"; }
    std::string getColumnsTag() const { return std::string("(0028,0011)"); }
    
    // GreenPaletteColorLookupTableDescriptor (0028,1102) vr=US_SS, vm=3, type=1C
    bool getGreenPaletteColorLookupTableDescriptor(MLuint16& parameter) const;
    bool setGreenPaletteColorLookupTableDescriptor(const MLuint16 parameter);
    std::string getGreenPaletteColorLookupTableDescriptorVR() const { return "US_SS"; }
    std::string getGreenPaletteColorLookupTableDescriptorVM() const { return "3"; }
    std::string getGreenPaletteColorLookupTableDescriptorTag() const { return std::string("(0028,1102)"); }
    
    // ICCProfile (0028,2000) vr=OB, vm=1, type=3
    bool getICCProfile(int& parameter) const;
    bool setICCProfile(const int parameter);
    std::string getICCProfileVR() const { return "OB"; }
    std::string getICCProfileVM() const { return "1"; }
    std::string getICCProfileTag() const { return std::string("(0028,2000)"); }
    
    // LargestImagePixelValue (0028,0107) vr=US_SS, vm=1, type=3
    bool getLargestImagePixelValue(MLuint16& parameter) const;
    bool setLargestImagePixelValue(const MLuint16 parameter);
    std::string getLargestImagePixelValueVR() const { return "US_SS"; }
    std::string getLargestImagePixelValueVM() const { return "1"; }
    std::string getLargestImagePixelValueTag() const { return std::string("(0028,0107)"); }
    
    // PixelAspectRatio (0028,0034) vr=IS, vm=2, type=1C
    bool getPixelAspectRatio(std::string& parameter) const;
    bool setPixelAspectRatio(const std::string parameter);
    std::string getPixelAspectRatioVR() const { return "IS"; }
    std::string getPixelAspectRatioVM() const { return "2"; }
    std::string getPixelAspectRatioTag() const { return std::string("(0028,0034)"); }
    
    // PixelDataProviderURL (0028,7fe0) vr=UT, vm=1, type=1C
    bool getPixelDataProviderURL(std::string& parameter) const;
    bool setPixelDataProviderURL(const std::string parameter);
    std::string getPixelDataProviderURLVR() const { return "UT"; }
    std::string getPixelDataProviderURLVM() const { return "1"; }
    std::string getPixelDataProviderURLTag() const { return std::string("(0028,7fe0)"); }
    
    // PlanarConfiguration (0028,0006) vr=US, vm=1, type=1C
    bool getPlanarConfiguration(MLuint16& parameter) const;
    bool setPlanarConfiguration(const MLuint16 parameter);
    std::string getPlanarConfigurationVR() const { return "US"; }
    std::string getPlanarConfigurationVM() const { return "1"; }
    std::string getPlanarConfigurationTag() const { return std::string("(0028,0006)"); }
    
    // RedPaletteColorLookupTableDescriptor (0028,1101) vr=US_SS, vm=3, type=1C
    bool getRedPaletteColorLookupTableDescriptor(MLuint16& parameter) const;
    bool setRedPaletteColorLookupTableDescriptor(const MLuint16 parameter);
    std::string getRedPaletteColorLookupTableDescriptorVR() const { return "US_SS"; }
    std::string getRedPaletteColorLookupTableDescriptorVM() const { return "3"; }
    std::string getRedPaletteColorLookupTableDescriptorTag() const { return std::string("(0028,1101)"); }
    
    // Rows (0028,0010) vr=US, vm=1, type=1
    bool getRows(MLuint16& parameter) const;
    bool setRows(const MLuint16 parameter);
    std::string getRowsVR() const { return "US"; }
    std::string getRowsVM() const { return "1"; }
    std::string getRowsTag() const { return std::string("(0028,0010)"); }
    
    // SmallestImagePixelValue (0028,0106) vr=US_SS, vm=1, type=3
    bool getSmallestImagePixelValue(MLuint16& parameter) const;
    bool setSmallestImagePixelValue(const MLuint16 parameter);
    std::string getSmallestImagePixelValueVR() const { return "US_SS"; }
    std::string getSmallestImagePixelValueVM() const { return "1"; }
    std::string getSmallestImagePixelValueTag() const { return std::string("(0028,0106)"); }
    
    // ImageOrientationPatient (0020,0037) vr=DS, vm=6, type=1
    bool getImageOrientationPatient(std::string& parameter) const;
    bool setImageOrientationPatient(const std::string parameter);
    std::string getImageOrientationPatientVR() const { return "DS"; }
    std::string getImageOrientationPatientVM() const { return "6"; }
    std::string getImageOrientationPatientTag() const { return std::string("(0020,0037)"); }
    
    // ImagePositionPatient (0020,0032) vr=DS, vm=3, type=1
    bool getImagePositionPatient(std::string& parameter) const;
    bool setImagePositionPatient(const std::string parameter);
    std::string getImagePositionPatientVR() const { return "DS"; }
    std::string getImagePositionPatientVM() const { return "3"; }
    std::string getImagePositionPatientTag() const { return std::string("(0020,0032)"); }
    
    // PixelSpacing (0028,0030) vr=DS, vm=2, type=1
    bool getPixelSpacing(std::string& parameter) const;
    bool setPixelSpacing(const std::string parameter);
    std::string getPixelSpacingVR() const { return "DS"; }
    std::string getPixelSpacingVM() const { return "2"; }
    std::string getPixelSpacingTag() const { return std::string("(0028,0030)"); }
    
    // SliceLocation (0020,1041) vr=DS, vm=1, type=3
    bool getSliceLocation(std::string& parameter) const;
    bool setSliceLocation(const std::string parameter);
    std::string getSliceLocationVR() const { return "DS"; }
    std::string getSliceLocationVM() const { return "1"; }
    std::string getSliceLocationTag() const { return std::string("(0020,1041)"); }
    
    // SliceThickness (0018,0050) vr=DS, vm=1, type=2
    bool getSliceThickness(std::string& parameter) const;
    bool setSliceThickness(const std::string parameter);
    std::string getSliceThicknessVR() const { return "DS"; }
    std::string getSliceThicknessVM() const { return "1"; }
    std::string getSliceThicknessTag() const { return std::string("(0018,0050)"); }
    
    // RescaleIntercept (0028,1052) vr=DS, vm=1, type=1C
    bool getRescaleIntercept(std::string& parameter) const;
    bool setRescaleIntercept(const std::string parameter);
    std::string getRescaleInterceptVR() const { return "DS"; }
    std::string getRescaleInterceptVM() const { return "1"; }
    std::string getRescaleInterceptTag() const { return std::string("(0028,1052)"); }
    
    // RescaleSlope (0028,1053) vr=DS, vm=1, type=1C
    bool getRescaleSlope(std::string& parameter) const;
    bool setRescaleSlope(const std::string parameter);
    std::string getRescaleSlopeVR() const { return "DS"; }
    std::string getRescaleSlopeVM() const { return "1"; }
    std::string getRescaleSlopeTag() const { return std::string("(0028,1053)"); }
    
    // RescaleType (0028,1054) vr=LO, vm=1, type=1C
    bool getRescaleType(std::string& parameter) const;
    bool setRescaleType(const std::string parameter);
    std::string getRescaleTypeVR() const { return "LO"; }
    std::string getRescaleTypeVM() const { return "1"; }
    std::string getRescaleTypeTag() const { return std::string("(0028,1054)"); }
    
    // NumberOfFrames (0028,0008) vr=IS, vm=1, type=1
    bool getNumberOfFrames(std::string& parameter) const;
    bool setNumberOfFrames(const std::string parameter);
    std::string getNumberOfFramesVR() const { return "IS"; }
    std::string getNumberOfFramesVM() const { return "1"; }
    std::string getNumberOfFramesTag() const { return std::string("(0028,0008)"); }
    
    // ImageFrameOrigin (60xx,0051) vr=US, vm=1, type=3
    bool getImageFrameOrigin(MLuint16& parameter) const;
    bool setImageFrameOrigin(const MLuint16 parameter);
    std::string getImageFrameOriginVR() const { return "US"; }
    std::string getImageFrameOriginVM() const { return "1"; }
    std::string getImageFrameOriginTag() const { return std::string("(60xx,0051)"); }
    
    // NumberOfFramesInOverlay (60xx,0015) vr=IS, vm=1, type=1
    bool getNumberOfFramesInOverlay(std::string& parameter) const;
    bool setNumberOfFramesInOverlay(const std::string parameter);
    std::string getNumberOfFramesInOverlayVR() const { return "IS"; }
    std::string getNumberOfFramesInOverlayVM() const { return "1"; }
    std::string getNumberOfFramesInOverlayTag() const { return std::string("(60xx,0015)"); }
    
    // OverlayBitPosition (60xx,0102) vr=US, vm=1, type=1
    bool getOverlayBitPosition(MLuint16& parameter) const;
    bool setOverlayBitPosition(const MLuint16 parameter);
    std::string getOverlayBitPositionVR() const { return "US"; }
    std::string getOverlayBitPositionVM() const { return "1"; }
    std::string getOverlayBitPositionTag() const { return std::string("(60xx,0102)"); }
    
    // OverlayBitsAllocated (60xx,0100) vr=US, vm=1, type=1
    bool getOverlayBitsAllocated(MLuint16& parameter) const;
    bool setOverlayBitsAllocated(const MLuint16 parameter);
    std::string getOverlayBitsAllocatedVR() const { return "US"; }
    std::string getOverlayBitsAllocatedVM() const { return "1"; }
    std::string getOverlayBitsAllocatedTag() const { return std::string("(60xx,0100)"); }
    
    // OverlayColumns (60xx,0011) vr=US, vm=1, type=1
    bool getOverlayColumns(MLuint16& parameter) const;
    bool setOverlayColumns(const MLuint16 parameter);
    std::string getOverlayColumnsVR() const { return "US"; }
    std::string getOverlayColumnsVM() const { return "1"; }
    std::string getOverlayColumnsTag() const { return std::string("(60xx,0011)"); }
    
    // OverlayDescription (60xx,0022) vr=LO, vm=1, type=3
    bool getOverlayDescription(std::string& parameter) const;
    bool setOverlayDescription(const std::string parameter);
    std::string getOverlayDescriptionVR() const { return "LO"; }
    std::string getOverlayDescriptionVM() const { return "1"; }
    std::string getOverlayDescriptionTag() const { return std::string("(60xx,0022)"); }
    
    // OverlayLabel (60xx,1500) vr=LO, vm=1, type=3
    bool getOverlayLabel(std::string& parameter) const;
    bool setOverlayLabel(const std::string parameter);
    std::string getOverlayLabelVR() const { return "LO"; }
    std::string getOverlayLabelVM() const { return "1"; }
    std::string getOverlayLabelTag() const { return std::string("(60xx,1500)"); }
    
    // OverlayOrigin (60xx,0050) vr=SS, vm=2, type=1
    bool getOverlayOrigin(int& parameter) const;
    bool setOverlayOrigin(const int parameter);
    std::string getOverlayOriginVR() const { return "SS"; }
    std::string getOverlayOriginVM() const { return "2"; }
    std::string getOverlayOriginTag() const { return std::string("(60xx,0050)"); }
    
    // OverlayRows (60xx,0010) vr=US, vm=1, type=1
    bool getOverlayRows(MLuint16& parameter) const;
    bool setOverlayRows(const MLuint16 parameter);
    std::string getOverlayRowsVR() const { return "US"; }
    std::string getOverlayRowsVM() const { return "1"; }
    std::string getOverlayRowsTag() const { return std::string("(60xx,0010)"); }
    
    // OverlaySubtype (60xx,0045) vr=LO, vm=1, type=3
    bool getOverlaySubtype(std::string& parameter) const;
    bool setOverlaySubtype(const std::string parameter);
    std::string getOverlaySubtypeVR() const { return "LO"; }
    std::string getOverlaySubtypeVM() const { return "1"; }
    std::string getOverlaySubtypeTag() const { return std::string("(60xx,0045)"); }
    
    // OverlayType (60xx,0040) vr=CS, vm=1, type=1
    bool getOverlayType(std::string& parameter) const;
    bool setOverlayType(const std::string parameter);
    std::string getOverlayTypeVR() const { return "CS"; }
    std::string getOverlayTypeVM() const { return "1"; }
    std::string getOverlayTypeTag() const { return std::string("(60xx,0040)"); }
    
    // ROIArea (60xx,1301) vr=IS, vm=1, type=3
    bool getROIArea(std::string& parameter) const;
    bool setROIArea(const std::string parameter);
    std::string getROIAreaVR() const { return "IS"; }
    std::string getROIAreaVM() const { return "1"; }
    std::string getROIAreaTag() const { return std::string("(60xx,1301)"); }
    
    // ROIMean (60xx,1302) vr=DS, vm=1, type=3
    bool getROIMean(std::string& parameter) const;
    bool setROIMean(const std::string parameter);
    std::string getROIMeanVR() const { return "DS"; }
    std::string getROIMeanVM() const { return "1"; }
    std::string getROIMeanTag() const { return std::string("(60xx,1302)"); }
    
    // ROIStandardDeviation (60xx,1303) vr=DS, vm=1, type=3
    bool getROIStandardDeviation(std::string& parameter) const;
    bool setROIStandardDeviation(const std::string parameter);
    std::string getROIStandardDeviationVR() const { return "DS"; }
    std::string getROIStandardDeviationVM() const { return "1"; }
    std::string getROIStandardDeviationTag() const { return std::string("(60xx,1303)"); }
    
    // DeidentificationMethod (0012,0063) vr=LO, vm=1-n, type=1C
    bool getDeidentificationMethod(std::string& parameter) const;
    bool setDeidentificationMethod(const std::string parameter);
    std::string getDeidentificationMethodVR() const { return "LO"; }
    std::string getDeidentificationMethodVM() const { return "1-n"; }
    std::string getDeidentificationMethodTag() const { return std::string("(0012,0063)"); }
    
    // EthnicGroup (0010,2160) vr=SH, vm=1, type=3
    bool getEthnicGroup(std::string& parameter) const;
    bool setEthnicGroup(const std::string parameter);
    std::string getEthnicGroupVR() const { return "SH"; }
    std::string getEthnicGroupVM() const { return "1"; }
    std::string getEthnicGroupTag() const { return std::string("(0010,2160)"); }
    
    // IssuerOfPatientID (0010,0021) vr=LO, vm=1, type=3
    bool getIssuerOfPatientID(std::string& parameter) const;
    bool setIssuerOfPatientID(const std::string parameter);
    std::string getIssuerOfPatientIDVR() const { return "LO"; }
    std::string getIssuerOfPatientIDVM() const { return "1"; }
    std::string getIssuerOfPatientIDTag() const { return std::string("(0010,0021)"); }
    
    // OtherPatientIDs (0010,1000) vr=LO, vm=1-n, type=3
    bool getOtherPatientIDs(std::string& parameter) const;
    bool setOtherPatientIDs(const std::string parameter);
    std::string getOtherPatientIDsVR() const { return "LO"; }
    std::string getOtherPatientIDsVM() const { return "1-n"; }
    std::string getOtherPatientIDsTag() const { return std::string("(0010,1000)"); }
    
    // OtherPatientNames (0010,1001) vr=PN, vm=1-n, type=3
    bool getOtherPatientNames(std::string& parameter) const;
    bool setOtherPatientNames(const std::string parameter);
    std::string getOtherPatientNamesVR() const { return "PN"; }
    std::string getOtherPatientNamesVM() const { return "1-n"; }
    std::string getOtherPatientNamesTag() const { return std::string("(0010,1001)"); }
    
    // PatientBirthDate (0010,0030) vr=DA, vm=1, type=2
    bool getPatientBirthDate(std::string& parameter) const;
    bool setPatientBirthDate(const std::string parameter);
    std::string getPatientBirthDateVR() const { return "DA"; }
    std::string getPatientBirthDateVM() const { return "1"; }
    std::string getPatientBirthDateTag() const { return std::string("(0010,0030)"); }
    
    // PatientBirthTime (0010,0032) vr=TM, vm=1, type=3
    bool getPatientBirthTime(std::string& parameter) const;
    bool setPatientBirthTime(const std::string parameter);
    std::string getPatientBirthTimeVR() const { return "TM"; }
    std::string getPatientBirthTimeVM() const { return "1"; }
    std::string getPatientBirthTimeTag() const { return std::string("(0010,0032)"); }
    
    // PatientBreedDescription (0010,2292) vr=LO, vm=1, type=2C
    bool getPatientBreedDescription(std::string& parameter) const;
    bool setPatientBreedDescription(const std::string parameter);
    std::string getPatientBreedDescriptionVR() const { return "LO"; }
    std::string getPatientBreedDescriptionVM() const { return "1"; }
    std::string getPatientBreedDescriptionTag() const { return std::string("(0010,2292)"); }
    
    // PatientComments (0010,4000) vr=LT, vm=1, type=3
    bool getPatientComments(std::string& parameter) const;
    bool setPatientComments(const std::string parameter);
    std::string getPatientCommentsVR() const { return "LT"; }
    std::string getPatientCommentsVM() const { return "1"; }
    std::string getPatientCommentsTag() const { return std::string("(0010,4000)"); }
    
    // PatientID (0010,0020) vr=LO, vm=1, type=2
    bool getPatientID(std::string& parameter) const;
    bool setPatientID(const std::string parameter);
    std::string getPatientIDVR() const { return "LO"; }
    std::string getPatientIDVM() const { return "1"; }
    std::string getPatientIDTag() const { return std::string("(0010,0020)"); }
    
    // PatientIdentityRemoved (0012,0062) vr=CS, vm=1, type=3
    bool getPatientIdentityRemoved(std::string& parameter) const;
    bool setPatientIdentityRemoved(const std::string parameter);
    std::string getPatientIdentityRemovedVR() const { return "CS"; }
    std::string getPatientIdentityRemovedVM() const { return "1"; }
    std::string getPatientIdentityRemovedTag() const { return std::string("(0012,0062)"); }
    
    // PatientName (0010,0010) vr=PN, vm=1, type=2
    bool getPatientName(std::string& parameter) const;
    bool setPatientName(const std::string parameter);
    std::string getPatientNameVR() const { return "PN"; }
    std::string getPatientNameVM() const { return "1"; }
    std::string getPatientNameTag() const { return std::string("(0010,0010)"); }
    
    // PatientSex (0010,0040) vr=CS, vm=1, type=2
    bool getPatientSex(std::string& parameter) const;
    bool setPatientSex(const std::string parameter);
    std::string getPatientSexVR() const { return "CS"; }
    std::string getPatientSexVM() const { return "1"; }
    std::string getPatientSexTag() const { return std::string("(0010,0040)"); }
    
    // PatientSpeciesDescription (0010,2201) vr=LO, vm=1, type=1C
    bool getPatientSpeciesDescription(std::string& parameter) const;
    bool setPatientSpeciesDescription(const std::string parameter);
    std::string getPatientSpeciesDescriptionVR() const { return "LO"; }
    std::string getPatientSpeciesDescriptionVM() const { return "1"; }
    std::string getPatientSpeciesDescriptionTag() const { return std::string("(0010,2201)"); }
    
    // ResponsibleOrganization (0010,2299) vr=LO, vm=1, type=2C
    bool getResponsibleOrganization(std::string& parameter) const;
    bool setResponsibleOrganization(const std::string parameter);
    std::string getResponsibleOrganizationVR() const { return "LO"; }
    std::string getResponsibleOrganizationVM() const { return "1"; }
    std::string getResponsibleOrganizationTag() const { return std::string("(0010,2299)"); }
    
    // ResponsiblePerson (0010,2297) vr=PN, vm=1, type=2C
    bool getResponsiblePerson(std::string& parameter) const;
    bool setResponsiblePerson(const std::string parameter);
    std::string getResponsiblePersonVR() const { return "PN"; }
    std::string getResponsiblePersonVM() const { return "1"; }
    std::string getResponsiblePersonTag() const { return std::string("(0010,2297)"); }
    
    // ResponsiblePersonRole (0010,2298) vr=CS, vm=1, type=1C
    bool getResponsiblePersonRole(std::string& parameter) const;
    bool setResponsiblePersonRole(const std::string parameter);
    std::string getResponsiblePersonRoleVR() const { return "CS"; }
    std::string getResponsiblePersonRoleVM() const { return "1"; }
    std::string getResponsiblePersonRoleTag() const { return std::string("(0010,2298)"); }
    
    // AdditionalPatientHistory (0010,21b0) vr=LT, vm=1, type=3
    bool getAdditionalPatientHistory(std::string& parameter) const;
    bool setAdditionalPatientHistory(const std::string parameter);
    std::string getAdditionalPatientHistoryVR() const { return "LT"; }
    std::string getAdditionalPatientHistoryVM() const { return "1"; }
    std::string getAdditionalPatientHistoryTag() const { return std::string("(0010,21b0)"); }
    
    // AdmissionID (0038,0010) vr=LO, vm=1, type=3
    bool getAdmissionID(std::string& parameter) const;
    bool setAdmissionID(const std::string parameter);
    std::string getAdmissionIDVR() const { return "LO"; }
    std::string getAdmissionIDVM() const { return "1"; }
    std::string getAdmissionIDTag() const { return std::string("(0038,0010)"); }
    
    // AdmittingDiagnosesDescription (0008,1080) vr=LO, vm=1-n, type=3
    bool getAdmittingDiagnosesDescription(std::string& parameter) const;
    bool setAdmittingDiagnosesDescription(const std::string parameter);
    std::string getAdmittingDiagnosesDescriptionVR() const { return "LO"; }
    std::string getAdmittingDiagnosesDescriptionVM() const { return "1-n"; }
    std::string getAdmittingDiagnosesDescriptionTag() const { return std::string("(0008,1080)"); }
    
    // IssuerOfAdmissionID (0038,0011) vr=LO, vm=1, type=3
    bool getIssuerOfAdmissionID(std::string& parameter) const;
    bool setIssuerOfAdmissionID(const std::string parameter);
    std::string getIssuerOfAdmissionIDVR() const { return "LO"; }
    std::string getIssuerOfAdmissionIDVM() const { return "1"; }
    std::string getIssuerOfAdmissionIDTag() const { return std::string("(0038,0011)"); }
    
    // Occupation (0010,2180) vr=SH, vm=1, type=3
    bool getOccupation(std::string& parameter) const;
    bool setOccupation(const std::string parameter);
    std::string getOccupationVR() const { return "SH"; }
    std::string getOccupationVM() const { return "1"; }
    std::string getOccupationTag() const { return std::string("(0010,2180)"); }
    
    // PatientAge (0010,1010) vr=AS, vm=1, type=3
    bool getPatientAge(std::string& parameter) const;
    bool setPatientAge(const std::string parameter);
    std::string getPatientAgeVR() const { return "AS"; }
    std::string getPatientAgeVM() const { return "1"; }
    std::string getPatientAgeTag() const { return std::string("(0010,1010)"); }
    
    // PatientSexNeutered (0010,2203) vr=CS, vm=1, type=2C
    bool getPatientSexNeutered(std::string& parameter) const;
    bool setPatientSexNeutered(const std::string parameter);
    std::string getPatientSexNeuteredVR() const { return "CS"; }
    std::string getPatientSexNeuteredVM() const { return "1"; }
    std::string getPatientSexNeuteredTag() const { return std::string("(0010,2203)"); }
    
    // PatientSize (0010,1020) vr=DS, vm=1, type=3
    bool getPatientSize(std::string& parameter) const;
    bool setPatientSize(const std::string parameter);
    std::string getPatientSizeVR() const { return "DS"; }
    std::string getPatientSizeVM() const { return "1"; }
    std::string getPatientSizeTag() const { return std::string("(0010,1020)"); }
    
    // PatientWeight (0010,1030) vr=DS, vm=1, type=3
    bool getPatientWeight(std::string& parameter) const;
    bool setPatientWeight(const std::string parameter);
    std::string getPatientWeightVR() const { return "DS"; }
    std::string getPatientWeightVM() const { return "1"; }
    std::string getPatientWeightTag() const { return std::string("(0010,1030)"); }
    
    // DVHNormalizationDoseValue (3004,0042) vr=DS, vm=1, type=3
    bool getDVHNormalizationDoseValue(std::string& parameter) const;
    bool setDVHNormalizationDoseValue(const std::string parameter);
    std::string getDVHNormalizationDoseValueVR() const { return "DS"; }
    std::string getDVHNormalizationDoseValueVM() const { return "1"; }
    std::string getDVHNormalizationDoseValueTag() const { return std::string("(3004,0042)"); }
    
    // DVHNormalizationPoint (3004,0040) vr=DS, vm=3, type=3
    bool getDVHNormalizationPoint(std::string& parameter) const;
    bool setDVHNormalizationPoint(const std::string parameter);
    std::string getDVHNormalizationPointVR() const { return "DS"; }
    std::string getDVHNormalizationPointVM() const { return "3"; }
    std::string getDVHNormalizationPointTag() const { return std::string("(3004,0040)"); }
    
    // BitsAllocated (0028,0100) vr=US, vm=1, type=1C
    bool getBitsAllocated(MLuint16& parameter) const;
    bool setBitsAllocated(const MLuint16 parameter);
    std::string getBitsAllocatedVR() const { return "US"; }
    std::string getBitsAllocatedVM() const { return "1"; }
    std::string getBitsAllocatedTag() const { return std::string("(0028,0100)"); }
    
    // BitsStored (0028,0101) vr=US, vm=1, type=1C
    bool getBitsStored(MLuint16& parameter) const;
    bool setBitsStored(const MLuint16 parameter);
    std::string getBitsStoredVR() const { return "US"; }
    std::string getBitsStoredVM() const { return "1"; }
    std::string getBitsStoredTag() const { return std::string("(0028,0101)"); }
    
    // DoseComment (3004,0006) vr=LO, vm=1, type=3
    bool getDoseComment(std::string& parameter) const;
    bool setDoseComment(const std::string parameter);
    std::string getDoseCommentVR() const { return "LO"; }
    std::string getDoseCommentVM() const { return "1"; }
    std::string getDoseCommentTag() const { return std::string("(3004,0006)"); }
    
    // DoseGridScaling (3004,000e) vr=DS, vm=1, type=1
    bool getDoseGridScaling(std::string& parameter) const;
    bool setDoseGridScaling(const std::string parameter);
    std::string getDoseGridScalingVR() const { return "DS"; }
    std::string getDoseGridScalingVM() const { return "1"; }
    std::string getDoseGridScalingTag() const { return std::string("(3004,000e)"); }
    
    // DoseSummationType (3004,000a) vr=CS, vm=1, type=1
    bool getDoseSummationType(std::string& parameter) const;
    bool setDoseSummationType(const std::string parameter);
    std::string getDoseSummationTypeVR() const { return "CS"; }
    std::string getDoseSummationTypeVM() const { return "1"; }
    std::string getDoseSummationTypeTag() const { return std::string("(3004,000a)"); }
    
    // DoseType (3004,0004) vr=CS, vm=1, type=1
    bool getDoseType(std::string& parameter) const;
    bool setDoseType(const std::string parameter);
    std::string getDoseTypeVR() const { return "CS"; }
    std::string getDoseTypeVM() const { return "1"; }
    std::string getDoseTypeTag() const { return std::string("(3004,0004)"); }
    
    // DoseUnits (3004,0002) vr=CS, vm=1, type=1
    bool getDoseUnits(std::string& parameter) const;
    bool setDoseUnits(const std::string parameter);
    std::string getDoseUnitsVR() const { return "CS"; }
    std::string getDoseUnitsVM() const { return "1"; }
    std::string getDoseUnitsTag() const { return std::string("(3004,0002)"); }
    
    // GridFrameOffsetVector (3004,000c) vr=DS, vm=2-n, type=1C
    bool getGridFrameOffsetVector(std::string& parameter) const;
    bool setGridFrameOffsetVector(const std::string parameter);
    std::string getGridFrameOffsetVectorVR() const { return "DS"; }
    std::string getGridFrameOffsetVectorVM() const { return "2-n"; }
    std::string getGridFrameOffsetVectorTag() const { return std::string("(3004,000c)"); }
    
    // HighBit (0028,0102) vr=US, vm=1, type=1C
    bool getHighBit(MLuint16& parameter) const;
    bool setHighBit(const MLuint16 parameter);
    std::string getHighBitVR() const { return "US"; }
    std::string getHighBitVM() const { return "1"; }
    std::string getHighBitTag() const { return std::string("(0028,0102)"); }
    
    // InstanceNumber (0020,0013) vr=IS, vm=1, type=3
    bool getInstanceNumber(std::string& parameter) const;
    bool setInstanceNumber(const std::string parameter);
    std::string getInstanceNumberVR() const { return "IS"; }
    std::string getInstanceNumberVM() const { return "1"; }
    std::string getInstanceNumberTag() const { return std::string("(0020,0013)"); }
    
    // NormalizationPoint (3004,0008) vr=DS, vm=3, type=3
    bool getNormalizationPoint(std::string& parameter) const;
    bool setNormalizationPoint(const std::string parameter);
    std::string getNormalizationPointVR() const { return "DS"; }
    std::string getNormalizationPointVM() const { return "3"; }
    std::string getNormalizationPointTag() const { return std::string("(3004,0008)"); }
    
    // PhotometricInterpretation (0028,0004) vr=CS, vm=1, type=1C
    bool getPhotometricInterpretation(std::string& parameter) const;
    bool setPhotometricInterpretation(const std::string parameter);
    std::string getPhotometricInterpretationVR() const { return "CS"; }
    std::string getPhotometricInterpretationVM() const { return "1"; }
    std::string getPhotometricInterpretationTag() const { return std::string("(0028,0004)"); }
    
    // PixelRepresentation (0028,0103) vr=US, vm=1, type=1C
    bool getPixelRepresentation(MLuint16& parameter) const;
    bool setPixelRepresentation(const MLuint16 parameter);
    std::string getPixelRepresentationVR() const { return "US"; }
    std::string getPixelRepresentationVM() const { return "1"; }
    std::string getPixelRepresentationTag() const { return std::string("(0028,0103)"); }
    
    // SamplesPerPixel (0028,0002) vr=US, vm=1, type=1C
    bool getSamplesPerPixel(MLuint16& parameter) const;
    bool setSamplesPerPixel(const MLuint16 parameter);
    std::string getSamplesPerPixelVR() const { return "US"; }
    std::string getSamplesPerPixelVM() const { return "1"; }
    std::string getSamplesPerPixelTag() const { return std::string("(0028,0002)"); }
    
    // TissueHeterogeneityCorrection (3004,0014) vr=CS, vm=1-3, type=3
    bool getTissueHeterogeneityCorrection(std::string& parameter) const;
    bool setTissueHeterogeneityCorrection(const std::string parameter);
    std::string getTissueHeterogeneityCorrectionVR() const { return "CS"; }
    std::string getTissueHeterogeneityCorrectionVM() const { return "1-3"; }
    std::string getTissueHeterogeneityCorrectionTag() const { return std::string("(3004,0014)"); }
    
    // Modality (0008,0060) vr=CS, vm=1, type=1
    bool getModality(std::string& parameter) const;
    bool setModality(const std::string parameter);
    std::string getModalityVR() const { return "CS"; }
    std::string getModalityVM() const { return "1"; }
    std::string getModalityTag() const { return std::string("(0008,0060)"); }
    
    // PerformedProcedureStepDescription (0040,0254) vr=LO, vm=1, type=3
    bool getPerformedProcedureStepDescription(std::string& parameter) const;
    bool setPerformedProcedureStepDescription(const std::string parameter);
    std::string getPerformedProcedureStepDescriptionVR() const { return "LO"; }
    std::string getPerformedProcedureStepDescriptionVM() const { return "1"; }
    std::string getPerformedProcedureStepDescriptionTag() const { return std::string("(0040,0254)"); }
    
    // PerformedProcedureStepID (0040,0253) vr=SH, vm=1, type=3
    bool getPerformedProcedureStepID(std::string& parameter) const;
    bool setPerformedProcedureStepID(const std::string parameter);
    std::string getPerformedProcedureStepIDVR() const { return "SH"; }
    std::string getPerformedProcedureStepIDVM() const { return "1"; }
    std::string getPerformedProcedureStepIDTag() const { return std::string("(0040,0253)"); }
    
    // PerformedProcedureStepStartDate (0040,0244) vr=DA, vm=1, type=3
    bool getPerformedProcedureStepStartDate(std::string& parameter) const;
    bool setPerformedProcedureStepStartDate(const std::string parameter);
    std::string getPerformedProcedureStepStartDateVR() const { return "DA"; }
    std::string getPerformedProcedureStepStartDateVM() const { return "1"; }
    std::string getPerformedProcedureStepStartDateTag() const { return std::string("(0040,0244)"); }
    
    // PerformedProcedureStepStartTime (0040,0245) vr=TM, vm=1, type=3
    bool getPerformedProcedureStepStartTime(std::string& parameter) const;
    bool setPerformedProcedureStepStartTime(const std::string parameter);
    std::string getPerformedProcedureStepStartTimeVR() const { return "TM"; }
    std::string getPerformedProcedureStepStartTimeVM() const { return "1"; }
    std::string getPerformedProcedureStepStartTimeTag() const { return std::string("(0040,0245)"); }
    
    // SeriesDescription (0008,103e) vr=LO, vm=1, type=3
    bool getSeriesDescription(std::string& parameter) const;
    bool setSeriesDescription(const std::string parameter);
    std::string getSeriesDescriptionVR() const { return "LO"; }
    std::string getSeriesDescriptionVM() const { return "1"; }
    std::string getSeriesDescriptionTag() const { return std::string("(0008,103e)"); }
    
    // SeriesInstanceUID (0020,000e) vr=UI, vm=1, type=1
    bool getSeriesInstanceUID(std::string& parameter) const;
    bool setSeriesInstanceUID(const std::string parameter);
    std::string getSeriesInstanceUIDVR() const { return "UI"; }
    std::string getSeriesInstanceUIDVM() const { return "1"; }
    std::string getSeriesInstanceUIDTag() const { return std::string("(0020,000e)"); }
    
    // SeriesNumber (0020,0011) vr=IS, vm=1, type=2
    bool getSeriesNumber(std::string& parameter) const;
    bool setSeriesNumber(const std::string parameter);
    std::string getSeriesNumberVR() const { return "IS"; }
    std::string getSeriesNumberVM() const { return "1"; }
    std::string getSeriesNumberTag() const { return std::string("(0020,0011)"); }
    
    // AuthorizationEquipmentCertificationNumber (0100,0426) vr=LO, vm=1, type=3
    bool getAuthorizationEquipmentCertificationNumber(std::string& parameter) const;
    bool setAuthorizationEquipmentCertificationNumber(const std::string parameter);
    std::string getAuthorizationEquipmentCertificationNumberVR() const { return "LO"; }
    std::string getAuthorizationEquipmentCertificationNumberVM() const { return "1"; }
    std::string getAuthorizationEquipmentCertificationNumberTag() const { return std::string("(0100,0426)"); }
    
    // InstanceCreationDate (0008,0012) vr=DA, vm=1, type=3
    bool getInstanceCreationDate(std::string& parameter) const;
    bool setInstanceCreationDate(const std::string parameter);
    std::string getInstanceCreationDateVR() const { return "DA"; }
    std::string getInstanceCreationDateVM() const { return "1"; }
    std::string getInstanceCreationDateTag() const { return std::string("(0008,0012)"); }
    
    // InstanceCreationTime (0008,0013) vr=TM, vm=1, type=3
    bool getInstanceCreationTime(std::string& parameter) const;
    bool setInstanceCreationTime(const std::string parameter);
    std::string getInstanceCreationTimeVR() const { return "TM"; }
    std::string getInstanceCreationTimeVM() const { return "1"; }
    std::string getInstanceCreationTimeTag() const { return std::string("(0008,0013)"); }
    
    // InstanceCreatorUID (0008,0014) vr=UI, vm=1, type=3
    bool getInstanceCreatorUID(std::string& parameter) const;
    bool setInstanceCreatorUID(const std::string parameter);
    std::string getInstanceCreatorUIDVR() const { return "UI"; }
    std::string getInstanceCreatorUIDVM() const { return "1"; }
    std::string getInstanceCreatorUIDTag() const { return std::string("(0008,0014)"); }
    
    // OriginalSpecializedSOPClassUID (0008,001b) vr=UI, vm=1, type=3
    bool getOriginalSpecializedSOPClassUID(std::string& parameter) const;
    bool setOriginalSpecializedSOPClassUID(const std::string parameter);
    std::string getOriginalSpecializedSOPClassUIDVR() const { return "UI"; }
    std::string getOriginalSpecializedSOPClassUIDVM() const { return "1"; }
    std::string getOriginalSpecializedSOPClassUIDTag() const { return std::string("(0008,001b)"); }
    
    // RelatedGeneralSOPClassUID (0008,001a) vr=UI, vm=1-n, type=3
    bool getRelatedGeneralSOPClassUID(std::string& parameter) const;
    bool setRelatedGeneralSOPClassUID(const std::string parameter);
    std::string getRelatedGeneralSOPClassUIDVR() const { return "UI"; }
    std::string getRelatedGeneralSOPClassUIDVM() const { return "1-n"; }
    std::string getRelatedGeneralSOPClassUIDTag() const { return std::string("(0008,001a)"); }
    
    // SOPAuthorizationComment (0100,0424) vr=LT, vm=1, type=3
    bool getSOPAuthorizationComment(std::string& parameter) const;
    bool setSOPAuthorizationComment(const std::string parameter);
    std::string getSOPAuthorizationCommentVR() const { return "LT"; }
    std::string getSOPAuthorizationCommentVM() const { return "1"; }
    std::string getSOPAuthorizationCommentTag() const { return std::string("(0100,0424)"); }
    
    // SOPAuthorizationDateTime (0100,0420) vr=DT, vm=1, type=3
    bool getSOPAuthorizationDateTime(std::string& parameter) const;
    bool setSOPAuthorizationDateTime(const std::string parameter);
    std::string getSOPAuthorizationDateTimeVR() const { return "DT"; }
    std::string getSOPAuthorizationDateTimeVM() const { return "1"; }
    std::string getSOPAuthorizationDateTimeTag() const { return std::string("(0100,0420)"); }
    
    // SOPClassUID (0008,0016) vr=UI, vm=1, type=1
    bool getSOPClassUID(std::string& parameter) const;
    bool setSOPClassUID(const std::string parameter);
    std::string getSOPClassUIDVR() const { return "UI"; }
    std::string getSOPClassUIDVM() const { return "1"; }
    std::string getSOPClassUIDTag() const { return std::string("(0008,0016)"); }
    
    // SOPInstanceStatus (0100,0410) vr=CS, vm=1, type=3
    bool getSOPInstanceStatus(std::string& parameter) const;
    bool setSOPInstanceStatus(const std::string parameter);
    std::string getSOPInstanceStatusVR() const { return "CS"; }
    std::string getSOPInstanceStatusVM() const { return "1"; }
    std::string getSOPInstanceStatusTag() const { return std::string("(0100,0410)"); }
    
    // SOPInstanceUID (0008,0018) vr=UI, vm=1, type=1
    bool getSOPInstanceUID(std::string& parameter) const;
    bool setSOPInstanceUID(const std::string parameter);
    std::string getSOPInstanceUIDVR() const { return "UI"; }
    std::string getSOPInstanceUIDVM() const { return "1"; }
    std::string getSOPInstanceUIDTag() const { return std::string("(0008,0018)"); }
    
    // SpecificCharacterSet (0008,0005) vr=CS, vm=1-n, type=1C
    bool getSpecificCharacterSet(std::string& parameter) const;
    bool setSpecificCharacterSet(const std::string parameter);
    std::string getSpecificCharacterSetVR() const { return "CS"; }
    std::string getSpecificCharacterSetVM() const { return "1-n"; }
    std::string getSpecificCharacterSetTag() const { return std::string("(0008,0005)"); }
    
    // TimezoneOffsetFromUTC (0008,0201) vr=SH, vm=1, type=3
    bool getTimezoneOffsetFromUTC(std::string& parameter) const;
    bool setTimezoneOffsetFromUTC(const std::string parameter);
    std::string getTimezoneOffsetFromUTCVR() const { return "SH"; }
    std::string getTimezoneOffsetFromUTCVM() const { return "1"; }
    std::string getTimezoneOffsetFromUTCTag() const { return std::string("(0008,0201)"); }
    
    // StructureSetDate (3006,0008) vr=DA, vm=1, type=2
    bool getStructureSetDate(std::string& parameter) const;
    bool setStructureSetDate(const std::string parameter);
    std::string getStructureSetDateVR() const { return "DA"; }
    std::string getStructureSetDateVM() const { return "1"; }
    std::string getStructureSetDateTag() const { return std::string("(3006,0008)"); }
    
    // StructureSetDescription (3006,0006) vr=ST, vm=1, type=3
    bool getStructureSetDescription(std::string& parameter) const;
    bool setStructureSetDescription(const std::string parameter);
    std::string getStructureSetDescriptionVR() const { return "ST"; }
    std::string getStructureSetDescriptionVM() const { return "1"; }
    std::string getStructureSetDescriptionTag() const { return std::string("(3006,0006)"); }
    
    // StructureSetLabel (3006,0002) vr=SH, vm=1, type=1
    bool getStructureSetLabel(std::string& parameter) const;
    bool setStructureSetLabel(const std::string parameter);
    std::string getStructureSetLabelVR() const { return "SH"; }
    std::string getStructureSetLabelVM() const { return "1"; }
    std::string getStructureSetLabelTag() const { return std::string("(3006,0002)"); }
    
    // StructureSetName (3006,0004) vr=LO, vm=1, type=3
    bool getStructureSetName(std::string& parameter) const;
    bool setStructureSetName(const std::string parameter);
    std::string getStructureSetNameVR() const { return "LO"; }
    std::string getStructureSetNameVM() const { return "1"; }
    std::string getStructureSetNameTag() const { return std::string("(3006,0004)"); }
    
    // StructureSetTime (3006,0009) vr=TM, vm=1, type=2
    bool getStructureSetTime(std::string& parameter) const;
    bool setStructureSetTime(const std::string parameter);
    std::string getStructureSetTimeVR() const { return "TM"; }
    std::string getStructureSetTimeVM() const { return "1"; }
    std::string getStructureSetTimeTag() const { return std::string("(3006,0009)"); }
    
 
    // DerivationCodeSequence (0008,9215) vr=SQ, vm=1, type=3
    virtual DcmDRTDerivationCodeSequenceInterface getDerivationCodeSequence();
    virtual DcmDRTDerivationCodeSequenceInterface getEmptyDerivationCodeSequence();
    void setDerivationCodeSequence(DcmDRTDerivationCodeSequenceInterface seq);
 
    std::string getDerivationCodeSequenceVR() const { return "SQ"; }
    std::string getDerivationCodeSequenceVM() const { return "1"; }
    std::string getDerivationCodeSequenceTag() { return std::string("(0008,9215)"); }
 
    // IconImageSequence (0088,0200) vr=SQ, vm=1, type=3
    virtual DcmDRTIconImageSequenceInterface getIconImageSequence();
    virtual DcmDRTIconImageSequenceInterface getEmptyIconImageSequence();
    void setIconImageSequence(DcmDRTIconImageSequenceInterface seq);
 
    std::string getIconImageSequenceVR() const { return "SQ"; }
    std::string getIconImageSequenceVM() const { return "1"; }
    std::string getIconImageSequenceTag() { return std::string("(0088,0200)"); }
 
    // ReferencedImageSequence (0008,1140) vr=SQ, vm=1, type=3
    virtual DcmDRTReferencedImageSequenceInterface getReferencedImageSequence();
    virtual DcmDRTReferencedImageSequenceInterface getEmptyReferencedImageSequence();
    void setReferencedImageSequence(DcmDRTReferencedImageSequenceInterface seq);
 
    std::string getReferencedImageSequenceVR() const { return "SQ"; }
    std::string getReferencedImageSequenceVM() const { return "1"; }
    std::string getReferencedImageSequenceTag() { return std::string("(0008,1140)"); }
 
    // ReferencedInstanceSequence (0008,114a) vr=SQ, vm=1, type=3
    virtual DcmDRTReferencedInstanceSequenceInterface getReferencedInstanceSequence();
    virtual DcmDRTReferencedInstanceSequenceInterface getEmptyReferencedInstanceSequence();
    void setReferencedInstanceSequence(DcmDRTReferencedInstanceSequenceInterface seq);
 
    std::string getReferencedInstanceSequenceVR() const { return "SQ"; }
    std::string getReferencedInstanceSequenceVM() const { return "1"; }
    std::string getReferencedInstanceSequenceTag() { return std::string("(0008,114a)"); }
 
    // SourceImageSequence (0008,2112) vr=SQ, vm=1, type=3
    virtual DcmDRTSourceImageSequenceInterface getSourceImageSequence();
    virtual DcmDRTSourceImageSequenceInterface getEmptySourceImageSequence();
    void setSourceImageSequence(DcmDRTSourceImageSequenceInterface seq);
 
    std::string getSourceImageSequenceVR() const { return "SQ"; }
    std::string getSourceImageSequenceVM() const { return "1"; }
    std::string getSourceImageSequenceTag() { return std::string("(0008,2112)"); }
 
    // PhysiciansOfRecordIdentificationSequence (0008,1049) vr=SQ, vm=1, type=3
    virtual DcmDRTPhysiciansOfRecordIdentificationSequenceInterface getPhysiciansOfRecordIdentificationSequence();
    virtual DcmDRTPhysiciansOfRecordIdentificationSequenceInterface getEmptyPhysiciansOfRecordIdentificationSequence();
    void setPhysiciansOfRecordIdentificationSequence(DcmDRTPhysiciansOfRecordIdentificationSequenceInterface seq);
 
    std::string getPhysiciansOfRecordIdentificationSequenceVR() const { return "SQ"; }
    std::string getPhysiciansOfRecordIdentificationSequenceVM() const { return "1"; }
    std::string getPhysiciansOfRecordIdentificationSequenceTag() { return std::string("(0008,1049)"); }
 
    // PhysiciansReadingStudyIdentificationSequence (0008,1062) vr=SQ, vm=1, type=3
    virtual DcmDRTPhysiciansReadingStudyIdentificationSequenceInterface getPhysiciansReadingStudyIdentificationSequence();
    virtual DcmDRTPhysiciansReadingStudyIdentificationSequenceInterface getEmptyPhysiciansReadingStudyIdentificationSequence();
    void setPhysiciansReadingStudyIdentificationSequence(DcmDRTPhysiciansReadingStudyIdentificationSequenceInterface seq);
 
    std::string getPhysiciansReadingStudyIdentificationSequenceVR() const { return "SQ"; }
    std::string getPhysiciansReadingStudyIdentificationSequenceVM() const { return "1"; }
    std::string getPhysiciansReadingStudyIdentificationSequenceTag() { return std::string("(0008,1062)"); }
 
    // ProcedureCodeSequence (0008,1032) vr=SQ, vm=1, type=3
    virtual DcmDRTProcedureCodeSequenceInterface getProcedureCodeSequence();
    virtual DcmDRTProcedureCodeSequenceInterface getEmptyProcedureCodeSequence();
    void setProcedureCodeSequence(DcmDRTProcedureCodeSequenceInterface seq);
 
    std::string getProcedureCodeSequenceVR() const { return "SQ"; }
    std::string getProcedureCodeSequenceVM() const { return "1"; }
    std::string getProcedureCodeSequenceTag() { return std::string("(0008,1032)"); }
 
    // ReferencedStudySequence (0008,1110) vr=SQ, vm=1, type=3
    virtual DcmDRTReferencedStudySequenceInterface getReferencedStudySequence();
    virtual DcmDRTReferencedStudySequenceInterface getEmptyReferencedStudySequence();
    void setReferencedStudySequence(DcmDRTReferencedStudySequenceInterface seq);
 
    std::string getReferencedStudySequenceVR() const { return "SQ"; }
    std::string getReferencedStudySequenceVM() const { return "1"; }
    std::string getReferencedStudySequenceTag() { return std::string("(0008,1110)"); }
 
    // ReferringPhysicianIdentificationSequence (0008,0096) vr=SQ, vm=1, type=3
    virtual DcmDRTReferringPhysicianIdentificationSequenceInterface getReferringPhysicianIdentificationSequence();
    virtual DcmDRTReferringPhysicianIdentificationSequenceInterface getEmptyReferringPhysicianIdentificationSequence();
    void setReferringPhysicianIdentificationSequence(DcmDRTReferringPhysicianIdentificationSequenceInterface seq);
 
    std::string getReferringPhysicianIdentificationSequenceVR() const { return "SQ"; }
    std::string getReferringPhysicianIdentificationSequenceVM() const { return "1"; }
    std::string getReferringPhysicianIdentificationSequenceTag() { return std::string("(0008,0096)"); }
 
    // ModalityLUTSequence (0028,3000) vr=SQ, vm=1, type=1C
    virtual DcmDRTModalityLUTSequenceInterface getModalityLUTSequence();
    virtual DcmDRTModalityLUTSequenceInterface getEmptyModalityLUTSequence();
    void setModalityLUTSequence(DcmDRTModalityLUTSequenceInterface seq);
 
    std::string getModalityLUTSequenceVR() const { return "SQ"; }
    std::string getModalityLUTSequenceVM() const { return "1"; }
    std::string getModalityLUTSequenceTag() { return std::string("(0028,3000)"); }
 
    // BreedRegistrationSequence (0010,2294) vr=SQ, vm=1, type=2C
    virtual DcmDRTBreedRegistrationSequenceInterface getBreedRegistrationSequence();
    virtual DcmDRTBreedRegistrationSequenceInterface getEmptyBreedRegistrationSequence();
    void setBreedRegistrationSequence(DcmDRTBreedRegistrationSequenceInterface seq);
 
    std::string getBreedRegistrationSequenceVR() const { return "SQ"; }
    std::string getBreedRegistrationSequenceVM() const { return "1"; }
    std::string getBreedRegistrationSequenceTag() { return std::string("(0010,2294)"); }
 
    // DeidentificationMethodCodeSequence (0012,0064) vr=SQ, vm=1, type=1C
    virtual DcmDRTDeidentificationMethodCodeSequenceInterface getDeidentificationMethodCodeSequence();
    virtual DcmDRTDeidentificationMethodCodeSequenceInterface getEmptyDeidentificationMethodCodeSequence();
    void setDeidentificationMethodCodeSequence(DcmDRTDeidentificationMethodCodeSequenceInterface seq);
 
    std::string getDeidentificationMethodCodeSequenceVR() const { return "SQ"; }
    std::string getDeidentificationMethodCodeSequenceVM() const { return "1"; }
    std::string getDeidentificationMethodCodeSequenceTag() { return std::string("(0012,0064)"); }
 
    // OtherPatientIDsSequence (0010,1002) vr=SQ, vm=1, type=3
    virtual DcmDRTOtherPatientIDsSequenceInterface getOtherPatientIDsSequence();
    virtual DcmDRTOtherPatientIDsSequenceInterface getEmptyOtherPatientIDsSequence();
    void setOtherPatientIDsSequence(DcmDRTOtherPatientIDsSequenceInterface seq);
 
    std::string getOtherPatientIDsSequenceVR() const { return "SQ"; }
    std::string getOtherPatientIDsSequenceVM() const { return "1"; }
    std::string getOtherPatientIDsSequenceTag() { return std::string("(0010,1002)"); }
 
    // PatientBreedCodeSequence (0010,2293) vr=SQ, vm=1, type=2C
    virtual DcmDRTPatientBreedCodeSequenceInterface getPatientBreedCodeSequence();
    virtual DcmDRTPatientBreedCodeSequenceInterface getEmptyPatientBreedCodeSequence();
    void setPatientBreedCodeSequence(DcmDRTPatientBreedCodeSequenceInterface seq);
 
    std::string getPatientBreedCodeSequenceVR() const { return "SQ"; }
    std::string getPatientBreedCodeSequenceVM() const { return "1"; }
    std::string getPatientBreedCodeSequenceTag() { return std::string("(0010,2293)"); }
 
    // PatientSpeciesCodeSequence (0010,2202) vr=SQ, vm=1, type=1C
    virtual DcmDRTPatientSpeciesCodeSequenceInterface getPatientSpeciesCodeSequence();
    virtual DcmDRTPatientSpeciesCodeSequenceInterface getEmptyPatientSpeciesCodeSequence();
    void setPatientSpeciesCodeSequence(DcmDRTPatientSpeciesCodeSequenceInterface seq);
 
    std::string getPatientSpeciesCodeSequenceVR() const { return "SQ"; }
    std::string getPatientSpeciesCodeSequenceVM() const { return "1"; }
    std::string getPatientSpeciesCodeSequenceTag() { return std::string("(0010,2202)"); }
 
    // ReferencedPatientSequence (0008,1120) vr=SQ, vm=1, type=3
    virtual DcmDRTReferencedPatientSequenceInterface getReferencedPatientSequence();
    virtual DcmDRTReferencedPatientSequenceInterface getEmptyReferencedPatientSequence();
    void setReferencedPatientSequence(DcmDRTReferencedPatientSequenceInterface seq);
 
    std::string getReferencedPatientSequenceVR() const { return "SQ"; }
    std::string getReferencedPatientSequenceVM() const { return "1"; }
    std::string getReferencedPatientSequenceTag() { return std::string("(0008,1120)"); }
 
    // AdmittingDiagnosesCodeSequence (0008,1084) vr=SQ, vm=1, type=3
    virtual DcmDRTAdmittingDiagnosesCodeSequenceInterface getAdmittingDiagnosesCodeSequence();
    virtual DcmDRTAdmittingDiagnosesCodeSequenceInterface getEmptyAdmittingDiagnosesCodeSequence();
    void setAdmittingDiagnosesCodeSequence(DcmDRTAdmittingDiagnosesCodeSequenceInterface seq);
 
    std::string getAdmittingDiagnosesCodeSequenceVR() const { return "SQ"; }
    std::string getAdmittingDiagnosesCodeSequenceVM() const { return "1"; }
    std::string getAdmittingDiagnosesCodeSequenceTag() { return std::string("(0008,1084)"); }
 
    // ROIContourSequence (3006,0039) vr=SQ, vm=1, type=1
    virtual DcmDRTROIContourSequenceInterface getROIContourSequence();
    virtual DcmDRTROIContourSequenceInterface getEmptyROIContourSequence();
    void setROIContourSequence(DcmDRTROIContourSequenceInterface seq);
 
    std::string getROIContourSequenceVR() const { return "SQ"; }
    std::string getROIContourSequenceVM() const { return "1"; }
    std::string getROIContourSequenceTag() { return std::string("(3006,0039)"); }
 
    // DVHSequence (3004,0050) vr=SQ, vm=1, type=1
    virtual DcmDRTDVHSequenceInterface getDVHSequence();
    virtual DcmDRTDVHSequenceInterface getEmptyDVHSequence();
    void setDVHSequence(DcmDRTDVHSequenceInterface seq);
 
    std::string getDVHSequenceVR() const { return "SQ"; }
    std::string getDVHSequenceVM() const { return "1"; }
    std::string getDVHSequenceTag() { return std::string("(3004,0050)"); }
 
    // ReferencedStructureSetSequence (300c,0060) vr=SQ, vm=1, type=1
    virtual DcmDRTReferencedStructureSetSequenceInterface getReferencedStructureSetSequence();
    virtual DcmDRTReferencedStructureSetSequenceInterface getEmptyReferencedStructureSetSequence();
    void setReferencedStructureSetSequence(DcmDRTReferencedStructureSetSequenceInterface seq);
 
    std::string getReferencedStructureSetSequenceVR() const { return "SQ"; }
    std::string getReferencedStructureSetSequenceVM() const { return "1"; }
    std::string getReferencedStructureSetSequenceTag() { return std::string("(300c,0060)"); }
 
    // ReferencedRTPlanSequence (300c,0002) vr=SQ, vm=1, type=1C
    virtual DcmDRTReferencedRTPlanSequenceInterface getReferencedRTPlanSequence();
    virtual DcmDRTReferencedRTPlanSequenceInterface getEmptyReferencedRTPlanSequence();
    void setReferencedRTPlanSequence(DcmDRTReferencedRTPlanSequenceInterface seq);
 
    std::string getReferencedRTPlanSequenceVR() const { return "SQ"; }
    std::string getReferencedRTPlanSequenceVM() const { return "1"; }
    std::string getReferencedRTPlanSequenceTag() { return std::string("(300c,0002)"); }
 
    // RTDoseROISequence (3004,0010) vr=SQ, vm=1, type=1
    virtual DcmDRTRTDoseROISequenceInterface getRTDoseROISequence();
    virtual DcmDRTRTDoseROISequenceInterface getEmptyRTDoseROISequence();
    void setRTDoseROISequence(DcmDRTRTDoseROISequenceInterface seq);
 
    std::string getRTDoseROISequenceVR() const { return "SQ"; }
    std::string getRTDoseROISequenceVM() const { return "1"; }
    std::string getRTDoseROISequenceTag() { return std::string("(3004,0010)"); }
 
    // PerformedProtocolCodeSequence (0040,0260) vr=SQ, vm=1, type=3
    virtual DcmDRTPerformedProtocolCodeSequenceInterface getPerformedProtocolCodeSequence();
    virtual DcmDRTPerformedProtocolCodeSequenceInterface getEmptyPerformedProtocolCodeSequence();
    void setPerformedProtocolCodeSequence(DcmDRTPerformedProtocolCodeSequenceInterface seq);
 
    std::string getPerformedProtocolCodeSequenceVR() const { return "SQ"; }
    std::string getPerformedProtocolCodeSequenceVM() const { return "1"; }
    std::string getPerformedProtocolCodeSequenceTag() { return std::string("(0040,0260)"); }
 
    // ReferencedPerformedProcedureStepSequence (0008,1111) vr=SQ, vm=1, type=3
    virtual DcmDRTReferencedPerformedProcedureStepSequenceInterface getReferencedPerformedProcedureStepSequence();
    virtual DcmDRTReferencedPerformedProcedureStepSequenceInterface getEmptyReferencedPerformedProcedureStepSequence();
    void setReferencedPerformedProcedureStepSequence(DcmDRTReferencedPerformedProcedureStepSequenceInterface seq);
 
    std::string getReferencedPerformedProcedureStepSequenceVR() const { return "SQ"; }
    std::string getReferencedPerformedProcedureStepSequenceVM() const { return "1"; }
    std::string getReferencedPerformedProcedureStepSequenceTag() { return std::string("(0008,1111)"); }
 
    // RequestAttributesSequence (0040,0275) vr=SQ, vm=1, type=3
    virtual DcmDRTRequestAttributesSequenceInterface getRequestAttributesSequence();
    virtual DcmDRTRequestAttributesSequenceInterface getEmptyRequestAttributesSequence();
    void setRequestAttributesSequence(DcmDRTRequestAttributesSequenceInterface seq);
 
    std::string getRequestAttributesSequenceVR() const { return "SQ"; }
    std::string getRequestAttributesSequenceVM() const { return "1"; }
    std::string getRequestAttributesSequenceTag() { return std::string("(0040,0275)"); }
 
    // CodingSchemeIdentificationSequence (0008,0110) vr=SQ, vm=1, type=3
    virtual DcmDRTCodingSchemeIdentificationSequenceInterface getCodingSchemeIdentificationSequence();
    virtual DcmDRTCodingSchemeIdentificationSequenceInterface getEmptyCodingSchemeIdentificationSequence();
    void setCodingSchemeIdentificationSequence(DcmDRTCodingSchemeIdentificationSequenceInterface seq);
 
    std::string getCodingSchemeIdentificationSequenceVR() const { return "SQ"; }
    std::string getCodingSchemeIdentificationSequenceVM() const { return "1"; }
    std::string getCodingSchemeIdentificationSequenceTag() { return std::string("(0008,0110)"); }
 
    // ContributingEquipmentSequence (0018,a001) vr=SQ, vm=1, type=3
    virtual DcmDRTContributingEquipmentSequenceInterface getContributingEquipmentSequence();
    virtual DcmDRTContributingEquipmentSequenceInterface getEmptyContributingEquipmentSequence();
    void setContributingEquipmentSequence(DcmDRTContributingEquipmentSequenceInterface seq);
 
    std::string getContributingEquipmentSequenceVR() const { return "SQ"; }
    std::string getContributingEquipmentSequenceVM() const { return "1"; }
    std::string getContributingEquipmentSequenceTag() { return std::string("(0018,a001)"); }
 
    // DigitalSignaturesSequence (fffa,fffa) vr=SQ, vm=1, type=3
    virtual DcmDRTDigitalSignaturesSequenceInterface getDigitalSignaturesSequence();
    virtual DcmDRTDigitalSignaturesSequenceInterface getEmptyDigitalSignaturesSequence();
    void setDigitalSignaturesSequence(DcmDRTDigitalSignaturesSequenceInterface seq);
 
    std::string getDigitalSignaturesSequenceVR() const { return "SQ"; }
    std::string getDigitalSignaturesSequenceVM() const { return "1"; }
    std::string getDigitalSignaturesSequenceTag() { return std::string("(fffa,fffa)"); }
 
    // EncryptedAttributesSequence (0400,0500) vr=SQ, vm=1, type=1C
    virtual DcmDRTEncryptedAttributesSequenceInterface getEncryptedAttributesSequence();
    virtual DcmDRTEncryptedAttributesSequenceInterface getEmptyEncryptedAttributesSequence();
    void setEncryptedAttributesSequence(DcmDRTEncryptedAttributesSequenceInterface seq);
 
    std::string getEncryptedAttributesSequenceVR() const { return "SQ"; }
    std::string getEncryptedAttributesSequenceVM() const { return "1"; }
    std::string getEncryptedAttributesSequenceTag() { return std::string("(0400,0500)"); }
 
    // HL7StructuredDocumentReferenceSequence (0040,a390) vr=SQ, vm=1, type=1C
    virtual DcmDRTHL7StructuredDocumentReferenceSequenceInterface getHL7StructuredDocumentReferenceSequence();
    virtual DcmDRTHL7StructuredDocumentReferenceSequenceInterface getEmptyHL7StructuredDocumentReferenceSequence();
    void setHL7StructuredDocumentReferenceSequence(DcmDRTHL7StructuredDocumentReferenceSequenceInterface seq);
 
    std::string getHL7StructuredDocumentReferenceSequenceVR() const { return "SQ"; }
    std::string getHL7StructuredDocumentReferenceSequenceVM() const { return "1"; }
    std::string getHL7StructuredDocumentReferenceSequenceTag() { return std::string("(0040,a390)"); }
 
    // MACParametersSequence (4ffe,0001) vr=SQ, vm=1, type=3
    virtual DcmDRTMACParametersSequenceInterface getMACParametersSequence();
    virtual DcmDRTMACParametersSequenceInterface getEmptyMACParametersSequence();
    void setMACParametersSequence(DcmDRTMACParametersSequenceInterface seq);
 
    std::string getMACParametersSequenceVR() const { return "SQ"; }
    std::string getMACParametersSequenceVM() const { return "1"; }
    std::string getMACParametersSequenceTag() { return std::string("(4ffe,0001)"); }
 
    // OriginalAttributesSequence (0400,0561) vr=SQ, vm=1, type=3
    virtual DcmDRTOriginalAttributesSequenceInterface getOriginalAttributesSequence();
    virtual DcmDRTOriginalAttributesSequenceInterface getEmptyOriginalAttributesSequence();
    void setOriginalAttributesSequence(DcmDRTOriginalAttributesSequenceInterface seq);
 
    std::string getOriginalAttributesSequenceVR() const { return "SQ"; }
    std::string getOriginalAttributesSequenceVM() const { return "1"; }
    std::string getOriginalAttributesSequenceTag() { return std::string("(0400,0561)"); }
 
    // ReferencedFrameOfReferenceSequence (3006,0010) vr=SQ, vm=1, type=3
    virtual DcmDRTReferencedFrameOfReferenceSequenceInterface getReferencedFrameOfReferenceSequence();
    virtual DcmDRTReferencedFrameOfReferenceSequenceInterface getEmptyReferencedFrameOfReferenceSequence();
    void setReferencedFrameOfReferenceSequence(DcmDRTReferencedFrameOfReferenceSequenceInterface seq);
 
    std::string getReferencedFrameOfReferenceSequenceVR() const { return "SQ"; }
    std::string getReferencedFrameOfReferenceSequenceVM() const { return "1"; }
    std::string getReferencedFrameOfReferenceSequenceTag() { return std::string("(3006,0010)"); }
 
    // StructureSetROISequence (3006,0020) vr=SQ, vm=1, type=3
    virtual DcmDRTStructureSetROISequenceInterface getStructureSetROISequence();
    virtual DcmDRTStructureSetROISequenceInterface getEmptyStructureSetROISequence();
    void setStructureSetROISequence(DcmDRTStructureSetROISequenceInterface seq);
 
    std::string getStructureSetROISequenceVR() const { return "SQ"; }
    std::string getStructureSetROISequenceVM() const { return "1"; }
    std::string getStructureSetROISequenceTag() { return std::string("(3006,0020)"); }
 
 
 private:
  dcmModuleTypeVec _dcmModuleTypes;
  
 
  ML_CLASS_HEADER(DRTDoseIODBase)
};
 
ML_END_NAMESPACE
 
#endif // __mlDRTDoseIODBase_H
 
/* MeVis-Hidden-Components-Start */
/* MeVis-Hidden-Components-End */