C# DvtkData类代码示例

 internal CommandSet(DvtkData.Dimse.CommandSet dvtkDataCommandSet)
     : base(dvtkDataCommandSet)
 {
     if (dvtkDataCommandSet == null)
     {
         DvtkHighLevelInterfaceException.Throw("Parameter may not be null/Nothing.");
     }
 }

 /// <summary>
 /// Constructor that initialized this instance with a DvtkData AcceptedPresentationContextList.
 /// </summary>
 /// <param name="dvtkDataAcceptedPresentationContextList">The DvtkData AcceptedPresentationContextList.</param>
 internal PresentationContextCollection(DvtkData.Dul.AcceptedPresentationContextList dvtkDataAcceptedPresentationContextList)
 {
     foreach (DvtkData.Dul.AcceptedPresentationContext dvtkDataAcceptedPresentationContext in dvtkDataAcceptedPresentationContextList)
     {
         PresentationContext presentationContext = new PresentationContext(dvtkDataAcceptedPresentationContext);
         Add(presentationContext);
     }
 }

 /// <summary>
 /// Constructor. Encapsulates a DvtkData.Dimse.CommandSet instance.
 /// </summary>
 /// <param name="dvtkDataCommandSet">The DvtkData.Dimse.CommandSet instance to encapsulate.</param>
 internal CommandSet(DvtkData.Dimse.CommandSet dvtkDataCommandSet)
     : base(dvtkDataCommandSet)
 {
     if (dvtkDataCommandSet == null)
     {
         throw new HliException("Parameter may not be null/Nothing.");
     }
 }

 internal FileMetaInformation(DvtkData.Dimse.AttributeSet dvtkDataAttributeSet)
     : base(dvtkDataAttributeSet)
 {
     if (dvtkDataAttributeSet == null)
     {
         DvtkHighLevelInterfaceException.Throw("Parameter may not be null/Nothing.");
     }
 }

        /// <summary>
        /// Class constructor.
        /// </summary>
        /// <param name="parentSequenceTag">Parent Sequence Tag</param>
        /// <param name="tag">Comparison Tag</param>
        /// <param name="commonDataFormat">Data Format for Tag</param>
        public DicomComparisonTag(DvtkData.Dimse.Tag parentSequenceTag, 
									DvtkData.Dimse.Tag tag, 
									BaseCommonDataFormat commonDataFormat)
        {
            _parentSequenceTag = parentSequenceTag;
            _tag = tag;
            _commonDataFormat = commonDataFormat;
        }

        /// <summary>
        /// Compare two pixel attributes (i.e. attributes that have VR OB, OF or OW).
        /// </summary>
        /// <param name="attribute1">The first attribute.</param>
        /// <param name="attribute2">The second attribute.</param>
        /// <returns>Indicates if the two are equal or not.</returns>
        public static bool ComparePixelAttributes(
			DvtkData.Dimse.Attribute attribute1, 
			DvtkData.Dimse.Attribute attribute2)
        {
            bool equal = true;

            equal = MAttributeUtilities.ComparePixelAttributes(attribute1, attribute2);

            return(equal);
        }

        public System.String GetValue(DvtkData.Dimse.Tag sequenceTag, DvtkData.Dimse.Tag tag)
        {
            System.String lValue = System.String.Empty;

            if (_dicomMessage != null)
            {
                lValue = GenerateTriggers.GetValueFromMessageUsingTag(_dicomMessage, sequenceTag, tag);

            }

            return lValue;
        }

        //
        // - Constructors -
        //
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="tagSequence">The tag sequence (one or more tags seperated with an '/') of this attribue.</param>
        /// <param name="attribute">
        /// The encapsulated Attribute from the DvtkData librbary.
        /// May not be null.
        /// </param>
        public Attribute(String tagSequence, DvtkData.Dimse.Attribute dvtkDataAttribute)
        {
            this.tagSequence = tagSequence;

            if (dvtkDataAttribute == null)
            {
                // Sanity check.
                DvtkHighLevelInterfaceException.Throw("Parameter may not be null.");
            }
            else
            {
                this.dvtkDataAttribute = dvtkDataAttribute;
            }
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="tagSequence">The tag sequence of the attribute.</param>
        /// <param name="dvtkDataAttribute">The encapsulated DvtkData attribute.</param>
        /// <param name="parentAttributeSet">The AttributeSet this instance is part of.</param>
        public ValidAttribute(TagSequence tagSequence, DvtkData.Dimse.Attribute dvtkDataAttribute, AttributeSet parentAttributeSet)
        {
            // Sanity check.
            if (dvtkDataAttribute == null)
            {
                throw new ArgumentException("Internal error: dvtkDataAttribute may not be null.");
            }

            // Sanity check.
            if (parentAttributeSet == null)
            {
                throw new ArgumentException("Internal error: parentAttributeSet may not be null.");
            }

            TagSequence = tagSequence;
            this.dvtkDataAttribute = dvtkDataAttribute;
            this.parentAttributeSet = parentAttributeSet;
        }

        /// <summary>
        /// Constructor.
        /// 
        /// Use this constructor to construct the command set and data set based on the 
        /// command set and data set contained in the encapsulated DvtkData DicomMessage.
        /// </summary>
        /// <param name="dvtkDataDicomMessage">The encapsulated DvtkData DicomMessage.</param>
        internal DicomMessage(DvtkData.Dimse.DicomMessage dvtkDataDicomMessage)
        {
            // Sanity check.
            if (dvtkDataDicomMessage == null)
            {
                DvtkHighLevelInterfaceException.Throw("Parameter may not be null.");
            }

            // Create the CommandSet object.
            this.commandSet = new CommandSet(dvtkDataDicomMessage.CommandSet);

            // Create the DataSet object.
            if (dvtkDataDicomMessage.DataSet == null)
            {
                this.dataSet = new DataSet();
            }
            else
            {
                this.dataSet = new DataSet(dvtkDataDicomMessage.DataSet);
            }
        }

        /// <summary>
        /// Initialize the DicomComparator
        /// </summary>
        /// <param name="dicomMessage"></param>
        /// <returns></returns>
        /// <returns>bool - true = template initialized, false template not initialized</returns>
        public bool Initialize(DvtkData.Dimse.DicomMessage dicomMessage)
        {
            DvtkData.Dimse.DimseCommand command = dicomMessage.CommandField;
            System.String sopClassUid = System.String.Empty;

            DvtkData.Dimse.Attribute attribute = dicomMessage.CommandSet.GetAttribute(DvtkData.Dimse.Tag.AFFECTED_SOP_CLASS_UID);
            if (attribute == null)
            {
                attribute = dicomMessage.CommandSet.GetAttribute(DvtkData.Dimse.Tag.REQUESTED_SOP_CLASS_UID);
            }
            if ((attribute != null) &&
                (attribute.Length != 0))
            {
                UniqueIdentifier uniqueIdentifier = (UniqueIdentifier)attribute.DicomValue;
                sopClassUid = uniqueIdentifier.Values[0];
            }

            // Try to initialise a template
            _template = new DicomComparisonTemplate();
            bool initialized = _template.Initialize(command, sopClassUid);
            if (initialized == true)
            {
                // Load the template with the corresponding attribute values
                initialized = LoadTemplate(dicomMessage.DataSet);
            }

            return initialized;
        }

 //
 // - Constructors -
 //
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="dvtkDataReleaseRq">The encapsulated DvtkData A_RELEASE_RQ</param>
 public ReleaseRq(DvtkData.Dul.A_RELEASE_RQ dvtkDataReleaseRq)
     : base(dvtkDataReleaseRq)
 {
 }

 /// <summary>
 /// Class constructor.
 /// </summary>
 /// <param name="tag">Comparison Tag</param>
 /// <param name="vr">Tag VR.</param>
 /// <param name="commonDataFormat">Data Format for Tag</param>
 public DicomComparisonTag(DvtkData.Dimse.Tag tag, VR vr, BaseCommonDataFormat commonDataFormat)
 {
     _tag = tag;
     _vr = vr;
     _commonDataFormat = commonDataFormat;
 }

 /// <summary>
 /// Constructor to encapsulate an existing DvtkData A_ASSOCIATE_AC.
 /// </summary>
 /// <param name="dvtkDataAssociateAc">The encapsulated DvtkData A_ASSOCIATE_AC</param>
 internal AssociateAc(DvtkData.Dul.A_ASSOCIATE_AC dvtkDataAssociateAc)
     : base(dvtkDataAssociateAc)
 {
     // Do nothing.
 }

 //
 // - Constructors -
 //        
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="dvtkDataDulMessage">The encapsulated DvtkData DulMessage.</param>
 internal DulMessage(DvtkData.Dul.DulMessage dvtkDataDulMessage)
 {
     this.dvtkDataDulMessage = dvtkDataDulMessage;
 }