/// <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++;
}
}
}
