mlDRTImageIODBase.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 __mlDRTImageIODBase_H
#define __mlDRTImageIODBase_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/mlDcmDRTMultiplexedAudioChannelsDescriptionCodeSequenceInterface.h"  //DRTMultiplexedAudioChannelsDescriptionCodeSequence
#include "DcmSequenceInterfaces/mlDcmDRTContrastBolusAdministrationRouteSequenceInterface.h"  //DRTContrastBolusAdministrationRouteSequence
#include "DcmSequenceInterfaces/mlDcmDRTContrastBolusAgentSequenceInterface.h"  //DRTContrastBolusAgentSequence
#include "DcmSequenceInterfaces/mlDcmDRTDeviceSequenceInterface.h"  //DRTDeviceSequence
#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/mlDcmDRTExposureSequenceInterface.h"  //DRTExposureSequence
#include "DcmSequenceInterfaces/mlDcmDRTFluenceMapSequenceInterface.h"  //DRTFluenceMapSequence
#include "DcmSequenceInterfaces/mlDcmDRTReferencedRTPlanSequenceInRTImageModuleInterface.h"  //DRTReferencedRTPlanSequenceInRTImageModule
#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/mlDcmDRTVOILUTSequenceInterface.h"  //DRTVOILUTSequence
 
 
ML_START_NAMESPACE
 
// ------------------------------------------------------------------
// ------------------------------------------------------------------
class MLDCMTKBASEOBJECTS_EXPORT DRTImageIODBase : public RTBase
{
public:
 
  DRTImageIODBase();
 
