/// <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; }
public AttributeList GetNextAttributes(out TagSequence lowestTagSequence) { AttributeList nextAttributes = null; lowestTagSequence = DetermineLowestTagSequence(); // // If unprocessed attributes still exist, create and fill the AttributeList to return. // if (lowestTagSequence != null) // Still attributes to process. { nextAttributes = DetermineNextAttributes(lowestTagSequence); } else // No more attributes left to process. { nextAttributes = null; } return(nextAttributes); }
/// <summary> /// Constructor. /// /// Use this to encapsulate an existing DvtkData sequence item. /// </summary> /// <param name="tagSequence">The tag sequence of this sequence item.</param> /// <param name="dvtkDataSequenceItem">The encapsulated DvtkData SequenceItem.</param> internal SequenceItem(TagSequence tagSequence, DvtkData.Dimse.SequenceItem dvtkDataSequenceItem) : base(tagSequence, dvtkDataSequenceItem) { }
/// <summary> /// Deletes this instance from the AttributeSet it is contained in. /// </summary> /// <remarks> /// <b>Don't use this instance anymore after calling this method!</b> /// </remarks> public override void Delete() { if (this.parentAttributeSet != null) { this.parentAttributeSet.DvtkDataAttributeSet.Remove(this.dvtkDataAttribute); TagSequence = new TagSequence(); this.parentAttributeSet = null; } }
// // - Methods - // /// <summary> /// Indicates if the specified attribute exists. /// </summary> /// <param name="tagSequenceString">The tag sequence (see class TagSequence for the format).</param> /// <returns>Boolean indicating if the specified attribute exists.</returns> public bool Exists(String tagSequenceString) { bool exists = false; TagSequence tagSequence = new TagSequence(tagSequenceString); if (!tagSequence.IsSingleAttributeMatching) { throw new HliException(tagSequenceString.ToString() + " not valid for the Exists method."); } if (tagSequence.IsValidForCommandSet) { exists = this.CommandSet.Exists(tagSequence); } else if (tagSequence.IsValidForDataSet) { exists = this.DataSet.Exists(tagSequence); } else { throw new HliException(tagSequenceString.ToString() + " not valid for a DicomMessage attribute."); } return(exists); }
/// <summary> /// Adds a single attribute with the tag, VR and values specified. /// </summary> /// <remarks> /// If an attribute already exists with this tag, it is removed first before it is again /// added. /// </remarks> /// <param name="dvtkDataTag">The tag of the attribute.</param> /// <param name="vR">The VR of the attribute.</param> /// <param name="values">The values, which will be copied from another attribute, for this attribute.</param> /// <exception cref="System.ArgumentException"> /// <paramref name="dvtkDataTag"/> is not valid for setting a CommandSet attribute.<br></br> /// </exception> /// <exception cref="System.ArgumentNullException"> /// <paramref name="values"/> is a null reference. /// </exception> public override void Set(DvtkData.Dimse.Tag dvtkDataTag, VR vR, Values values) { TagSequence internalTagSequence = new TagSequence(); internalTagSequence.Add(new Tag(dvtkDataTag.GroupNumber, dvtkDataTag.ElementNumber)); // // Sanity checks. // // Check if the tag supplied is valid for a CommandSet. if (!internalTagSequence.IsValidForCommandSet) { throw new ArgumentException(internalTagSequence.ToString() + " is not valid for setting a CommandSet attribute.", "dvtkDataTag"); } if (values == null) { throw new ArgumentNullException("values"); } // // Perform the actual operation in the base class. // Set(internalTagSequence, vR, values); }
/// <summary> /// Adds a single attribute with the tag sequence, VR and values specified. /// </summary> /// <remarks> /// If an attribute already exists with this tag, it is removed first before it is again /// added. /// <br></br><br></br> /// If sequence items (each with a sequence item index) are specified in the tag sequence, /// empty sequence items will be added automatically to avoid gaps in the sequence items of sequence /// attributes. /// </remarks> /// <param name="tagSequence">The tag sequence of the attribute.</param> /// <param name="vR">The VR of the attribute.</param> /// <param name="values">The values, which will be copied from another attribute, for this attribute.</param> /// <exception cref="System.ArgumentException"> /// <paramref name="dvtkDataTag"/> is not valid for setting an attribute.<br></br> /// -or-<br></br> /// <paramref name="dvtkDataTag"/> is not valid for setting a CommandSet attribute.<br></br> /// </exception> /// <exception cref="System.ArgumentNullException"> /// <paramref name="values"/> is a null reference. /// </exception> public override void Set(String tagSequence, VR vR, Values values) { TagSequence internalTagSequence = new TagSequence(tagSequence); // // Sanity checks. // if (!internalTagSequence.IsSingleAttributeMatching) { throw new ArgumentException(internalTagSequence.ToString() + " not valid for setting an attribute."); } // Check if the tag supplied is valid for a CommandSet. if (!internalTagSequence.IsValidForCommandSet) { throw new ArgumentException(internalTagSequence.ToString() + " not valid for setting a CommandSet attribute.", "dvtkDataTag"); } if (values == null) { throw new ArgumentNullException("values"); } // // Perform the actual operation in the base class. // Set(internalTagSequence, vR, values); }
// // - Methods - // private void SetTagCellForDicomAttribute(DicomAttribute dicomAttribute, int columnIndex) { if (dicomAttribute != null) { TagSequence tagSequence = new TagSequence(dicomAttribute.ValidationRuleDicomAttribute.TagSequenceString); if (dicomAttribute.DisplayFullTagSequence) { ArrayList tags = tagSequence.Tags; for (int tagIndex = 0; tagIndex < tags.Count; tagIndex++) { Tag tag = tags[tagIndex] as Tag; if (tag.ContainsIndex) { SetCellOK(columnIndex, "".PadRight(tagIndex, '>') + tag.DicomNotation + "(" + tag.IndexNumber + ")"); } else { SetCellOK(columnIndex, "".PadRight(tagIndex, '>') + tag.DicomNotation); } } } else { SetCellOK(columnIndex, tagSequence.DicomNotation); } } if (this.displayFlags) { SetCellOK(columnIndex, "<br><i>Flags:</i>"); SetCellOK(columnIndex, "<i>" + dicomAttribute.ValidationRule.FlagsString + "</i>"); } }
private void SetPresentCellForAttribute(AttributeList attributeList, int zeroBasedIndex) { int columnIndex = (int)this.columnIndexAttributePresent[zeroBasedIndex]; AttributeBase attributebase = attributeList[zeroBasedIndex]; if (attributebase != null) { String presentString = ""; bool containsError = false; if (attributebase.IsPresent) { presentString = "+"; } else { presentString = "-"; } if ((attributebase.ValidationRule.Flags & FlagsBase.Compare_present) == FlagsBase.Compare_present) { if (attributeList.ContainsComparePresentErrors) { containsError = true; } } if ((attributebase.ValidationRule.Flags & FlagsBase.Present) == FlagsBase.Present) { if (!attributebase.IsPresent) { containsError = true; } } if ((attributebase.ValidationRule.Flags & FlagsBase.Not_present) == FlagsBase.Not_present) { if (attributebase.IsPresent) { containsError = true; } } // If this is a Dicom attribute which is a group length, only compare when the compareGroupLength // field is true. if ((!this.displayGroupLength) && (attributebase is DicomAttribute)) { DicomAttribute dicomAttribute = attributebase as DicomAttribute; TagSequence tagSequence = new TagSequence(dicomAttribute.ValidationRuleDicomAttribute.TagSequenceString); if (tagSequence.LastTag.ElementNumber == 0) { containsError = false; } } if (containsError) { SetCellError(columnIndex, presentString); } else { SetCellOK(columnIndex, presentString); } } }
// // - Methods - // /// <summary> /// Adds a sequence item to the end of the item list. /// </summary> /// <remarks> /// This method is only meaningfull if this instance has a VR SQ. /// </remarks> /// <param name="item">The sequence item to add.</param> public override void AddItem(SequenceItem item) { if (this.VR == VR.SQ) { SequenceItem cloneSequenceItem = item.Clone(); DvtkDataSequence.Add(cloneSequenceItem.DvtkDataSequenceItem); } else { Thread.WriteWarningCurrentThread("Adding a sequence item to an attribute with tag sequence " + TagSequence.ToString() + " and VR " + this.VR.ToString() + ". Doing nothing."); } }
/// <summary> /// Clears all sequence items present in the attribute. /// </summary> /// <remarks> /// This method is only meaningfull if this instance has a VR SQ. /// </remarks> public override void ClearItems() { if (this.VR == VR.SQ) { DvtkDataSequence.Clear(); } else { Thread.WriteWarningCurrentThread("Clearing the sequence items of an attribute with tag sequence " + TagSequence.ToString() + " and VR " + this.VR.ToString() + ". Doing nothing."); } }
/// <summary> /// Obsolete class, use the classes in the namespace DvtkHighLevelInterface.Common.Compare instead. /// </summary> /// <param name="dicomAttributesToValidate">-</param> /// <param name="zeroBasedIndex">-</param> private void AddAttributeInformationForAttribute(DicomAttributesToValidate dicomAttributesToValidate, int zeroBasedIndex) { bool isAttributePresent = false; DicomAttributeToValidate dicomAttributeToValidate = dicomAttributesToValidate[zeroBasedIndex] as DicomAttributeToValidate; CompareFlags compareFlags = dicomAttributeToValidate.ValidationRuleDicomAttribute.CompareFlags; DicomAttributeFlags dicomAttributeFlags = dicomAttributeToValidate.ValidationRuleDicomAttribute.DicomAttributeFlags; if (dicomAttributeToValidate.Attribute is ValidAttribute) { isAttributePresent = true; } else { isAttributePresent = false; } // Attribute Tag column. if (this.displayAttributeTag) { if (isAttributePresent) { if (dicomAttributeToValidate.ValidationRuleDicomAttribute.DisplayFullTagSequence) { ArrayList tags = (dicomAttributeToValidate.Attribute as ValidAttribute).TagSequence.Tags; for (int tagIndex = 0; tagIndex < tags.Count; tagIndex++) { Tag tag = tags[tagIndex] as Tag; if (tag.ContainsIndex) { SetCellOK((int)this.columnIndexAttributeTag[zeroBasedIndex], "".PadRight(tagIndex, '>') + tag.DicomNotation + "(" + tag.IndexNumber + ")"); } else { SetCellOK((int)this.columnIndexAttributeTag[zeroBasedIndex], "".PadRight(tagIndex, '>') + tag.DicomNotation); } } } else { SetCellOK((int)this.columnIndexAttributeTag[zeroBasedIndex], ((ValidAttribute)dicomAttributeToValidate.Attribute).TagSequence.DicomNotation); } } else { if (dicomAttributeToValidate.ValidationRuleDicomAttribute.TagSequence == "") { SetCellNotApplicable((int)this.columnIndexAttributeTag[zeroBasedIndex]); } else { TagSequence tagSequence = new TagSequence(dicomAttributeToValidate.ValidationRuleDicomAttribute.TagSequence); ArrayList tags = tagSequence.Tags; for (int tagIndex = 0; tagIndex < tags.Count; tagIndex++) { Tag tag = tags[tagIndex] as Tag; if (tag.ContainsIndex) { SetCellOK((int)this.columnIndexAttributeTag[zeroBasedIndex], "".PadRight(tagIndex, '>') + tag.DicomNotation + "(" + tag.IndexNumber + ")"); } else { SetCellOK((int)this.columnIndexAttributeTag[zeroBasedIndex], "".PadRight(tagIndex, '>') + tag.DicomNotation); } } } } } // Attribute Name column. if (this.displayAttributeName) { if (isAttributePresent) { SetCellOK((int)this.columnIndexAttributeName[zeroBasedIndex], GetAttributeName(dicomAttributeToValidate.Attribute)); } else { if (dicomAttributeToValidate.ValidationRuleDicomAttribute.TagSequence == "") { SetCellNotApplicable((int)this.columnIndexAttributeName[zeroBasedIndex]); } else { SetCellOK((int)this.columnIndexAttributeName[zeroBasedIndex], "-"); } } } // Attribute Present column. if (this.displayAttributePresent) { if (dicomAttributeToValidate.ValidationRuleDicomAttribute.TagSequence == "") { SetCellNotApplicable((int)this.columnIndexAttributePresent[zeroBasedIndex]); } else { String presentString = ""; bool containsError = false; if (isAttributePresent) { presentString = "+"; } else { presentString = "-"; } if ((compareFlags & CompareFlags.Compare_present) == CompareFlags.Compare_present) { if (dicomAttributesToValidate.ContainsComparePresentErrors) { containsError = true; } } if ((dicomAttributeFlags & DicomAttributeFlags.Present) == DicomAttributeFlags.Present) { if (!isAttributePresent) { containsError = true; } } if ((dicomAttributeFlags & DicomAttributeFlags.Not_present) == DicomAttributeFlags.Not_present) { if (isAttributePresent) { containsError = true; } } if (containsError) { SetCellError((int)this.columnIndexAttributePresent[zeroBasedIndex], presentString); } else { SetCellOK((int)this.columnIndexAttributePresent[zeroBasedIndex], presentString); } } } // Attribute VR column. if (this.displayAttributeVR) { if (isAttributePresent) { bool containsError = false; if ((compareFlags & CompareFlags.Compare_VR) == CompareFlags.Compare_VR) { if (dicomAttributesToValidate.ContainsCompareVRErrors) { containsError = true; } } if (containsError) { SetCellError((int)this.columnIndexAttributeVR[zeroBasedIndex], dicomAttributeToValidate.Attribute.VR.ToString()); } else { SetCellOK((int)this.columnIndexAttributeVR[zeroBasedIndex], dicomAttributeToValidate.Attribute.VR.ToString()); } } else { SetCellNotApplicable((int)this.columnIndexAttributeVR[zeroBasedIndex]); } } // Attribute Values column. if (this.displayAttributeValues) { int columnIndex = (int)this.columnIndexAttributeValues[zeroBasedIndex]; if (isAttributePresent) { if (dicomAttributeToValidate.Attribute.VR == VR.SQ) { SetCellNotApplicable(columnIndex); } else { bool containsError = false; if ((compareFlags & CompareFlags.Compare_values) == CompareFlags.Compare_values) { if (dicomAttributesToValidate.ContainsCompareValuesErrors) { containsError = true; } } if ((dicomAttributeFlags & DicomAttributeFlags.Values) == DicomAttributeFlags.Values) { if (dicomAttributeToValidate.Attribute.Values.Count == 0) { containsError = true; } } if ((dicomAttributeFlags & DicomAttributeFlags.No_values) == DicomAttributeFlags.No_values) { if (dicomAttributeToValidate.Attribute.Values.Count > 0) { containsError = true; } } if (containsError) { SetCellError(columnIndex, dicomAttributeToValidate.Attribute.Values.ToString()); } else { SetCellOK(columnIndex, dicomAttributeToValidate.Attribute.Values.ToString()); } } } else { SetCellNotApplicable(columnIndex); } } }
/// <summary> /// Creates a deep copy of this TagSequence. /// </summary> /// <returns>The created deep copy.</returns> internal TagSequence Clone() { TagSequence cloneTagSequence = new TagSequence(); foreach(Tag tag in this.tags) { Tag cloneTag = tag.Clone(); cloneTagSequence.Add(cloneTag); } return(cloneTagSequence); }
/// <summary> /// Adds a single attribute with the tag sequence, VR and values specified. /// </summary> /// <remarks> /// Depending on the group number of the last tag in the tag sequence, the attribute /// is set in the CommandSet or DataSet of this instance. /// <br></br><br></br> /// If an attribute already exists with this tag sequence, it is removed first before it is /// again set. /// <br></br><br></br> /// If sequence items (each with a sequence item index) are specified in the tag sequence, /// empty sequence items will be added automatically to avoid gaps in the sequence items of sequence /// attributes. /// </remarks> /// <param name="tagSequence">The tag sequence that uniquely identifies the attribute.</param> /// <param name="vR">The VR of the attribute.</param> /// <param name="parameters"> /// The values of the attribute. Do not use the DICOM delimeter '\' directly. Instead use /// multiple parameter arguments for this method when adding a single attribute with multiple values. /// </param> internal void Set(TagSequence tagSequence, VR vR, params Object[] parameters) { // Check if the TagSequence supplied uniquely identifies one attribute. if (!tagSequence.IsSingleAttributeMatching) { throw new HliException(tagSequence.ToString() + " not valid for setting an attribute."); } if (tagSequence.IsValidForCommandSet) { CommandSet.Set(tagSequence, vR, parameters); } else if (tagSequence.IsValidForDataSet) { DataSet.Set(tagSequence, vR, parameters); } else { throw new HliException(tagSequence.ToString() + " not valid for setting a DicomMessage attribute."); } }
/// <summary> /// Adds a single attribute with the tag sequence string, VR and values specified. /// </summary> /// <remarks> /// Depending on the group number of the last tag in the tag sequence string, the attribute /// is set in the CommandSet or DataSet of this instance. /// <br></br><br></br> /// If an attribute already exists with this tag sequence string, it is removed first before it is /// again set. /// <br></br><br></br> /// If sequence items (each with a sequence item index) are specified in the tag sequence string, /// empty sequence items will be added automatically to avoid gaps in the sequence items of sequence /// attributes. /// </remarks> /// <param name="tagSequenceString">The tag sequence string that uniquely identifies the attribute.</param> /// <param name="vR">The VR of the attribute.</param> /// <param name="parameters"> /// The values of the attribute. Do not use the DICOM delimeter '\' directly. Instead use /// multiple parameter arguments for this method when adding a single attribute with multiple values. /// </param> public void Set(String tagSequenceString, VR vR, params Object[] parameters) { TagSequence tagSequence = new TagSequence(tagSequenceString); Set(tagSequence, vR, parameters); }
/// <summary> /// Adds a single attribute with the tag, VR and values specified. /// </summary> /// <remarks> /// Depending on the group number of the tag, the attribute /// is set in the CommandSet or DataSet of this instance. /// <br></br><br></br> /// If an attribute already exists with this tag, it is removed first before it is /// again set. /// </remarks> /// <param name="dvtkDataTag">The tag that uniquely identifies the attribute.</param> /// <param name="vR">The VR of the attribute.</param> /// <param name="parameters"> /// The values of the attribute. Do not use the DICOM delimeter '\' directly. Instead use /// multiple parameter arguments for this method when adding a single attribute with multiple values. /// </param> public void Set(DvtkData.Dimse.Tag dvtkDataTag, VR vR, params Object[] parameters) { TagSequence tagSequence = new TagSequence(); tagSequence.Add(new Tag(dvtkDataTag.GroupNumber, dvtkDataTag.ElementNumber)); Set(tagSequence, vR, parameters); }
/// <summary> /// Creates a deep copy of this instance. /// </summary> /// <param name="parentAttributeSetToCloneTo"> /// The AttributeSet the new cloned Attribute wil become part of. /// </param> /// <returns>The created deep copy of this instance.</returns> internal override Attribute Clone(AttributeSet parentAttributeSetToCloneTo) { // // Clone the attribute without values. // TagSequence newTagSequence = parentAttributeSetToCloneTo.TagSequence.Clone(); Tag lastTagCurrentAttribute = TagSequence.Tags[TagSequence.Tags.Count - 1] as Tag; newTagSequence.Add(lastTagCurrentAttribute); ValidAttribute cloneAttribute = new ValidAttribute(newTagSequence, new DvtkData.Dimse.Attribute(lastTagCurrentAttribute.AsUInt32, (DvtkData.Dimse.VR) this.VR), parentAttributeSetToCloneTo); // // Add the values or items to the cloned attribute. // Values currentValues = this.Values; Values cloneValues = cloneAttribute.Values; if (currentValues.IsImplementedWithCollection) { Object[] collectionAsArray = new Object[currentValues.CollectionImplementation.Count]; currentValues.CollectionImplementation.CopyTo(collectionAsArray, 0); cloneValues.Add(collectionAsArray); } else if (currentValues.IsImplementedWithString) { cloneValues.Add(currentValues.StringImplementation); } else if ((currentValues.Attribute.VR == VR.OB) || (currentValues.Attribute.VR == VR.OF) || (currentValues.Attribute.VR == VR.OW)) { cloneValues.Add(currentValues); } else if (this.VR == VR.UN) { cloneValues.ByteArrayImplementation = currentValues.ByteArrayImplementation; } else if (this.VR == VR.SQ) { for (int index = 1; index <= this.ItemCount; index++) { // The AddItem will take care that the item is cloned. cloneAttribute.AddItem(this.GetItem(index)); } } else { // Do nothing. } // // Set the Name of the attribute. // cloneAttribute.Name = Name; return(cloneAttribute); }
/// <summary> /// Converts the supplied array to a DvtkData TagCollection. /// </summary> /// <remarks> /// When an array element is null, it will be skipped.<br></br><br></br> /// When an array element cannot be converted, it will be interpreted as a tag with value 0x00000000. /// </remarks> /// <param name="objects">The array to convert.</param> /// <returns>The returned DvtkData TagCollection.</returns> private DvtkData.Collections.TagCollection ConvertToTagCollection(object[] objects) { DvtkData.Collections.TagCollection tagCollection = new DvtkData.Collections.TagCollection(); foreach (object item in objects) { if (item != null) { DvtkData.Dimse.Tag dvtkDataTag = null; try { if (item is DvtkData.Dimse.Tag) { DvtkData.Dimse.Tag sourceDvtkDataTag = item as DvtkData.Dimse.Tag; dvtkDataTag = new DvtkData.Dimse.Tag(sourceDvtkDataTag.GroupNumber, sourceDvtkDataTag.ElementNumber); } else if (item is System.Int32) { dvtkDataTag = (System.Int32)item; } else if (item is System.UInt32) { dvtkDataTag = (System.UInt32)item; } else if (item is String) { TagSequence tagSequence = new TagSequence(item as String); if (tagSequence.IsSingleAttributeMatching) { if (tagSequence.Tags.Count == 1) { Tag tag = tagSequence.Tags[0] as Tag; dvtkDataTag = new DvtkData.Dimse.Tag(tag.GroupNumber, tag.ElementNumber); } else { throw new ArgumentException("One of the Array elements represents a nested tag."); } } else { throw new ArgumentException("One of the Array elements represents an indexed tag."); } } else { throw new ArgumentException("One of the Array elements is of an unexpected type."); } } catch { dvtkDataTag = new DvtkData.Dimse.Tag(0x0000, 0x0000); } tagCollection.Add(dvtkDataTag); } } return (tagCollection); }
/// <summary> /// Gets a sequence item. /// </summary> /// <remarks> /// This method is only meaningfull if this instance has a VR SQ. /// </remarks> /// <param name="oneBasedIndex">The one based index.</param> /// <returns>The sequence item.</returns> public override SequenceItem GetItem(int oneBasedIndex) { SequenceItem sequenceItem = null; if (this.VR == VR.SQ) { if ((oneBasedIndex >= 1) && (oneBasedIndex <= ItemCount)) { TagSequence sequenceItemTagSequence = TagSequence.Clone(); Tag lastTag = sequenceItemTagSequence.Tags[sequenceItemTagSequence.Tags.Count - 1] as Tag; lastTag.IndexNumber = oneBasedIndex; sequenceItem = new SequenceItem(sequenceItemTagSequence, DvtkDataSequence[oneBasedIndex - 1]); } else { sequenceItem = new SequenceItem(); Thread.WriteWarningCurrentThread("Getting sequence item " + oneBasedIndex.ToString() + " from attribute with tag sequence " + TagSequence.ToString() + " containing " + ItemCount.ToString() + " items. Returning an empty sequence item."); } } else { sequenceItem = new SequenceItem(); Thread.WriteWarningCurrentThread("Getting a sequence item from attribute with tag sequence " + TagSequence.ToString() + " and VR " + this.VR.ToString() + ". Returning an empty sequence item."); } return(sequenceItem); }
private void SetValuesCellForAttribute(AttributeList attributeList, int zeroBasedIndex) { int columnIndex = (int)this.columnIndexAttributeValues[zeroBasedIndex]; AttributeBase attributebase = attributeList[zeroBasedIndex]; if (attributebase.IsPresent) { bool isDicomSequenceAttribute = false; if (attributebase is DicomAttribute) { if ((attributebase as DicomAttribute).AttributeOnly.VR == VR.SQ) { isDicomSequenceAttribute = true; } } if (!isDicomSequenceAttribute) { bool containsError = false; String valuesString = attributebase.ValuesToString(); if ((attributebase.ValidationRule.Flags & FlagsBase.Compare_values) == FlagsBase.Compare_values) { if (attributeList.ContainsCompareValuesErrors) { containsError = true; } } if ((attributebase.ValidationRule.Flags & FlagsBase.Values) == FlagsBase.Values) { if (valuesString.Length == 0) { containsError = true; } } if ((attributebase.ValidationRule.Flags & FlagsBase.No_values) == FlagsBase.No_values) { if (valuesString.Length > 0) { containsError = true; } } // If this is a Dicom attribute which is a group length, only compare when the compareGroupLength // field is true. if ((!this.displayGroupLength) && (attributebase is DicomAttribute)) { DicomAttribute dicomAttribute = attributebase as DicomAttribute; TagSequence tagSequence = new TagSequence(dicomAttribute.ValidationRuleDicomAttribute.TagSequenceString); if (tagSequence.LastTag.ElementNumber == 0) { containsError = false; } } // If the attribute contains no values, display this with the text "No values" in italic. if (valuesString.Length == 0) { valuesString = "<i>No values</i>"; } if (containsError) { SetCellError(columnIndex, valuesString); } else { SetCellOK(columnIndex, valuesString); } } else // Is Sequence attribute. { if ((attributebase.ValidationRule.Flags & FlagsBase.Include_sequence_items) == 0) // If sequence item will not be displayed. { SetCellOK(columnIndex, "<i>Items will not be displayed.</i>"); } } } }
/// <summary> /// Insert a Sequence Item at a specified position. /// </summary> /// <remarks> /// This method is only meaningfull if this instance has a VR SQ. The inserted Sequence /// Item will get item number oneBasedIndex. /// </remarks> /// <param name="oneBasedIndex">The one based index of the position to insert.</param> /// <param name="item">The Sequence item to insert.</param> public override void InsertItem(int oneBasedIndex, SequenceItem item) { if (this.VR == VR.SQ) { if ((oneBasedIndex >= 1) && (oneBasedIndex <= (ItemCount + 1))) { SequenceItem cloneSequenceItem = item.Clone(); DvtkDataSequence.Insert(oneBasedIndex - 1, cloneSequenceItem.DvtkDataSequenceItem); } else { Thread.WriteWarningCurrentThread("Inserting sequence item at one based position " + oneBasedIndex.ToString() + " fom attribute with tag sequence " + TagSequence.ToString() + " containing " + ItemCount.ToString() + " items. Doing nothing."); } } else { Thread.WriteWarningCurrentThread("Adding a sequence item to an attribute with tag sequence " + TagSequence.ToString() + " and VR " + this.VR.ToString() + ". Doing nothing."); } }
/// <summary> /// Adds a single attribute with the tag, VR and value specified. /// </summary> /// <remarks> /// Only use this method for setting an attribute with VR OB, OF or OW. /// <br></br><br></br> /// If an attribute already exists with this tag, it is removed first before it is again /// added. /// </remarks> /// <param name="dvtkDataTag">The tag of the attribute.</param> /// <param name="vR">The VR (may only be OB, OF or OW) of the attribute.</param> /// <param name="value">The value of the attribute.</param> /// <exception cref="System.ArgumentException"> /// <paramref name="dvtkDataTag"/> is not valid for setting a CommandSet attribute.<br></br> /// -or-<br></br> /// <paramref name="vR"/> is unequal to OB, OF or OW. /// </exception> /// <exception cref="System.ArgumentNullException"> /// <paramref name="value"/> is a null reference. /// </exception> public override void Set(DvtkData.Dimse.Tag dvtkDataTag, VR vR, Byte[] value) { TagSequence internalTagSequence = new TagSequence(); internalTagSequence.Add(new Tag(dvtkDataTag.GroupNumber, dvtkDataTag.ElementNumber)); // // Sanity checks. // // Check if the tag supplied is valid for a CommandSet. if (!internalTagSequence.IsValidForCommandSet) { throw new ArgumentException(internalTagSequence.ToString() + " is not valid for setting a CommandSet attribute.", "dvtkDataTag"); } // Check the supplied VR. if ((vR != VR.OB) && (vR != VR.OF) && (vR != VR.OW)) { throw new ArgumentException("Supplied VR is " + vR.ToString() + ". VR may only be OB, OF or OW.", "vR"); } if (value == null) { throw new ArgumentNullException("value"); } // // Perform the actual operation in the base class. // Set(internalTagSequence, vR, value); }
/// <summary> /// Removes a sequence item. /// </summary> /// <param name="oneBasedIndex">The one based index</param> public override void RemoveItemAt(int oneBasedIndex) { if (this.VR == VR.SQ) { if ((oneBasedIndex >= 1) && (oneBasedIndex <= ItemCount)) { DvtkDataSequence.RemoveAt(oneBasedIndex - 1); } else { Thread.WriteWarningCurrentThread("Removing sequence item " + oneBasedIndex.ToString() + " from attribute with tag sequence " + TagSequence.ToString() + " containing " + ItemCount.ToString() + " items. Doing nothing."); } } else { Thread.WriteWarningCurrentThread("Removing a sequence item from attribute with tag sequence " + TagSequence.ToString() + " and VR " + this.VR.ToString() + ". Doing nothing."); } }
/// <summary> /// Adds a single attribute with the tag sequence, VR and value specified. /// </summary> /// <remarks> /// Only use this method for setting an attribute with VR OB, OF or OW. /// <br></br><br></br> /// If an attribute already exists with this tag, it is removed first before it is again /// added. /// <br></br><br></br> /// If sequence items (each with a sequence item index) are specified in the tag sequence, /// empty sequence items will be added automatically to avoid gaps in the sequence items of sequence /// attributes. /// </remarks> /// <param name="tagSequence">The tag sequence of the attribute.</param> /// <param name="vR">The VR (may only be OB, OF or OW) of the attribute.</param> /// <param name="value">The value of the attribute.</param> /// <exception cref="System.ArgumentException"> /// <paramref name="dvtkDataTag"/> is not valid for setting an attribute.<br></br> /// -or-<br></br> /// <paramref name="dvtkDataTag"/> is not valid for setting a CommandSet attribute.<br></br> /// -or-<br></br> /// <paramref name="vR"/> is unequal to OB, OF or OW. /// </exception> /// <exception cref="System.ArgumentNullException"> /// <paramref name="value"/> is a null reference. /// </exception> public override void Set(String tagSequence, VR vR, Byte[] value) { TagSequence internalTagSequence = new TagSequence(tagSequence); // // Sanity checks. // if (!internalTagSequence.IsSingleAttributeMatching) { throw new ArgumentException(internalTagSequence.ToString() + " not valid for setting an attribute."); } // Check if the tag supplied is valid for a CommandSet. if (!internalTagSequence.IsValidForCommandSet) { throw new ArgumentException(internalTagSequence.ToString() + " not valid for setting a CommandSet attribute.", "dvtkDataTag"); } // Check the supplied VR. if ((vR != VR.OB) && (vR != VR.OF) && (vR != VR.OW)) { throw new ArgumentException("Supplied VR is " + vR.ToString() + ". VR may only be OB, OF or OW.", "vR"); } if (value == null) { throw new ArgumentNullException("value"); } // // Perform the actual operation in the base class. // Set(internalTagSequence, vR, value); }
// // - Methods - // /// <summary> /// Get the next collection of attributes to compare to each other. /// If an attribute is not present, a null pointer is returned in the AttributeCollection. /// If all attributes have been compared, null is returned. /// </summary> /// <returns>The attributes to validate.</returns> /// private AttributeList DetermineNextAttributes(TagSequence lowestTagSequence) { AttributeList nextAttributes = new AttributeList(); nextAttributes.CompareRule = new CompareRule(); for (int index = 0; index < this.attributeCollections.Count; index++) { int attributeSetIndex = (int)this.currentAttributeIndices[index]; AttributeCollectionBase attributeCollectionBase = this.attributeCollections[index]; if (attributeCollectionBase == null) { nextAttributes.Add(null); nextAttributes.CompareRule.Add(null); } else if (attributeCollectionBase is Hl7AttributeCollection) { nextAttributes.Add(null); nextAttributes.CompareRule.Add(null); } else if (attributeCollectionBase is DicomAttributeCollection) { DicomAttributeCollection dicomAttributeCollection = attributeCollectionBase as DicomAttributeCollection; if (attributeSetIndex < dicomAttributeCollection.AttributeSetOnly.Count) // Still unprocessed attributes left in this dataset. { ValidAttribute attributeOnly = dicomAttributeCollection.AttributeSetOnly[attributeSetIndex] as ValidAttribute; if (attributeOnly.TagSequence.LastTag.AsUInt32 == lowestTagSequence.LastTag.AsUInt32) { // Add entry with existing attribute. ValidationRuleDicomAttribute validationRuleDicomAttribute = new ValidationRuleDicomAttribute(lowestTagSequence.ToString(), dicomAttributeCollection.Flags); nextAttributes.CompareRule.Add(validationRuleDicomAttribute); DicomAttribute dicomAttribute = new DicomAttribute(attributeOnly, validationRuleDicomAttribute); nextAttributes.Add(dicomAttribute); // This attribute will be returned. Increase the attribute index. this.currentAttributeIndices[index] = attributeSetIndex + 1; } else { // Add entry with non-existing attribute. ValidationRuleDicomAttribute validationRuleDicomAttribute = new ValidationRuleDicomAttribute(lowestTagSequence.ToString(), dicomAttributeCollection.Flags); DicomAttribute dicomAttribute = new DicomAttribute(new DvtkHighLevelInterface.Dicom.Other.InvalidAttribute(), validationRuleDicomAttribute); nextAttributes.Add(dicomAttribute); } } else // No more unprocessed attributes left in this dataset. { // Add entry with non-existing attribute. ValidationRuleDicomAttribute validationRuleDicomAttribute = new ValidationRuleDicomAttribute(lowestTagSequence.ToString(), dicomAttributeCollection.Flags); DicomAttribute dicomAttribute = new DicomAttribute(new DvtkHighLevelInterface.Dicom.Other.InvalidAttribute(), validationRuleDicomAttribute); nextAttributes.Add(dicomAttribute); } } } return(nextAttributes); }
// // - Constructors - // /// <summary> /// Default constructor. /// </summary> public InvalidAttribute() { TagSequence = new TagSequence("0x00000000"); }
/// <summary> /// Constructor. /// </summary> /// <param name="tagSequence">Tag sequence used to retrieve the attribute.</param> public InvalidAttribute(TagSequence tagSequence) { TagSequence = tagSequence; }
/// <summary> /// Adds a single attribute with the tag, VR and values specified. /// </summary> /// <remarks> /// If an attribute already exists with this tag, it is removed first before it is again /// added. /// </remarks> /// <param name="dvtkDataTag">The tag of the attribute.</param> /// <param name="vR">The VR of the attribute.</param> /// <param name="values"> /// The values of the attribute. Do not use the DICOM delimeter '\' directly. Instead supply /// multiple values arguments for this method when adding a single attribute with multiple values. /// </param> /// <exception cref="System.ArgumentException"> /// <paramref name="dvtkDataTag"/> is not valid for setting a FileMetaInformation attribute.<br></br> /// </exception> /// <exception cref="System.ArgumentNullException"> /// <paramref name="values"/> is a null reference. /// </exception> public override void Set(DvtkData.Dimse.Tag dvtkDataTag, VR vR, params Object[] values) { TagSequence internalTagSequence = new TagSequence(); internalTagSequence.Add(new Tag(dvtkDataTag.GroupNumber, dvtkDataTag.ElementNumber)); // // Sanity checks. // // Check if the tag supplied is valid for a FileMetaInformation. if (!internalTagSequence.IsValidForFileMetaInformation) { throw new ArgumentException(internalTagSequence.ToString() + " is not valid for setting a FileMetaInformation attribute.", "dvtkDataTag"); } if (values == null) { throw new ArgumentNullException("values"); } // // Perform the actual operation. // Set(internalTagSequence, vR, values); if ((internalTagSequence.ToString() == "0x00020010") && (values.Length == 1)) { this.dvtkDataFileHead.TransferSyntax = new DvtkData.Dul.TransferSyntax(values[0].ToString()); } }
/// <summary> /// Gets the attribute that has the supplied tag sequence string. /// </summary> /// <param name="tagSequenceString"></param> /// <returns></returns> public Attribute this[String tagSequenceString] { get { Attribute attribute = null; TagSequence tagSequence = new TagSequence(tagSequenceString); if (!tagSequence.IsSingleAttributeMatching) { throw new HliException(tagSequenceString.ToString() + " not valid for the index property."); } if (tagSequence.IsValidForCommandSet) { attribute = this.CommandSet[tagSequence]; } else if (tagSequence.IsValidForDataSet) { attribute = this.DataSet[tagSequence]; } else { throw new HliException(tagSequenceString.ToString() + " not valid for a DicomMessage attribute."); } return(attribute); } }
/// <summary> /// Adds a single attribute with the tag sequence, VR and values specified. /// </summary> /// <remarks> /// If an attribute already exists with this tag, it is removed first before it is again /// added. /// <br></br> /// If sequence items (each with a sequence item index) are specified in the tag sequence, /// empty sequence items will be added automatically to avoid gaps in the sequence items of sequence /// attributes. /// </remarks> /// <param name="tagSequence">The tag sequence of the attribute.</param> /// <param name="vR">The VR of the attribute.</param> /// <param name="values">The values, which will be copied from another attribute, for this attribute.</param> /// <exception cref="System.ArgumentException"> /// <paramref name="dvtkDataTag"/> is not valid for setting an attribute.<br></br> /// -or-<br></br> /// <paramref name="dvtkDataTag"/> is not valid for setting a FileMetaInformation attribute.<br></br> /// </exception> /// <exception cref="System.ArgumentNullException"> /// <paramref name="values"/> is a null reference. /// </exception> public override void Set(String tagSequence, VR vR, Values values) { TagSequence internalTagSequence = new TagSequence(tagSequence); // // Sanity checks. // if (!internalTagSequence.IsSingleAttributeMatching) { throw new ArgumentException(internalTagSequence.ToString() + " not valid for setting an attribute."); } // Check if the tag supplied is valid for a FileMetaInformation. if (!internalTagSequence.IsValidForFileMetaInformation) { throw new ArgumentException(internalTagSequence.ToString() + " not valid for setting a FileMetaInformation attribute.", "dvtkDataTag"); } if (values == null) { throw new ArgumentNullException("values"); } // // Perform the actual operation. // Set(internalTagSequence, vR, values); if ((internalTagSequence.ToString() == "0x00020010") && (values.Count == 1)) { this.dvtkDataFileHead.TransferSyntax = new DvtkData.Dul.TransferSyntax(values[0]); } }