public void AssertTagValueChanged(uint tag, string valueToSet, string originalCharacterSet, string expectedNewCharacterSet) { DicomAttributeCollection dataset = new DicomAttributeCollection(); SetupDataSet(dataset, originalCharacterSet); DicomFile file = new DicomFile("test", CreateMetaInfo(), dataset); Assert.AreEqual(originalCharacterSet, file.DataSet[DicomTags.SpecificCharacterSet].ToString()); SetTagCommand cmd = new SetTagCommand(tag, valueToSet); Assert.AreEqual(cmd.CanSaveInUnicode, UnicodeAllowed, "SetTagCommand.CanSaveInUnicode returns an incorrect value"); Assert.IsTrue(cmd.Apply(file), "SetTagCommand.Apply failed"); var filename = string.Format("Test-{0}.dcm", DicomTagDictionary.GetDicomTag(tag).Name); Assert.IsTrue(file.Save(filename), "Unable to save dicom file"); file = new DicomFile(filename); file.Load(); if (valueToSet == null) { Assert.AreEqual(string.Empty, file.DataSet[tag].ToString()); } else { Assert.AreEqual(valueToSet, file.DataSet[tag].ToString()); } Assert.IsTrue(file.DataSet[DicomTags.SpecificCharacterSet].ToString().Equals(expectedNewCharacterSet)); Delete(filename); }
private static DicomTag GetTagFromAttributeNode(XmlNode attributeNode) { String tag = attributeNode.Attributes["Tag"].Value; DicomTag theTag; if (tag.StartsWith("$")) { theTag = DicomTagDictionary.GetDicomTag(tag.Substring(1)); } else { uint tagValue = uint.Parse(tag, NumberStyles.HexNumber); theTag = DicomTagDictionary.GetDicomTag(tagValue); DicomVr xmlVr = DicomVr.GetVR(attributeNode.Attributes["VR"].Value); if (theTag == null) { theTag = new DicomTag(tagValue, "Unknown tag", "UnknownTag", xmlVr, false, 1, uint.MaxValue, false); } if (!theTag.VR.Equals(xmlVr)) { theTag = new DicomTag(tagValue, theTag.Name, theTag.VariableName, xmlVr, theTag.MultiVR, theTag.VMLow, theTag.VMHigh, theTag.Retired); } } return(theTag); }
/// <summary> /// Routine for comparing two DICOMDIRs. The Root Directory REcord for the two dicomdirs should be passed in. /// </summary> /// <remarks> /// The routine will traverse through the directory records and ensure that each record matches. /// </remarks> /// <param name="sq1"></param> /// <param name="sq2"></param> /// <param name="failureReason"></param> /// <returns></returns> private static bool Compare(DirectoryRecordSequenceItem sq1, DirectoryRecordSequenceItem sq2, out string failureReason) { if ((sq1.NextDirectoryRecord == null && sq2.NextDirectoryRecord != null) || (sq2.NextDirectoryRecord == null && sq2.NextDirectoryRecord != null)) { failureReason = "NextDirectoryRecord exists for one record, but not for the other"; return(false); } if ((sq1.LowerLevelDirectoryRecord == null && sq2.LowerLevelDirectoryRecord != null) || (sq2.LowerLevelDirectoryRecord == null && sq2.LowerLevelDirectoryRecord != null)) { failureReason = "LowerLevelDirectoryRecord exists for one record, but not for the other"; return(false); } List <DicomAttributeComparisonResult> failures = new List <DicomAttributeComparisonResult>(); sq1.Equals(sq2, ref failures); if (failures.Count > 0) { bool foundTag = false; DicomTag lower = DicomTagDictionary.GetDicomTag(DicomTags.OffsetOfReferencedLowerLevelDirectoryEntity); DicomTag next = DicomTagDictionary.GetDicomTag(DicomTags.OffsetOfTheNextDirectoryRecord); failureReason = string.Empty; foreach (DicomAttributeComparisonResult result in failures) { if ((result.TagName == null) || (!result.TagName.Equals(lower.Name) && !result.TagName.Equals(next.Name))) { foundTag = true; failureReason = result.Details; } } if (foundTag) { return(false); } } if (sq1.LowerLevelDirectoryRecord != null) { if (!Compare(sq1.LowerLevelDirectoryRecord, sq2.LowerLevelDirectoryRecord, out failureReason)) { return(false); } } if (sq1.NextDirectoryRecord != null) { if (!Compare(sq1.NextDirectoryRecord, sq2.NextDirectoryRecord, out failureReason)) { return(false); } } failureReason = String.Empty; return(true); }
private static void ListTagsByParentSequence(IEnumerable <FunctionalGroupMacro> functionalGroups, bool excludeMultiItemSequences) { var tagFunctionalGroupMap = functionalGroups.SelectMany(f => f.NestedTags.Select(g => new { Tag = g, ParentTag = f.DefinedTags.Single(), FunctionalGroup = f })); if (excludeMultiItemSequences) { tagFunctionalGroupMap = tagFunctionalGroupMap.Where(t => !t.FunctionalGroup.CanHaveMultipleItems); } foreach (var groupResults in tagFunctionalGroupMap.GroupBy(f => f.Tag).OrderByDescending(t => t.Distinct((a, b) => a.ParentTag == b.ParentTag).Count())) { var subGrouped = groupResults.GroupBy(g => g.ParentTag).ToList(); if (subGrouped.Count() == 1 && excludeMultiItemSequences) { continue; } Console.WriteLine(DicomTagDictionary.GetDicomTag(groupResults.Key)); foreach (var pair in subGrouped) { const string format = "- {0} ({1})"; Console.WriteLine(format, DicomTagDictionary.GetDicomTag(pair.Key), string.Join(", ", pair.Select(g => g.FunctionalGroup.GetType().Name).ToArray())); } Console.WriteLine(); } }
protected static void Parse(string tagPath, out List <DicomTag> parentTags, out DicomTag tag) { Platform.CheckForNullReference(tagPath, "tagPath"); parentTags = null; tag = null; string[] tagPathComponents = tagPath.Split(','); if (tagPathComponents != null) { uint tagValue; if (tagPathComponents.Length > 1) { parentTags = new List <DicomTag>(); for (int i = 0; i < tagPathComponents.Length - 1; i++) { tagValue = uint.Parse(tagPathComponents[i], NumberStyles.HexNumber); DicomTag parent = DicomTagDictionary.GetDicomTag(tagValue); if (parent == null) { throw new Exception(String.Format("Specified tag {0} is not in the dictionary", parent)); } parentTags.Add(parent); } } tagValue = uint.Parse(tagPathComponents[tagPathComponents.Length - 1], NumberStyles.HexNumber); tag = DicomTagDictionary.GetDicomTag(tagValue); if (tag == null) { throw new Exception(String.Format("Specified tag {0} is not in the dictionary", tag)); } } }
public static DicomTagPath operator +(DicomTagPath left, uint right) { List <DicomTag> tags = new List <DicomTag>(left.TagsInPath); tags.Add(DicomTagDictionary.GetDicomTag(right)); return(new DicomTagPath(tags)); }
public ComparisionDifference(uint tag, string expected, string actual) { DicomTag = DicomTagDictionary.GetDicomTag(tag); Description = DicomTag.Name; ExpectValue = expected; RealValue = actual; }
private void ScanCollection(DicomAttributeCollection collection, string[] tagArray, int startIndex, List <DicomAttribute> attributeList) { if (startIndex >= tagArray.Length) { return; } DicomTag tag = DicomTagDictionary.GetDicomTag(tagArray[startIndex].Substring(1)); if (tag == null) { throw new NoSuchDicomTagException(tagArray[startIndex].Substring(1)); } DicomAttribute attrib; if (collection.TryGetAttribute(tag, out attrib)) { if (attrib.Tag.VR.Equals(DicomVr.SQvr)) { var sequences = attrib.Values as DicomSequenceItem[]; if (sequences != null) { foreach (var sq in sequences) { ScanCollection(sq, tagArray, startIndex + 1, attributeList); } } } else { attributeList.Add(attrib); } } }
static void InternalCompare(uint tag, string expected, string actual, int maxLength, ICollection <ComparisionDifference> list) { // reduce the strings if they exceed the max lengths if (maxLength > 0) { DicomTag dicomTag = null; if (!string.IsNullOrEmpty(expected) && expected.Length > maxLength) { dicomTag = DicomTagDictionary.GetDicomTag(tag); Platform.Log(LogLevel.Warn, string.Format("'{0}' exceeds max length allowed for {1}. Only first {2} characters are used for comparison", expected, dicomTag.Name, maxLength)); expected = expected.Substring(0, maxLength); } if (!string.IsNullOrEmpty(actual) && actual.Length > maxLength) { dicomTag = dicomTag ?? DicomTagDictionary.GetDicomTag(tag); Platform.Log(LogLevel.Warn, string.Format("'{0}' exceeds max length allowed for {1}. Only first {2} characters are used for comparison", actual, dicomTag.Name, maxLength)); actual = actual.Substring(0, maxLength); } } if (!StringUtils.AreEqual(expected, actual, StringComparison.InvariantCultureIgnoreCase)) { list.Add(new ComparisionDifference(tag, expected, actual)); } }
public DicomAttribute this[uint tag] { get { return(this[DicomTagDictionary.GetDicomTag(tag)]); } }
public override bool ReceiveMessageAsFileStream(DicomServer server, ServerAssociationParameters association, byte presentationId, DicomMessage message) { var sopClassUid = message.AffectedSopClassUid; if (sopClassUid.Equals(SopClass.BreastTomosynthesisImageStorageUid) || sopClassUid.Equals(SopClass.EnhancedCtImageStorageUid) || sopClassUid.Equals(SopClass.EnhancedMrColorImageStorageUid) || sopClassUid.Equals(SopClass.EnhancedMrImageStorageUid) || sopClassUid.Equals(SopClass.EnhancedPetImageStorageUid) || sopClassUid.Equals(SopClass.EnhancedUsVolumeStorageUid) || sopClassUid.Equals(SopClass.EnhancedXaImageStorageUid) || sopClassUid.Equals(SopClass.EnhancedXrfImageStorageUid) || sopClassUid.Equals(SopClass.UltrasoundMultiFrameImageStorageUid) || sopClassUid.Equals(SopClass.MultiFrameGrayscaleByteSecondaryCaptureImageStorageUid) || sopClassUid.Equals(SopClass.MultiFrameGrayscaleWordSecondaryCaptureImageStorageUid) || sopClassUid.Equals(SopClass.MultiFrameSingleBitSecondaryCaptureImageStorageUid) || sopClassUid.Equals(SopClass.MultiFrameTrueColorSecondaryCaptureImageStorageUid)) { server.DimseDatasetStopTag = DicomTagDictionary.GetDicomTag(DicomTags.ReconstructionIndex); // Random tag at the end of group 20 server.StreamMessage = true; return(true); } return(false); }
public ImageSetField this[uint tag] { get { DicomTag theTag = DicomTagDictionary.GetDicomTag(tag); return(this[theTag]); } }
public bool IsStoredTag(uint tag) { DicomTag dicomTag = DicomTagDictionary.GetDicomTag(tag); if (dicomTag == null) { return(false); } return(IsStoredTag(dicomTag)); }
public static ColumnDefinition GetColumnDefinition(uint dicomTag) { DicomTag tag = DicomTagDictionary.GetDicomTag(dicomTag); if (tag == null) { tag = new DicomTag(dicomTag, string.Empty, string.Empty, DicomVr.UNvr, false, uint.MinValue, uint.MaxValue, false); } return(GetColumnDefinition(tag)); }
private static DicomTag NewTag(uint tag) { DicomTag returnTag = DicomTagDictionary.GetDicomTag(tag); if (returnTag == null) { returnTag = new DicomTag(tag, "Unknown Tag", "UnknownTag", DicomVr.UNvr, false, 1, uint.MaxValue, false); } return(returnTag); }
private static string GetTagName(uint tag) { DicomTag dcmTag = DicomTagDictionary.GetDicomTag(tag); if (dcmTag != null) { return(dcmTag.ToString()); } return(String.Format("({0}) Unknown", tag.ToString("X8"))); }
public Expression CreateExpression(string text) { if (text.StartsWith("$")) { DicomTag tag = DicomTagDictionary.GetDicomTag(text.Substring(1)); if (tag == null) { throw new XmlSpecificationCompilerException("Invalid DICOM tag: " + text); } } return(new DicomExpression(text)); }
public bool TryGetAttribute(uint tag, out DicomAttribute attribute) { attribute = DicomTagDictionary.GetDicomTag(tag).CreateDicomAttribute(); switch (tag) { case DicomTags.ModalitiesInStudy: attribute.Values = study.ModalitiesInStudy; return(true); case DicomTags.StudyDescription: attribute.SetStringValue(study.StudyDescription); return(true); case DicomTags.AccessionNumber: attribute.SetStringValue(study.AccessionNumber); return(true); case DicomTags.NumberOfStudyRelatedInstances: attribute.SetInt32(0, study.NumberOfStudyRelatedInstances); return(true); case DicomTags.NumberOfStudyRelatedSeries: attribute.SetInt32(0, study.NumberOfStudyRelatedSeries); return(true); case DicomTags.PatientsAge: attribute.SetStringValue(study.PatientsAge); return(true); case DicomTags.ReferringPhysiciansName: attribute.SetStringValue(study.ReferringPhysiciansName); return(true); case DicomTags.SopClassesInStudy: attribute.Values = study.SopClassesInStudy; return(true); case DicomTags.StudyId: attribute.SetStringValue(study.StudyId); return(true); case DicomTags.StudyDate: attribute.SetStringValue(study.StudyDate); return(true); case DicomTags.StudyTime: attribute.SetStringValue(study.StudyTime); return(true); default: return(false); } }
public void TestTagMappingBySopClass() { foreach (var uid in _multiframeSopClassUids) { var sopClass = SopClass.GetSopClass(uid).Name; var functionalGroups = FunctionalGroupDescriptor.GetApplicableFunctionalGroups(uid).ToList(); var tagGroups = functionalGroups.Select(f => f.Create()) .SelectMany(f => f.NestedTags.Select(t => new { TagValue = t, FunctionalGroup = f })) .GroupBy(u => u.TagValue).OrderBy(u => u.Key).ToList(); foreach (var group in tagGroups) { var dcmTag = DicomTagDictionary.GetDicomTag(group.Key); // asserts that any tag defined in 'singleton' functional groups (those whose sequence can have at most 1 item) should have at least some mapping var fgType = FunctionalGroupDescriptor.GetFunctionalGroupByTag(uid, group.Key); if (fgType == null) { foreach (var entry in group) { Assert.IsTrue(entry.FunctionalGroup.CanHaveMultipleItems, "At least one singleton functional group defines tag {0} for SOP class {1}", dcmTag, sopClass); } } // explicitly assert the mapping for any tag defined by multiple 'singleton' functional groups - so that if new tags are introduced later, we would explicitly consider what is the correct mapping if (group.Count(g => !g.FunctionalGroup.CanHaveMultipleItems) > 1) { const string wrongMapMsg = "SOP Class {0} maps tag {1} to the wrong functional group"; if (uid == SopClass.EnhancedXaImageStorageUid) { switch (group.Key) { case DicomTags.TableHorizontalRotationAngle: case DicomTags.TableHeadTiltAngle: case DicomTags.TableCradleTiltAngle: Assert.AreEqual(new FunctionalGroupDescriptor(typeof(XRayTablePositionFunctionalGroup)), fgType, wrongMapMsg, sopClass, dcmTag); break; default: Assert.Fail("SOP Class {0} shouldn't have an ambiguous mapping for tag {1} - if new tags were added, please explicitly update the expected mapping in this unit test", sopClass, dcmTag); break; } } else { Assert.Fail("SOP Class {0} shouldn't have any ambiguous mappings - if new tags were added, please explicitly update the expected mapping in this unit test", sopClass); } } } } }
/// <summary> /// Creates an in-memory DICOM image /// </summary> /// <returns></returns> private static DicomFile CreateDicomImage(int rows = 20, int columns = 30, bool bitsAllocated16 = true, bool signed = false, int numberOfFrames = 1, Endian endian = Endian.Little, bool useOB = false) { var sopClassUid = bitsAllocated16 ? SopClass.MultiFrameGrayscaleWordSecondaryCaptureImageStorageUid : SopClass.MultiFrameGrayscaleByteSecondaryCaptureImageStorageUid; var sopInstanceUid = DicomUid.GenerateUid().UID; var dcf = new DicomFile(); dcf.MediaStorageSopClassUid = sopClassUid; dcf.MediaStorageSopInstanceUid = sopInstanceUid; dcf.TransferSyntax = endian == Endian.Little ? TransferSyntax.ExplicitVrLittleEndian : TransferSyntax.ExplicitVrBigEndian; dcf.DataSet[DicomTags.PatientId].SetStringValue("TEST"); dcf.DataSet[DicomTags.PatientsName].SetStringValue("TEST"); dcf.DataSet[DicomTags.StudyInstanceUid].SetStringValue(DicomUid.GenerateUid().UID); dcf.DataSet[DicomTags.StudyId].SetStringValue("TEST"); dcf.DataSet[DicomTags.StudyDescription].SetStringValue("TEST"); dcf.DataSet[DicomTags.SeriesInstanceUid].SetStringValue(DicomUid.GenerateUid().UID); dcf.DataSet[DicomTags.SeriesNumber].SetInt32(0, 1); dcf.DataSet[DicomTags.SeriesDescription].SetStringValue("TEST"); dcf.DataSet[DicomTags.SopClassUid].SetStringValue(sopClassUid); dcf.DataSet[DicomTags.SopInstanceUid].SetStringValue(sopInstanceUid); dcf.DataSet[DicomTags.InstanceNumber].SetInt32(0, 1); var frameSize = rows * columns * (bitsAllocated16 ? 2 : 1); var data = new byte[numberOfFrames * frameSize]; for (var n = 0; n < numberOfFrames; ++n) { var value = (byte)(0xFF & (n + 0x80)); for (var k = 0; k < frameSize; ++k) { data[n * frameSize + k] = value; } } var pixelDataTag = DicomTagDictionary.GetDicomTag(DicomTags.PixelData); pixelDataTag = new DicomTag(pixelDataTag.TagValue, pixelDataTag.Name, pixelDataTag.VariableName, useOB ? DicomVr.OBvr : DicomVr.OWvr, pixelDataTag.MultiVR, pixelDataTag.VMLow, pixelDataTag.VMHigh, pixelDataTag.Retired); dcf.DataSet[DicomTags.PhotometricInterpretation].SetStringValue(PhotometricInterpretation.Monochrome2.Code); dcf.DataSet[DicomTags.SamplesPerPixel].SetInt32(0, 1); dcf.DataSet[DicomTags.PixelRepresentation].SetInt32(0, signed ? 1 : 0); dcf.DataSet[DicomTags.BitsAllocated].SetInt32(0, bitsAllocated16 ? 16 : 8); dcf.DataSet[DicomTags.BitsStored].SetInt32(0, bitsAllocated16 ? 16 : 8); dcf.DataSet[DicomTags.HighBit].SetInt32(0, bitsAllocated16 ? 15 : 7); dcf.DataSet[DicomTags.Rows].SetInt32(0, rows); dcf.DataSet[DicomTags.Columns].SetInt32(0, columns); dcf.DataSet[DicomTags.NumberOfFrames].SetInt32(0, numberOfFrames); dcf.DataSet[pixelDataTag].Values = data; return(dcf); }
public void ConvertAttributeToUN(DicomAttributeCollection theSet, uint tag) { ByteBuffer theData = theSet[tag].GetByteBuffer(TransferSyntax.ImplicitVrLittleEndian, theSet.SpecificCharacterSet); DicomTag baseTag = DicomTagDictionary.GetDicomTag(tag); DicomTag theTag = new DicomTag(tag, baseTag.Name, baseTag.VariableName, DicomVr.UNvr, baseTag.MultiVR, baseTag.VMLow, baseTag.VMHigh, baseTag.Retired); DicomAttribute unAttrib = DicomVr.UNvr.CreateDicomAttribute(theTag, theData); theSet[tag] = unAttrib; }
static void AddDicomLength(uint tag) { DicomTag dTag = DicomTagDictionary.GetDicomTag(tag); // For PN VR tags, we're only storing 64 bit lengths, whereas the max length is 64. if (dTag.VR.Equals(DicomVr.PNvr)) { _maxLengths.Add(tag, 64); } else { _maxLengths.Add(tag, dTag.VR.MaximumLength); } }
/// <summary> /// Fixes the VR of the specified DICOM tag, which is especially important for multi-VR tags. /// </summary> private static DicomTag FixVR(uint tag, DicomVr newVR) { var dicomTag = DicomTagDictionary.GetDicomTag(tag); if (dicomTag.VR == newVR) { return(dicomTag); } if (!dicomTag.MultiVR) { throw new ArgumentException("The specified DICOM tag does not support multiple VRs.", "tag"); } return(new DicomTag(dicomTag.TagValue, dicomTag.Name, dicomTag.VariableName, newVR, true, dicomTag.VMLow, dicomTag.VMHigh, dicomTag.Retired)); }
private void PopulateField(uint tag, IDicomAttributeProvider attributeProvider) { DicomAttribute attr; if (attributeProvider.TryGetAttribute(tag, out attr)) { AddField(new ImageSetField(attr)); } else { // add default value AddField(new ImageSetField(DicomTagDictionary.GetDicomTag(tag).CreateDicomAttribute())); } }
public AddOriginalAttributes() { UpdateEntry = new ImageLevelUpdateEntry() { TagPath = new DicomTagPath() { Tag = DicomTagDictionary.GetDicomTag(DicomTags.OriginalAttributesSequence) }, Value = "N/A", OriginalValue = "N/A" }; }
private static DicomTag LookupDicomTag(string tag) { uint tagValue; if (uint.TryParse(tag, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out tagValue)) { // very simple support for private tags, since the toolkit won't try to read it anyway if (DicomTag.IsPrivateGroup((ushort)(0x00FFFF & (tagValue >> 16)))) { return(new DicomTag(tagValue, "Private Tag", "PrivateTag", DicomVr.UNvr, false, 1, uint.MaxValue, false)); } return(DicomTagDictionary.GetDicomTag(tagValue)); } return(DicomTagDictionary.GetDicomTag(tag)); }
/// <summary> /// Ensures the offset of the data set in the source stream is determined. /// </summary> internal void ParseMetaInfo() { if (MetaInfoFileLength != 0) { return; } var theFile = new DicomFile(); const uint stopTag = DicomTags.RelatedGeneralSopClassUid; theFile.Load(StreamOpener, DicomTagDictionary.GetDicomTag(stopTag), DicomReadOptions.Default); MetaInfoFileLength = theFile.MetaInfoFileLength; }
public Expression CreateExpression(string text) { if (text.StartsWith("$")) { var tagArray = text.Split(new[] { '/' }); foreach (var t in tagArray) { DicomTag tag = DicomTagDictionary.GetDicomTag(t.Substring(1)); if (tag == null) { throw new XmlSpecificationCompilerException("Invalid DICOM tag: " + t); } } } return(new DicomExpression(text)); }
internal static DicomTag NewTag(uint tag, DicomVr vr) { var theTag = DicomTagDictionary.GetDicomTag(tag); if (theTag == null) { theTag = new DicomTag(tag, "Unknown tag", "UnknownTag", vr ?? DicomVr.UNvr, false, 1, uint.MaxValue, false); } else if (vr != null && !theTag.VR.Equals(vr)) { theTag = new DicomTag(tag, theTag.Name, theTag.VariableName, vr, theTag.MultiVR, theTag.VMLow, theTag.VMHigh, theTag.Retired); } return(theTag); }
protected DicomTagColumn(DicomTag dicomTag) { _tag = dicomTag.TagValue; _vr = dicomTag.VR.Name; uint tagGroup = (_tag >> 16) & 0x0000FFFF; uint tagElement = _tag & 0x0000FFFF; if (DicomTagDictionary.GetDicomTag(dicomTag.TagValue) == null) { _tagName = string.Format(SR.FormatUnknownDicomTag, tagGroup, tagElement); } else { _tagName = string.Format(SR.FormatDicomTag, tagGroup, tagElement, dicomTag.Name); } }