  DRTImageIODBase(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 ~DRTImageIODBase () {}
 
  void setDcmTree(DCMTree::TreePtr dcmTree) { setMutableTree(dcmTree); }
 
  DCMTree::TreePtr getDCMTree() { return getMutableTree(); }
 
  bool isValid() { return getMutableTree() != NULL; }
 
 
    // ApprovalStatus (300e,0002) vr=CS, vm=1, type=1
    bool getApprovalStatus(std::string& parameter) const;
    bool setApprovalStatus(const std::string parameter);
    std::string getApprovalStatusVR() const { return "CS"; }
    std::string getApprovalStatusVM() const { return "1"; }
    std::string getApprovalStatusTag() const { return std::string("(300e,0002)"); }
    
    // ReviewDate (300e,0004) vr=DA, vm=1, type=2C
    bool getReviewDate(std::string& parameter) const;
    bool setReviewDate(const std::string parameter);
    std::string getReviewDateVR() const { return "DA"; }
    std::string getReviewDateVM() const { return "1"; }
    std::string getReviewDateTag() const { return std::string("(300e,0004)"); }
    
    // ReviewTime (300e,0005) vr=TM, vm=1, type=2C
    bool getReviewTime(std::string& parameter) const;
    bool setReviewTime(const std::string parameter);
    std::string getReviewTimeVR() const { return "TM"; }
    std::string getReviewTimeVM() const { return "1"; }
    std::string getReviewTimeTag() const { return std::string("(300e,0005)"); }
    
    // ReviewerName (300e,0008) vr=PN, vm=1, type=2C
    bool getReviewerName(std::string& parameter) const;
    bool setReviewerName(const std::string parameter);
    std::string getReviewerNameVR() const { return "PN"; }
    std::string getReviewerNameVM() const { return "1"; }
    std::string getReviewerNameTag() const { return std::string("(300e,0008)"); }
    
    // ActualFrameDuration (0018,1242) vr=IS, vm=1, type=3
    bool getActualFrameDuration(std::string& parameter) const;
    bool setActualFrameDuration(const std::string parameter);
    std::string getActualFrameDurationVR() const { return "IS"; }
    std::string getActualFrameDurationVM() const { return "1"; }
    std::string getActualFrameDurationTag() const { return std::string("(0018,1242)"); }
    
    // CineRate (0018,0040) vr=IS, vm=1, type=3
    bool getCineRate(std::string& parameter) const;
    bool setCineRate(const std::string parameter);
    std::string getCineRateVR() const { return "IS"; }
    std::string getCineRateVM() const { return "1"; }
    std::string getCineRateTag() const { return std::string("(0018,0040)"); }
    
    // EffectiveDuration (0018,0072) vr=DS, vm=1, type=3
    bool getEffectiveDuration(std::string& parameter) const;
    bool setEffectiveDuration(const std::string parameter);
    std::string getEffectiveDurationVR() const { return "DS"; }
    std::string getEffectiveDurationVM() const { return "1"; }
    std::string getEffectiveDurationTag() const { return std::string("(0018,0072)"); }
    
    // FrameDelay (0018,1066) vr=DS, vm=1, type=3
    bool getFrameDelay(std::string& parameter) const;
    bool setFrameDelay(const std::string parameter);
    std::string getFrameDelayVR() const { return "DS"; }
    std::string getFrameDelayVM() const { return "1"; }
    std::string getFrameDelayTag() const { return std::string("(0018,1066)"); }
    
    // FrameTime (0018,1063) vr=DS, vm=1, type=1C
    bool getFrameTime(std::string& parameter) const;
    bool setFrameTime(const std::string parameter);
    std::string getFrameTimeVR() const { return "DS"; }
    std::string getFrameTimeVM() const { return "1"; }
    std::string getFrameTimeTag() const { return std::string("(0018,1063)"); }
    
    // FrameTimeVector (0018,1065) vr=DS, vm=1-n, type=1C
    bool getFrameTimeVector(std::string& parameter) const;
    bool setFrameTimeVector(const std::string parameter);
    std::string getFrameTimeVectorVR() const { return "DS"; }
    std::string getFrameTimeVectorVM() const { return "1-n"; }
    std::string getFrameTimeVectorTag() const { return std::string("(0018,1065)"); }
    
    // ImageTriggerDelay (0018,1067) vr=DS, vm=1, type=3
    bool getImageTriggerDelay(std::string& parameter) const;
    bool setImageTriggerDelay(const std::string parameter);
    std::string getImageTriggerDelayVR() const { return "DS"; }
    std::string getImageTriggerDelayVM() const { return "1"; }
    std::string getImageTriggerDelayTag() const { return std::string("(0018,1067)"); }
    
    // PreferredPlaybackSequencing (0018,1244) vr=US, vm=1, type=3
    bool getPreferredPlaybackSequencing(MLuint16& parameter) const;
    bool setPreferredPlaybackSequencing(const MLuint16 parameter);
    std::string getPreferredPlaybackSequencingVR() const { return "US"; }
    std::string getPreferredPlaybackSequencingVM() const { return "1"; }
    std::string getPreferredPlaybackSequencingTag() const { return std::string("(0018,1244)"); }
    
    // RecommendedDisplayFrameRate (0008,2144) vr=IS, vm=1, type=3
    bool getRecommendedDisplayFrameRate(std::string& parameter) const;
    bool setRecommendedDisplayFrameRate(const std::string parameter);
    std::string getRecommendedDisplayFrameRateVR() const { return "IS"; }
    std::string getRecommendedDisplayFrameRateVM() const { return "1"; }
    std::string getRecommendedDisplayFrameRateTag() const { return std::string("(0008,2144)"); }
    
    // StartTrim (0008,2142) vr=IS, vm=1, type=3
    bool getStartTrim(std::string& parameter) const;
    bool setStartTrim(const std::string parameter);
    std::string getStartTrimVR() const { return "IS"; }
    std::string getStartTrimVM() const { return "1"; }
    std::string getStartTrimTag() const { return std::string("(0008,2142)"); }
    
    // StopTrim (0008,2143) vr=IS, vm=1, type=3
    bool getStopTrim(std::string& parameter) const;
    bool setStopTrim(const std::string parameter);
    std::string getStopTrimVR() const { return "IS"; }
    std::string getStopTrimVM() const { return "1"; }
    std::string getStopTrimTag() const { return std::string("(0008,2143)"); }
    
    // 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)"); }
    
    // ContrastBolusAgent (0018,0010) vr=LO, vm=1, type=2
    bool getContrastBolusAgent(std::string& parameter) const;
    bool setContrastBolusAgent(const std::string parameter);
    std::string getContrastBolusAgentVR() const { return "LO"; }
    std::string getContrastBolusAgentVM() const { return "1"; }
    std::string getContrastBolusAgentTag() const { return std::string("(0018,0010)"); }
    
    // ContrastBolusIngredient (0018,1048) vr=CS, vm=1, type=3
    bool getContrastBolusIngredient(std::string& parameter) const;
    bool setContrastBolusIngredient(const std::string parameter);
    std::string getContrastBolusIngredientVR() const { return "CS"; }
    std::string getContrastBolusIngredientVM() const { return "1"; }
    std::string getContrastBolusIngredientTag() const { return std::string("(0018,1048)"); }
    
    // ContrastBolusIngredientConcentration (0018,1049) vr=DS, vm=1, type=3
    bool getContrastBolusIngredientConcentration(std::string& parameter) const;
    bool setContrastBolusIngredientConcentration(const std::string parameter);
    std::string getContrastBolusIngredientConcentrationVR() const { return "DS"; }
    std::string getContrastBolusIngredientConcentrationVM() const { return "1"; }
    std::string getContrastBolusIngredientConcentrationTag() const { return std::string("(0018,1049)"); }
    
    // ContrastBolusRoute (0018,1040) vr=LO, vm=1, type=3
    bool getContrastBolusRoute(std::string& parameter) const;
    bool setContrastBolusRoute(const std::string parameter);
    std::string getContrastBolusRouteVR() const { return "LO"; }
    std::string getContrastBolusRouteVM() const { return "1"; }
    std::string getContrastBolusRouteTag() const { return std::string("(0018,1040)"); }
    
    // ContrastBolusStartTime (0018,1042) vr=TM, vm=1, type=3
    bool getContrastBolusStartTime(std::string& parameter) const;
    bool setContrastBolusStartTime(const std::string parameter);
    std::string getContrastBolusStartTimeVR() const { return "TM"; }
    std::string getContrastBolusStartTimeVM() const { return "1"; }
    std::string getContrastBolusStartTimeTag() const { return std::string("(0018,1042)"); }
    
    // ContrastBolusStopTime (0018,1043) vr=TM, vm=1, type=3
    bool getContrastBolusStopTime(std::string& parameter) const;
    bool setContrastBolusStopTime(const std::string parameter);
    std::string getContrastBolusStopTimeVR() const { return "TM"; }
    std::string getContrastBolusStopTimeVM() const { return "1"; }
    std::string getContrastBolusStopTimeTag() const { return std::string("(0018,1043)"); }
    
    // ContrastBolusTotalDose (0018,1044) vr=DS, vm=1, type=3
    bool getContrastBolusTotalDose(std::string& parameter) const;
    bool setContrastBolusTotalDose(const std::string parameter);
    std::string getContrastBolusTotalDoseVR() const { return "DS"; }
    std::string getContrastBolusTotalDoseVM() const { return "1"; }
    std::string getContrastBolusTotalDoseTag() const { return std::string("(0018,1044)"); }
    
    // ContrastBolusVolume (0018,1041) vr=DS, vm=1, type=3
    bool getContrastBolusVolume(std::string& parameter) const;
    bool setContrastBolusVolume(const std::string parameter);
    std::string getContrastBolusVolumeVR() const { return "DS"; }
    std::string getContrastBolusVolumeVM() const { return "1"; }
    std::string getContrastBolusVolumeTag() const { return std::string("(0018,1041)"); }
    
    // ContrastFlowDuration (0018,1047) vr=DS, vm=1-n, type=3
    bool getContrastFlowDuration(std::string& parameter) const;
    bool setContrastFlowDuration(const std::string parameter);
    std::string getContrastFlowDurationVR() const { return "DS"; }
    std::string getContrastFlowDurationVM() const { return "1-n"; }
    std::string getContrastFlowDurationTag() const { return std::string("(0018,1047)"); }
    
    // ContrastFlowRate (0018,1046) vr=DS, vm=1-n, type=3
    bool getContrastFlowRate(std::string& parameter) const;
    bool setContrastFlowRate(const std::string parameter);
    std::string getContrastFlowRateVR() const { return "DS"; }
    std::string getContrastFlowRateVM() const { return "1-n"; }
    std::string getContrastFlowRateTag() const { return std::string("(0018,1046)"); }
    
    // 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)"); }
    
    // 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)"); }
    
    // 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)"); }
    
    // BeamLimitingDeviceAngle (300a,0120) vr=DS, vm=1, type=3
    bool getBeamLimitingDeviceAngle(std::string& parameter) const;
    bool setBeamLimitingDeviceAngle(const std::string parameter);
    std::string getBeamLimitingDeviceAngleVR() const { return "DS"; }
    std::string getBeamLimitingDeviceAngleVM() const { return "1"; }
    std::string getBeamLimitingDeviceAngleTag() const { return std::string("(300a,0120)"); }
    
    // BitsAllocated (0028,0100) vr=US, vm=1, type=1
    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=1
    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)"); }
    
