/// <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); }
/// <summary> /// Get all attributes that are refered to by this tag sequence. /// /// Precondition for the supplied TagSequence: /// All but the last tag contains an index. /// The last tag doesn't contain an index. /// </summary> /// <param name="tagSequence">The tag sequence.</param> /// <returns>The attributes.</returns> internal AttributeCollection GetAttributes(TagSequence tagSequence) { AttributeCollection attributeCollection = new AttributeCollection(); Tag firstTag = (tagSequence.Tags[0]) as Tag; Attribute firstAttribute = GetAttribute(firstTag.AsUInt32); if (firstAttribute is InvalidAttribute) { // Do nothing, just return an empty set. } else { if (tagSequence.Tags.Count > 1) // Expecting a sequence attribute as first tag. { if (firstAttribute.VR == VR.SQ) { int fromIndex = 0; int toIndex = 0; if (firstTag.ContainsWildcardIndex) { fromIndex = 1; toIndex = firstAttribute.ItemCount; } else { fromIndex = firstTag.IndexNumber; toIndex = firstTag.IndexNumber; } TagSequence itemTagSequence = tagSequence.Clone(); itemTagSequence.Tags.RemoveAt(0); for (int index = fromIndex; index <= toIndex; index++) { SequenceItem item = firstAttribute.GetItem(index); AttributeCollection itemAttributeCollection = item.GetAttributes(itemTagSequence); attributeCollection.AddRange(itemAttributeCollection); } } else { // Do nothing, just return an empty set. } } else // Expecting a non-sequence attribute as tag. { attributeCollection.Add(firstAttribute); } } return(attributeCollection); }
/// <summary> /// Constructor. /// </summary> /// <param name="sequenceItem">The single sequence item that encodes this Measured Value.</param> public MeasuredValue(SequenceItem sequenceItem) { this.sequenceItem = sequenceItem; this.measurementUnits = ConceptCode.CreateConceptCode(sequenceItem, "0x004008EA", measurementUnitsContext); this.validationResults = new ValidationResults(context); }
/// <summary> /// Clear all attributes from this SequenceItem and clone all attributes /// from the supplied SequenceItem. /// </summary> /// <param name="sequenceItem">The SequenceItem to clone from.</param> public void CloneFrom(SequenceItem sequenceItem) { Clear(); for (int index = 0; index < sequenceItem.Count; index++) { // The Add method will take care of the deep copy. Add(sequenceItem[index]); } }
// // - Methods - // /// <summary> /// Clone this SequenceItem using deep copy. /// </summary> /// <returns>The cloned SequenceItem.</returns> public SequenceItem Clone() { SequenceItem cloneSequenceItem = new SequenceItem(); for (int index = 0; index < this.Count; index++) { // The Add method will take care of the deep copy. cloneSequenceItem.Add(this[index]); } return(cloneSequenceItem); }
// // - 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> /// Get a SequenceItem by specifying a tagSequence /// <paramref name="tagSequence">tagSequence</paramref>. /// </summary> /// <param name="tagSequence"> /// The (tag)Sequence of which you want a SequenceItem. /// </param> /// <param name="oneBasedIndex"> /// Specify which SequenceItem is requested. (1 for the first SequenceItem in the sequence) /// </param> /// <example> /// <b>VB .NET</b> /// <code> /// 'Get a SequenceItem by specifying a tagSequence /// /// 'DataSet is inherited from AttributeSet /// Dim myDataSet As DvtkHighLevelInterface.Dicom.Other.DataSet /// /// myDataSet.Read("c:\Somefile.dcm") /// /// 'Get the first Sequence item from the specified Sequence /// Dim mySequenceItem As DvtkHighLevelInterface.Dicom.Other.SequenceItem /// /// If myDataSet.Exists("0x00080096") Then /// If myDataSet.GetitemCount("0x00080096") > 0 Then /// mySequenceItem = myDataSet.Getitem("0x00080096", 1) /// End If /// End If /// </code> /// </example> /// <returns> /// A Values Object containing a list of all values the attribute contains. /// </returns> /// <exception cref="HliException"> /// Tag sequence supplied invalid for this operation. /// </exception> ///<remarks> /// If the attribute requested by the tagSequence is non existent or invalid an empty SequenceItem will be returned. ///</remarks> public SequenceItem Getitem(String tagSequence, int oneBasedIndex) { // // Sanity checks. // if (tagSequence == null) { throw new ArgumentNullException("tagSequence"); } TagSequence internalTagSequence = new TagSequence(tagSequence); if (!internalTagSequence.IsValid) { throw new ArgumentException("Tag sequence is not valid", "tagSequence"); } if (!internalTagSequence.IsSingleAttributeMatching) { throw new ArgumentException("Tag sequence must specify a single attribute", "tagSequence"); } if (oneBasedIndex == 0) { throw new ArgumentException("Index is one based", "oneBasedIndex"); } // // Perform the actual operation. // SequenceItem sequenceItem = null; ValidAttribute validAttribute = this[internalTagSequence] as ValidAttribute; if (validAttribute == null) { sequenceItem = new SequenceItem(); Thread.WriteWarningCurrentThread("Trying to get a sequence item for an invalid attribute with tag sequence " + tagSequence + ". Returning an empty sequence item."); } else { sequenceItem = validAttribute.GetItem(oneBasedIndex); } return(sequenceItem); }
public void AddItem_tagSequence_sequenceItem() { String tagSequence = ""; DvtkHighLevelInterface.Dicom.Other.SequenceItem sequenceItem = null; // null value exception try { fileMetaInformation.AddItem(tagSequence, sequenceItem); } catch (DvtkHighLevelInterface.Common.Other.HliException) { } }
/// <summary> /// Adds (using deep copy) the <paramref name="sequenceItem"/> to all Sequence Attributes /// indicated by <paramref name="tagSequence"/>. /// </summary> /// <param name="tagSequence">The tag sequence.</param> /// <param name="sequenceItem">The Sequence Item to add.</param> public void AddItem(String tagSequence, SequenceItem sequenceItem) { TagSequence internalTagSequence = new TagSequence(tagSequence); if (!internalTagSequence.IsAttributeMatching) { throw new HliException("Tag sequence supplied invalid for this operation."); } AttributeCollection attributeCollection = GetAttributes(internalTagSequence); foreach (Attribute attribute in attributeCollection) { attribute.AddItem(sequenceItem); } }
/// <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> /// Insert a Sequence Item at a specified position. /// </summary> /// <param name="oneBasedIndex">The one based index.</param> /// <param name="item">The Sequence item to insert.</param> public override void InsertItem(int oneBasedIndex, SequenceItem item) { Thread.WriteWarningCurrentThread("Inserting a sequence item to non existing attribute \"" + TagSequenceString + "\". Doing nothing."); }
// // - 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) { Thread.WriteWarningCurrentThread("Adding a sequence item to non existing attribute \"" + TagSequenceString + "\". Doing nothing."); }
// // - 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) { Thread.WriteWarningCurrentThread("Adding a sequence item to non existing attribute \"" + TagSequenceString + "\". Doing nothing."); }
/// <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; }
// // - 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 abstract void AddItem(SequenceItem item);
/// <summary> /// Insert a Sequence Item at a specified position. /// </summary> /// <param name="oneBasedIndex">The one based index.</param> /// <param name="item">The Sequence item to insert.</param> public override void InsertItem(int oneBasedIndex, SequenceItem item) { Thread.WriteWarningCurrentThread("Inserting a sequence item to non existing attribute \"" + TagSequenceString + "\". Doing nothing."); }
/// <summary> /// Clear all attributes from this SequenceItem and clone all attributes /// from the supplied SequenceItem. /// </summary> /// <param name="sequenceItem">The SequenceItem to clone from.</param> public void CloneFrom(SequenceItem sequenceItem) { Clear(); for (int index = 0; index < sequenceItem.Count; index++) { // The Add method will take care of the deep copy. Add(sequenceItem[index]); } }
// // - Methods - // /// <summary> /// Clone this SequenceItem using deep copy. /// </summary> /// <returns>The cloned SequenceItem.</returns> public SequenceItem Clone() { SequenceItem cloneSequenceItem = new SequenceItem(); for (int index = 0; index < this.Count; index++) { // The Add method will take care of the deep copy. cloneSequenceItem.Add(this[index]); } return(cloneSequenceItem); }
/// <summary> /// Insert a Sequence Item at a specified position. /// </summary> /// <param name="oneBasedIndex">The one based index.</param> /// <param name="item">The Sequence item to insert.</param> public abstract void InsertItem(int oneBasedIndex, SequenceItem item);
// // - 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 abstract void AddItem(SequenceItem item);
// // - 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> /// Insert a Sequence Item at a specified position. /// </summary> /// <param name="oneBasedIndex">The one based index.</param> /// <param name="item">The Sequence item to insert.</param> public abstract void InsertItem(int oneBasedIndex, SequenceItem item);
/// <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> /// Obsolete class, use the classes in the namespace DvtkHighLevelInterface.Common.Compare instead. /// </summary> /// <param name="sequenceAttribute1">-</param> /// <param name="sequenceAttribute2">-</param> /// <param name="level">-</param> private void AddSequenceAttributesContentComparison(Attribute sequenceAttribute1, Attribute sequenceAttribute2, int level) { int maxItemCount = Math.Max(sequenceAttribute1.ItemCount, sequenceAttribute2.ItemCount); for (int itemIndex = 1; itemIndex <= maxItemCount; itemIndex++) { // // Get the two sequence items to compare. If one sequence item doesn't // exist for the itemIndex, use an empty sequence item. // SequenceItem sequenceItem1 = null; SequenceItem sequenceItem2 = null; bool sequenceItem1Present = true; bool sequenceItem2Present = true; if (itemIndex <= sequenceAttribute1.ItemCount) { sequenceItem1 = sequenceAttribute1.GetItem(itemIndex); sequenceItem1Present = true; } else { sequenceItem1 = new SequenceItem(); sequenceItem1Present = false; } if (itemIndex <= sequenceAttribute2.ItemCount) { sequenceItem2 = sequenceAttribute2.GetItem(itemIndex); sequenceItem2Present = true; } else { sequenceItem2 = new SequenceItem(); sequenceItem2Present = false; } // // Write the BEGIN ITEM row, compare the two sequence items and write the END ITEM row. // AddBeginOrEndSequenceItem(sequenceItem1Present, sequenceItem2Present, itemIndex, level + 1, true); AddAttributeSetsComparison(sequenceItem1, sequenceItem2, level + 1); AddBeginOrEndSequenceItem(sequenceItem1Present, sequenceItem2Present, itemIndex, level + 1, false); // // Update the differences count. // if ((!sequenceItem1Present) || (!sequenceItem2Present)) { this.differencesCount++; } } }