/// <summary>
/// Create both a Content Item instance and all its direct and indirect child Content Item instances.
/// </summary>
/// <param name="attributeSet">
/// <param name="dataSet">
/// The AttributeSet instance containing the DICOM attributes to construct this Content
/// Item instance and its direct and indirect child Content Item instances with.
/// </param>
/// </param>
/// <param name="parentContentItem">
/// The parent Content Item instance.
/// If no parent exists, supply null.
/// </param>
/// <param name="position">
/// The ordinal position of the associated Sequence Item in it's contained Content Sequence.
/// Item.
/// </param>
/// <returns>A Content Item instance.</returns>
private static ContentItem CreateContentItems(AttributeSet attributeSet, ContentItem parentContentItem, uint position)
{
//
// Create the single Content Item instance using the Attribute Set instance supplied.
//
ContentItem contentItem = CreateContentItem(attributeSet, parentContentItem, position);
//
// If existing, create its child Content Item instances.
//
DvtkHighLevelInterface.Dicom.Other.Attribute attribute = attributeSet["0x0040A730"]; // Content Sequence Attribute.
if (attribute.Exists)
{
if (attribute.VR == VR.SQ)
{
for (uint sequenceItemIndex = 1; sequenceItemIndex <= attribute.ItemCount; sequenceItemIndex++)
{
SequenceItem sequenceItem = attribute.GetItem(System.Convert.ToInt32(sequenceItemIndex));
ContentItem childContentItem = CreateContentItems(sequenceItem, contentItem, sequenceItemIndex);
contentItem.childContentItems.Add(childContentItem);
}
}
}
return(contentItem);
}
/// <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);
}
internal virtual void Set <T>(TagSequence tagSequence, VR vR, T genericsParameter)
{
AttributeSet currentAttributeSetInLoop = this;
for (int index = 0; index < tagSequence.Tags.Count; index++)
{
Tag tag = tagSequence[index];
if (index < tagSequence.Tags.Count - 1)
// If this is not the last tag from the TagSequence...
{
Attribute attribute = currentAttributeSetInLoop.SetSequenceAttribute(tag);
currentAttributeSetInLoop = attribute.GetItem(tag.IndexNumber);
}
else
// If this is the last tag from the TagSequence...
{
Attribute attribute = currentAttributeSetInLoop.GetAttribute(tag.AsUInt32);
if (attribute is ValidAttribute)
{
attribute.Delete();
}
attribute = currentAttributeSetInLoop.Create(tag.AsUInt32, vR);
// The type of genericsParameter (generics type) is determined run-time.
// Maybe this is the reason for a direct call to attribute.Values.Add
// (has a overloaded method with params parameter) with the argument
// genericsParameter not to work. Needed to explicitly cast to a specfic type
// before calling the Add method.
if (genericsParameter is Values)
{
Values values = genericsParameter as Values;
attribute.Values.Add(values);
}
else if (genericsParameter is Byte[])
{
Byte[] value = genericsParameter as Byte[];
attribute.Values.Set(value);
}
else if (genericsParameter is Object[])
{
Object[] values = genericsParameter as Object[];
attribute.Values.Add(values);
}
else
{
throw new HliException("Not supposed to get here.");
}
}
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="sequenceItem">
/// The SequenceItem instance containing the DICOM attributes to construct this instance with.
/// </param>
/// <param name="parentContentItem">The parent Content Item.</param>
/// <param name="position">The ordinal position of the associated Sequence Item in it's contained Content Sequence Item.</param>
public ContentItemWithValueTypeNum(AttributeSet attributeSet, ContentItem parentContentItem, uint position) :
base(attributeSet, parentContentItem, position)
{
DvtkHighLevelInterface.Dicom.Other.Attribute attribute = attributeSet["0x0040A300"];
if (attribute.Exists)
{
if (attribute.VR == VR.SQ)
{
if (attribute.ItemCount > 0)
{
this.measuredValue = new MeasuredValue(attribute.GetItem(1));
}
}
}
this.numericValueQualifier = ConceptCode.CreateConceptCode(attributeSet, "0x0040A301", numericValueQualifierContext);
}
//
// - Methods -
//
/// <summary>
/// Create a ConceptCode instance, if the specified Sequence Attribute is present in the
/// supplied Attribute Set and the Sequence Attribute contains at least one Sequence Item.
/// </summary>
/// <param name="attributeSet">
/// The Attribute Set in which the Sequence Attribute may be present.
/// </param>
/// <param name="tag">The Tag of the Sequence Attribute.</param>
/// <returns>
/// The created ConceptCode instance if the first Sequence Item exists.
/// Null otherwise.
/// </returns>
internal static ConceptCode CreateConceptCode(AttributeSet attributeSet, String tag, string context)
{
ConceptCode conceptCode = null;
DvtkHighLevelInterface.Dicom.Other.Attribute attribute = attributeSet[tag];
if (attribute.Exists)
{
if (attribute.VR == VR.SQ)
{
if (attribute.ItemCount > 0)
{
conceptCode = new ConceptCode(attribute.GetItem(1), context);
}
}
}
return(conceptCode);
}
/// <summary>
/// Make attributes in this AttributeSet ascending (Dicom compliant).
/// </summary>
/// <param name="recursive">
/// When this is true, all attributes are made ascending resursively,
/// i.e. all contained sequence items are also sorted.
/// </param>
public void MakeAscending(bool recursive)
{
this.dvtkDataAttributeSet.MakeAscending();
if (recursive)
{
for (int index = 0; index < Count; index++)
{
Attribute attribute = this[index];
if (attribute.VR == VR.SQ)
{
for (int sequenceItemIndex = 1; sequenceItemIndex <= attribute.ItemCount; sequenceItemIndex++)
{
attribute.GetItem(sequenceItemIndex).MakeAscending(true);
}
}
}
}
}
/// <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++;
}
}
}
private void AddSequenceAttributesContentInformation(DicomAttributesToValidate dicomAttributesToValidate, int oneBasedLevel)
{
//
// Determine the maximum amount of sequence items for all supplied sequence attributes.
//
int maxItemCount = dicomAttributesToValidate.MaxItemCount;
//
// Fill the table with the information.
//
for (int itemIndex = 1; itemIndex <= maxItemCount; itemIndex++)
{
//
// Add begin item row.
//
NewRow();
AddCommonInformationForBeginOrEndSequenceItems(oneBasedLevel, true, itemIndex);
for (int attributeIndex = 0; attributeIndex < dicomAttributesToValidate.Count; attributeIndex++)
{
AddAttributeInformationForBeginOrEndSequenceItem(dicomAttributesToValidate, attributeIndex, itemIndex, true);
}
//
// Add the comparison of attributes within the sequence items.
//
ArrayList sequenceItemsToCompare = new ArrayList();
ArrayList compareFlagsForSequenceItems = new ArrayList();
ArrayList dicomAttributeFlagsForSequenceItems = new ArrayList();
ArrayList displaySequenceItems = new ArrayList();
for (int attributeSetsIndex = 0; attributeSetsIndex < dicomAttributesToValidate.Count; attributeSetsIndex++)
{
DicomAttributeToValidate dicomAttributeToValidate = dicomAttributesToValidate[attributeSetsIndex] as DicomAttributeToValidate;
Attribute attribute = dicomAttributeToValidate.Attribute;
if (attribute is ValidAttribute)
{
if (attribute.VR == VR.SQ)
{
if ((dicomAttributeToValidate.ValidationRuleDicomAttribute.DicomAttributeFlags & DicomAttributeFlags.Include_sequence_items) == DicomAttributeFlags.Include_sequence_items)
{
if (attribute.ItemCount < itemIndex)
{
// Add empty sequence item.
sequenceItemsToCompare.Add(new SequenceItem());
}
else
{
sequenceItemsToCompare.Add(attribute.GetItem(itemIndex));
}
}
else
{
// Add empty sequence item.
sequenceItemsToCompare.Add(new SequenceItem());
}
}
else
{
// Add empty sequence item.
sequenceItemsToCompare.Add(new SequenceItem());
}
}
else
{
// Add empty sequence item.
sequenceItemsToCompare.Add(new SequenceItem());
}
compareFlagsForSequenceItems.Add(dicomAttributeToValidate.ValidationRuleDicomAttribute.CompareFlags);
dicomAttributeFlagsForSequenceItems.Add(dicomAttributeToValidate.ValidationRuleDicomAttribute.DicomAttributeFlags & DicomAttributeFlags.Include_sequence_items);
if (dicomAttributeToValidate.Display)
{
displaySequenceItems.Add(true);
}
else
{
displaySequenceItems.Add(false);
}
}
AddAttributeSetsInformationUsingStaticCompare(sequenceItemsToCompare, compareFlagsForSequenceItems, dicomAttributeFlagsForSequenceItems, displaySequenceItems);
//
// Add end item row.
//
NewRow();
AddCommonInformationForBeginOrEndSequenceItems(oneBasedLevel, false, itemIndex);
for (int attributeIndex = 0; attributeIndex < dicomAttributesToValidate.Count; attributeIndex++)
{
AddAttributeInformationForBeginOrEndSequenceItem(dicomAttributesToValidate, attributeIndex, itemIndex, false);
}
}
}
/// <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++;
}
}
}