    // ConversionType (0008,0064) vr=CS, vm=1, type=2
    bool getConversionType(std::string& parameter) const;
    bool setConversionType(const std::string parameter);
    std::string getConversionTypeVR() const { return "CS"; }
    std::string getConversionTypeVM() const { return "1"; }
    std::string getConversionTypeTag() const { return std::string("(0008,0064)"); }
    
    // EndCumulativeMetersetWeight (300c,0009) vr=DS, vm=1, type=3
    bool getEndCumulativeMetersetWeight(std::string& parameter) const;
    bool setEndCumulativeMetersetWeight(const std::string parameter);
    std::string getEndCumulativeMetersetWeightVR() const { return "DS"; }
    std::string getEndCumulativeMetersetWeightVM() const { return "1"; }
    std::string getEndCumulativeMetersetWeightTag() const { return std::string("(300c,0009)"); }
    
    // FractionNumber (3002,0029) vr=IS, vm=1, type=3
    bool getFractionNumber(std::string& parameter) const;
    bool setFractionNumber(const std::string parameter);
    std::string getFractionNumberVR() const { return "IS"; }
    std::string getFractionNumberVM() const { return "1"; }
    std::string getFractionNumberTag() const { return std::string("(3002,0029)"); }
    
    // GantryAngle (300a,011e) vr=DS, vm=1, type=3
    bool getGantryAngle(std::string& parameter) const;
    bool setGantryAngle(const std::string parameter);
    std::string getGantryAngleVR() const { return "DS"; }
    std::string getGantryAngleVM() const { return "1"; }
    std::string getGantryAngleTag() const { return std::string("(300a,011e)"); }
    
    // GantryPitchAngle (300a,014a) vr=FL, vm=1, type=3
    bool getGantryPitchAngle(float& parameter) const;
    bool setGantryPitchAngle(const float parameter);
    std::string getGantryPitchAngleVR() const { return "FL"; }
    std::string getGantryPitchAngleVM() const { return "1"; }
    std::string getGantryPitchAngleTag() const { return std::string("(300a,014a)"); }
    
    // HighBit (0028,0102) vr=US, vm=1, type=1
    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)"); }
    
    // ImagePlanePixelSpacing (3002,0011) vr=DS, vm=2, type=2
    bool getImagePlanePixelSpacing(std::string& parameter) const;
    bool setImagePlanePixelSpacing(const std::string parameter);
    std::string getImagePlanePixelSpacingVR() const { return "DS"; }
    std::string getImagePlanePixelSpacingVM() const { return "2"; }
    std::string getImagePlanePixelSpacingTag() const { return std::string("(3002,0011)"); }
    
    // IsocenterPosition (300a,012c) vr=DS, vm=3, type=3
    bool getIsocenterPosition(std::string& parameter) const;
    bool setIsocenterPosition(const std::string parameter);
    std::string getIsocenterPositionVR() const { return "DS"; }
    std::string getIsocenterPositionVM() const { return "3"; }
    std::string getIsocenterPositionTag() const { return std::string("(300a,012c)"); }
    
    // OperatorsName (0008,1070) vr=PN, vm=1-n, type=2
    bool getOperatorsName(std::string& parameter) const;
    bool setOperatorsName(const std::string parameter);
    std::string getOperatorsNameVR() const { return "PN"; }
    std::string getOperatorsNameVM() const { return "1-n"; }
    std::string getOperatorsNameTag() const { return std::string("(0008,1070)"); }
    
    // PatientPosition (0018,5100) vr=CS, vm=1, type=1C
    bool getPatientPosition(std::string& parameter) const;
    bool setPatientPosition(const std::string parameter);
    std::string getPatientPositionVR() const { return "CS"; }
    std::string getPatientPositionVM() const { return "1"; }
    std::string getPatientPositionTag() const { return std::string("(0018,5100)"); }
    
    // PatientSupportAngle (300a,0122) vr=DS, vm=1, type=3
    bool getPatientSupportAngle(std::string& parameter) const;
    bool setPatientSupportAngle(const std::string parameter);
    std::string getPatientSupportAngleVR() const { return "DS"; }
    std::string getPatientSupportAngleVM() const { return "1"; }
    std::string getPatientSupportAngleTag() const { return std::string("(300a,0122)"); }
    
    // PhotometricInterpretation (0028,0004) vr=CS, vm=1, type=1
    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)"); }
    
    // PixelIntensityRelationship (0028,1040) vr=CS, vm=1, type=3
    bool getPixelIntensityRelationship(std::string& parameter) const;
    bool setPixelIntensityRelationship(const std::string parameter);
    std::string getPixelIntensityRelationshipVR() const { return "CS"; }
    std::string getPixelIntensityRelationshipVM() const { return "1"; }
    std::string getPixelIntensityRelationshipTag() const { return std::string("(0028,1040)"); }
    
    // PixelIntensityRelationshipSign (0028,1041) vr=SS, vm=1, type=1C
    bool getPixelIntensityRelationshipSign(int& parameter) const;
    bool setPixelIntensityRelationshipSign(const int parameter);
    std::string getPixelIntensityRelationshipSignVR() const { return "SS"; }
    std::string getPixelIntensityRelationshipSignVM() const { return "1"; }
    std::string getPixelIntensityRelationshipSignTag() const { return std::string("(0028,1041)"); }
    
    // PixelRepresentation (0028,0103) vr=US, vm=1, type=1
    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)"); }
    
    // PrimaryDosimeterUnit (300a,00b3) vr=CS, vm=1, type=2
    bool getPrimaryDosimeterUnit(std::string& parameter) const;
    bool setPrimaryDosimeterUnit(const std::string parameter);
    std::string getPrimaryDosimeterUnitVR() const { return "CS"; }
    std::string getPrimaryDosimeterUnitVM() const { return "1"; }
    std::string getPrimaryDosimeterUnitTag() const { return std::string("(300a,00b3)"); }
    
    // RTImageDescription (3002,0004) vr=ST, vm=1, type=3
    bool getRTImageDescription(std::string& parameter) const;
    bool setRTImageDescription(const std::string parameter);
    std::string getRTImageDescriptionVR() const { return "ST"; }
    std::string getRTImageDescriptionVM() const { return "1"; }
    std::string getRTImageDescriptionTag() const { return std::string("(3002,0004)"); }
    
    // RTImageLabel (3002,0002) vr=SH, vm=1, type=1
    bool getRTImageLabel(std::string& parameter) const;
    bool setRTImageLabel(const std::string parameter);
    std::string getRTImageLabelVR() const { return "SH"; }
    std::string getRTImageLabelVM() const { return "1"; }
    std::string getRTImageLabelTag() const { return std::string("(3002,0002)"); }
    
    // RTImageName (3002,0003) vr=LO, vm=1, type=3
    bool getRTImageName(std::string& parameter) const;
    bool setRTImageName(const std::string parameter);
    std::string getRTImageNameVR() const { return "LO"; }
    std::string getRTImageNameVM() const { return "1"; }
    std::string getRTImageNameTag() const { return std::string("(3002,0003)"); }
    
    // RTImageOrientation (3002,0010) vr=DS, vm=6, type=2C
    bool getRTImageOrientation(std::string& parameter) const;
    bool setRTImageOrientation(const std::string parameter);
    std::string getRTImageOrientationVR() const { return "DS"; }
    std::string getRTImageOrientationVM() const { return "6"; }
    std::string getRTImageOrientationTag() const { return std::string("(3002,0010)"); }
    
    // RTImagePlane (3002,000c) vr=CS, vm=1, type=1
    bool getRTImagePlane(std::string& parameter) const;
    bool setRTImagePlane(const std::string parameter);
    std::string getRTImagePlaneVR() const { return "CS"; }
    std::string getRTImagePlaneVM() const { return "1"; }
    std::string getRTImagePlaneTag() const { return std::string("(3002,000c)"); }
    
    // RTImagePosition (3002,0012) vr=DS, vm=2, type=2
    bool getRTImagePosition(std::string& parameter) const;
    bool setRTImagePosition(const std::string parameter);
    std::string getRTImagePositionVR() const { return "DS"; }
    std::string getRTImagePositionVM() const { return "2"; }
    std::string getRTImagePositionTag() const { return std::string("(3002,0012)"); }
    
    // RTImageSID (3002,0026) vr=DS, vm=1, type=2
    bool getRTImageSID(std::string& parameter) const;
    bool setRTImageSID(const std::string parameter);
    std::string getRTImageSIDVR() const { return "DS"; }
    std::string getRTImageSIDVM() const { return "1"; }
    std::string getRTImageSIDTag() const { return std::string("(3002,0026)"); }
    
    // RadiationMachineName (3002,0020) vr=SH, vm=1, type=2
    bool getRadiationMachineName(std::string& parameter) const;
    bool setRadiationMachineName(const std::string parameter);
    std::string getRadiationMachineNameVR() const { return "SH"; }
    std::string getRadiationMachineNameVM() const { return "1"; }
    std::string getRadiationMachineNameTag() const { return std::string("(3002,0020)"); }
    
    // RadiationMachineSAD (3002,0022) vr=DS, vm=1, type=2
    bool getRadiationMachineSAD(std::string& parameter) const;
    bool setRadiationMachineSAD(const std::string parameter);
    std::string getRadiationMachineSADVR() const { return "DS"; }
    std::string getRadiationMachineSADVM() const { return "1"; }
    std::string getRadiationMachineSADTag() const { return std::string("(3002,0022)"); }
    
    // RadiationMachineSSD (3002,0024) vr=DS, vm=1, type=3
    bool getRadiationMachineSSD(std::string& parameter) const;
    bool setRadiationMachineSSD(const std::string parameter);
    std::string getRadiationMachineSSDVR() const { return "DS"; }
    std::string getRadiationMachineSSDVM() const { return "1"; }
    std::string getRadiationMachineSSDTag() const { return std::string("(3002,0024)"); }
    
    // ReferencedBeamNumber (300c,0006) vr=IS, vm=1, type=3
    bool getReferencedBeamNumber(std::string& parameter) const;
    bool setReferencedBeamNumber(const std::string parameter);
    std::string getReferencedBeamNumberVR() const { return "IS"; }
    std::string getReferencedBeamNumberVM() const { return "1"; }
    std::string getReferencedBeamNumberTag() const { return std::string("(300c,0006)"); }
    
    // ReferencedFractionGroupNumber (300c,0022) vr=IS, vm=1, type=3
    bool getReferencedFractionGroupNumber(std::string& parameter) const;
    bool setReferencedFractionGroupNumber(const std::string parameter);
    std::string getReferencedFractionGroupNumberVR() const { return "IS"; }
    std::string getReferencedFractionGroupNumberVM() const { return "1"; }
    std::string getReferencedFractionGroupNumberTag() const { return std::string("(300c,0022)"); }
    
    // ReportedValuesOrigin (3002,000a) vr=CS, vm=1, type=2C
    bool getReportedValuesOrigin(std::string& parameter) const;
    bool setReportedValuesOrigin(const std::string parameter);
    std::string getReportedValuesOriginVR() const { return "CS"; }
    std::string getReportedValuesOriginVM() const { return "1"; }
    std::string getReportedValuesOriginTag() const { return std::string("(3002,000a)"); }
    
    // SamplesPerPixel (0028,0002) vr=US, vm=1, type=1
    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)"); }
    
    // SourceToReferenceObjectDistance (3002,0028) vr=DS, vm=1, type=3
    bool getSourceToReferenceObjectDistance(std::string& parameter) const;
    bool setSourceToReferenceObjectDistance(const std::string parameter);
    std::string getSourceToReferenceObjectDistanceVR() const { return "DS"; }
    std::string getSourceToReferenceObjectDistanceVM() const { return "1"; }
    std::string getSourceToReferenceObjectDistanceTag() const { return std::string("(3002,0028)"); }
    
    // StartCumulativeMetersetWeight (300c,0008) vr=DS, vm=1, type=3
    bool getStartCumulativeMetersetWeight(std::string& parameter) const;
    bool setStartCumulativeMetersetWeight(const std::string parameter);
    std::string getStartCumulativeMetersetWeightVR() const { return "DS"; }
    std::string getStartCumulativeMetersetWeightVM() const { return "1"; }
    std::string getStartCumulativeMetersetWeightTag() const { return std::string("(300c,0008)"); }
    
    // TableTopEccentricAngle (300a,0125) vr=DS, vm=1, type=3
    bool getTableTopEccentricAngle(std::string& parameter) const;
    bool setTableTopEccentricAngle(const std::string parameter);
    std::string getTableTopEccentricAngleVR() const { return "DS"; }
    std::string getTableTopEccentricAngleVM() const { return "1"; }
    std::string getTableTopEccentricAngleTag() const { return std::string("(300a,0125)"); }
    
    // TableTopEccentricAxisDistance (300a,0124) vr=DS, vm=1, type=3
    bool getTableTopEccentricAxisDistance(std::string& parameter) const;
    bool setTableTopEccentricAxisDistance(const std::string parameter);
    std::string getTableTopEccentricAxisDistanceVR() const { return "DS"; }
    std::string getTableTopEccentricAxisDistanceVM() const { return "1"; }
    std::string getTableTopEccentricAxisDistanceTag() const { return std::string("(300a,0124)"); }
    
    // TableTopLateralPosition (300a,012a) vr=DS, vm=1, type=3
    bool getTableTopLateralPosition(std::string& parameter) const;
    bool setTableTopLateralPosition(const std::string parameter);
    std::string getTableTopLateralPositionVR() const { return "DS"; }
    std::string getTableTopLateralPositionVM() const { return "1"; }
    std::string getTableTopLateralPositionTag() const { return std::string("(300a,012a)"); }
    
    // TableTopLongitudinalPosition (300a,0129) vr=DS, vm=1, type=3
    bool getTableTopLongitudinalPosition(std::string& parameter) const;
    bool setTableTopLongitudinalPosition(const std::string parameter);
    std::string getTableTopLongitudinalPositionVR() const { return "DS"; }
    std::string getTableTopLongitudinalPositionVM() const { return "1"; }
    std::string getTableTopLongitudinalPositionTag() const { return std::string("(300a,0129)"); }
    
    // TableTopVerticalPosition (300a,0128) vr=DS, vm=1, type=3
    bool getTableTopVerticalPosition(std::string& parameter) const;
    bool setTableTopVerticalPosition(const std::string parameter);
    std::string getTableTopVerticalPositionVR() const { return "DS"; }
    std::string getTableTopVerticalPositionVM() const { return "1"; }
    std::string getTableTopVerticalPositionTag() const { return std::string("(300a,0128)"); }
    
    // XRayImageReceptorAngle (3002,000e) vr=DS, vm=1, type=2
    bool getXRayImageReceptorAngle(std::string& parameter) const;
    bool setXRayImageReceptorAngle(const std::string parameter);
    std::string getXRayImageReceptorAngleVR() const { return "DS"; }
    std::string getXRayImageReceptorAngleVM() const { return "1"; }
    std::string getXRayImageReceptorAngleTag() const { return std::string("(3002,000e)"); }
    
    // XRayImageReceptorTranslation (3002,000d) vr=DS, vm=3, type=3
    bool getXRayImageReceptorTranslation(std::string& parameter) const;
    bool setXRayImageReceptorTranslation(const std::string parameter);
    std::string getXRayImageReceptorTranslationVR() const { return "DS"; }
    std::string getXRayImageReceptorTranslationVM() const { return "3"; }
    std::string getXRayImageReceptorTranslationTag() const { return std::string("(3002,000d)"); }
    
    // 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)"); }
    
    // VOILUTFunction (0028,1056) vr=CS, vm=1, type=3
    bool getVOILUTFunction(std::string& parameter) const;
    bool setVOILUTFunction(const std::string parameter);
    std::string getVOILUTFunctionVR() const { return "CS"; }
    std::string getVOILUTFunctionVM() const { return "1"; }
    std::string getVOILUTFunctionTag() const { return std::string("(0028,1056)"); }
    
    // WindowCenter (0028,1050) vr=DS, vm=1-n, type=1C
    bool getWindowCenter(std::string& parameter) const;
    bool setWindowCenter(const std::string parameter);
    std::string getWindowCenterVR() const { return "DS"; }
    std::string getWindowCenterVM() const { return "1-n"; }
    std::string getWindowCenterTag() const { return std::string("(0028,1050)"); }
    
    // WindowCenterWidthExplanation (0028,1055) vr=LO, vm=1-n, type=3
    bool getWindowCenterWidthExplanation(std::string& parameter) const;
    bool setWindowCenterWidthExplanation(const std::string parameter);
    std::string getWindowCenterWidthExplanationVR() const { return "LO"; }
    std::string getWindowCenterWidthExplanationVM() const { return "1-n"; }
    std::string getWindowCenterWidthExplanationTag() const { return std::string("(0028,1055)"); }
    
    // WindowWidth (0028,1051) vr=DS, vm=1-n, type=1C
    bool getWindowWidth(std::string& parameter) const;
    bool setWindowWidth(const std::string parameter);
    std::string getWindowWidthVR() const { return "DS"; }
    std::string getWindowWidthVM() const { return "1-n"; }
    std::string getWindowWidthTag() const { return std::string("(0028,1051)"); }
    
 
    // MultiplexedAudioChannelsDescriptionCodeSequence (003a,0300) vr=SQ, vm=1, type=2C
    virtual DcmDRTMultiplexedAudioChannelsDescriptionCodeSequenceInterface getMultiplexedAudioChannelsDescriptionCodeSequence();
    virtual DcmDRTMultiplexedAudioChannelsDescriptionCodeSequenceInterface getEmptyMultiplexedAudioChannelsDescriptionCodeSequence();
    void setMultiplexedAudioChannelsDescriptionCodeSequence(DcmDRTMultiplexedAudioChannelsDescriptionCodeSequenceInterface seq);
 
    std::string getMultiplexedAudioChannelsDescriptionCodeSequenceVR() const { return "SQ"; }
    std::string getMultiplexedAudioChannelsDescriptionCodeSequenceVM() const { return "1"; }
    std::string getMultiplexedAudioChannelsDescriptionCodeSequenceTag() { return std::string("(003a,0300)"); }
 
    // ContrastBolusAdministrationRouteSequence (0018,0014) vr=SQ, vm=1, type=3
    virtual DcmDRTContrastBolusAdministrationRouteSequenceInterface getContrastBolusAdministrationRouteSequence();
    virtual DcmDRTContrastBolusAdministrationRouteSequenceInterface getEmptyContrastBolusAdministrationRouteSequence();
    void setContrastBolusAdministrationRouteSequence(DcmDRTContrastBolusAdministrationRouteSequenceInterface seq);
 
    std::string getContrastBolusAdministrationRouteSequenceVR() const { return "SQ"; }
    std::string getContrastBolusAdministrationRouteSequenceVM() const { return "1"; }
    std::string getContrastBolusAdministrationRouteSequenceTag() { return std::string("(0018,0014)"); }
 
    // ContrastBolusAgentSequence (0018,0012) vr=SQ, vm=1, type=3
    virtual DcmDRTContrastBolusAgentSequenceInterface getContrastBolusAgentSequence();
    virtual DcmDRTContrastBolusAgentSequenceInterface getEmptyContrastBolusAgentSequence();
    void setContrastBolusAgentSequence(DcmDRTContrastBolusAgentSequenceInterface seq);
 
    std::string getContrastBolusAgentSequenceVR() const { return "SQ"; }
    std::string getContrastBolusAgentSequenceVM() const { return "1"; }
    std::string getContrastBolusAgentSequenceTag() { return std::string("(0018,0012)"); }
 
    // DeviceSequence (0050,0010) vr=SQ, vm=1, type=3
    virtual DcmDRTDeviceSequenceInterface getDeviceSequence();
    virtual DcmDRTDeviceSequenceInterface getEmptyDeviceSequence();
    void setDeviceSequence(DcmDRTDeviceSequenceInterface seq);
 
    std::string getDeviceSequenceVR() const { return "SQ"; }
    std::string getDeviceSequenceVM() const { return "1"; }
    std::string getDeviceSequenceTag() { return std::string("(0050,0010)"); }
 
    // 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)"); }
 
    // ExposureSequence (3002,0030) vr=SQ, vm=1, type=3
    virtual DcmDRTExposureSequenceInterface getExposureSequence();
    virtual DcmDRTExposureSequenceInterface getEmptyExposureSequence();
    void setExposureSequence(DcmDRTExposureSequenceInterface seq);
 
    std::string getExposureSequenceVR() const { return "SQ"; }
    std::string getExposureSequenceVM() const { return "1"; }
    std::string getExposureSequenceTag() { return std::string("(3002,0030)"); }
 
    // FluenceMapSequence (3002,0040) vr=SQ, vm=1, type=1C
    virtual DcmDRTFluenceMapSequenceInterface getFluenceMapSequence();
    virtual DcmDRTFluenceMapSequenceInterface getEmptyFluenceMapSequence();
    void setFluenceMapSequence(DcmDRTFluenceMapSequenceInterface seq);
 
    std::string getFluenceMapSequenceVR() const { return "SQ"; }
    std::string getFluenceMapSequenceVM() const { return "1"; }
    std::string getFluenceMapSequenceTag() { return std::string("(3002,0040)"); }
 
    // ReferencedRTPlanSequence (300c,0002) vr=SQ, vm=1, type=3
    virtual DcmDRTReferencedRTPlanSequenceInRTImageModuleInterface getReferencedRTPlanSequence();
    virtual DcmDRTReferencedRTPlanSequenceInRTImageModuleInterface getEmptyReferencedRTPlanSequence();
    void setReferencedRTPlanSequence(DcmDRTReferencedRTPlanSequenceInRTImageModuleInterface seq);
 
    std::string getReferencedRTPlanSequenceVR() const { return "SQ"; }
    std::string getReferencedRTPlanSequenceVM() const { return "1"; }
    std::string getReferencedRTPlanSequenceTag() { return std::string("(300c,0002)"); }
 
    // 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)"); }
 
    // VOILUTSequence (0028,3010) vr=SQ, vm=1, type=1C
    virtual DcmDRTVOILUTSequenceInterface getVOILUTSequence();
    virtual DcmDRTVOILUTSequenceInterface getEmptyVOILUTSequence();
    void setVOILUTSequence(DcmDRTVOILUTSequenceInterface seq);
 
    std::string getVOILUTSequenceVR() const { return "SQ"; }
    std::string getVOILUTSequenceVM() const { return "1"; }
    std::string getVOILUTSequenceTag() { return std::string("(0028,3010)"); }
 
 
 private:
  dcmModuleTypeVec _dcmModuleTypes;
  
 
  ML_CLASS_HEADER(DRTImageIODBase)
};
 
ML_END_NAMESPACE
 
#endif // __mlDRTImageIODBase_H
 
/* MeVis-Hidden-Components-Start */
/* MeVis-Hidden-Components-End */