public void Test_DodgyTagNames()
{
_helper.TruncateTablesIfExists();
DirectoryInfo d = new DirectoryInfo(Path.Combine(TestContext.CurrentContext.TestDirectory, nameof(Test_DodgyTagNames)));
d.Create();
var fi = TestData.Create(new FileInfo(Path.Combine(d.FullName, "MyTestFile.dcm")));
var fi2 = TestData.Create(new FileInfo(Path.Combine(d.FullName, "MyTestFile2.dcm")));
DicomFile dcm;
using (var stream = File.OpenRead(fi.FullName))
{
dcm = DicomFile.Open(stream);
dcm.Dataset.AddOrUpdate(DicomTag.PrintRETIRED, "FISH");
dcm.Dataset.AddOrUpdate(DicomTag.Date, new DateTime(2001, 01, 01));
dcm.Save(fi2.FullName);
}
var adder = new TagColumnAdder(DicomTypeTranslaterReader.GetColumnNameForTag(DicomTag.Date, false), "datetime2", _helper.ImageTableInfo, new AcceptAllCheckNotifier());
adder.Execute();
adder = new TagColumnAdder(DicomTypeTranslaterReader.GetColumnNameForTag(DicomTag.PrintRETIRED, false), "datetime2", _helper.ImageTableInfo, new AcceptAllCheckNotifier());
adder.Execute();
fi.Delete();
File.Move(fi2.FullName, fi.FullName);
//creates the queues, exchanges and bindings
var tester = new MicroserviceTester(_globals.RabbitOptions, _globals.DicomRelationalMapperOptions);
tester.CreateExchange(_globals.RabbitOptions.FatalLoggingExchange, null);
using (var host = new DicomRelationalMapperHost(_globals))
{
host.Start();
using (var timeline = new TestTimeline(tester))
{
timeline.SendMessage(_globals.DicomRelationalMapperOptions, _helper.GetDicomFileMessage(_globals.FileSystemOptions.FileSystemRoot, fi));
//start the timeline
timeline.StartTimeline();
Thread.Sleep(TimeSpan.FromSeconds(10));
new TestTimelineAwaiter().Await(() => host.Consumer.AckCount >= 1, null, 30000, () => host.Consumer.DleErrors);
Assert.AreEqual(1, _helper.SeriesTable.GetRowCount(), "SeriesTable did not have the expected number of rows in LIVE");
Assert.AreEqual(1, _helper.StudyTable.GetRowCount(), "StudyTable did not have the expected number of rows in LIVE");
Assert.AreEqual(1, _helper.ImageTable.GetRowCount(), "ImageTable did not have the expected number of rows in LIVE");
host.Stop("Test end");
}
}
tester.Shutdown();
}
public void BsonRoundTrip_BlacklistedVrs_ConvertedCorrectly()
{
var ds = new DicomDataset
{
new DicomOtherByte(DicomTag.SelectorOBValue, byte.MinValue),
new DicomOtherWord(DicomTag.SelectorOWValue, byte.MinValue),
new DicomUnknown(DicomTag.SelectorUNValue, byte.MinValue)
};
// Ensure this test fails if we update the blacklist later
Assert.True(
ds.Select(x => x.ValueRepresentation).All(DicomTypeTranslater.DicomVrBlacklist.Contains) &&
ds.Count() == DicomTypeTranslater.DicomVrBlacklist.Length);
BsonDocument doc = DicomTypeTranslaterReader.BuildBsonDocument(ds);
Assert.NotNull(doc);
Assert.True(doc.All(x => x.Value.IsBsonNull));
DicomDataset recoDs = DicomTypeTranslaterWriter.BuildDicomDataset(doc);
Assert.AreEqual(3, recoDs.Count());
foreach (DicomItem item in recoDs)
{
Assert.Zero(((DicomElement)item).Count);
}
}
public void TestPatientAgeTag()
{
string filename = Path.Combine(TestContext.CurrentContext.TestDirectory, "test.dcm");
var dataset = new DicomDataset();
dataset.Add(DicomTag.SOPInstanceUID, "123.123.123");
dataset.Add(DicomTag.SOPClassUID, "123.123.123");
dataset.Add(new DicomAgeString(DicomTag.PatientAge, "009Y"));
var cSharpValue = DicomTypeTranslaterReader.GetCSharpValue(dataset, DicomTag.PatientAge);
Assert.AreEqual("009Y", cSharpValue);
var file = new DicomFile(dataset);
file.Save(filename);
var source = new DicomFileCollectionSource();
source.FilenameField = "Path";
source.PreInitialize(new ExplicitListDicomFileWorklist(new[] { filename }), new ThrowImmediatelyDataLoadEventListener());
var chunk = source.GetChunk(new ThrowImmediatelyDataLoadEventListener(), new GracefulCancellationToken());
Assert.AreEqual("009Y", chunk.Rows[0]["PatientAge"]);
}
public void BsonRoundTrip_TagWithMultipleVrs_SameAfterConversion()
{
DicomTypeTranslater.SerializeBinaryData = true;
var usItem = new DicomUnsignedShort(DicomTag.GrayLookupTableDataRETIRED, 0, 1, ushort.MaxValue);
var owItem = new DicomOtherWord(DicomTag.GrayLookupTableDataRETIRED, 0, 1, ushort.MaxValue);
Assert.True(usItem.Tag.DictionaryEntry.ValueRepresentations.Length == 3);
Assert.True(owItem.Tag.DictionaryEntry.ValueRepresentations.Length == 3);
var usDataset = new DicomDataset {
usItem
};
var owDataset = new DicomDataset {
owItem
};
BsonDocument usDocument = DicomTypeTranslaterReader.BuildBsonDocument(usDataset);
BsonDocument owDocument = DicomTypeTranslaterReader.BuildBsonDocument(owDataset);
Assert.NotNull(usDocument);
Assert.NotNull(owDocument);
DicomDataset recoUsDataset = DicomTypeTranslaterWriter.BuildDicomDataset(usDocument);
DicomDataset recoOwDataset = DicomTypeTranslaterWriter.BuildDicomDataset(owDocument);
Assert.True(DicomDatasetHelpers.ValueEquals(usDataset, recoUsDataset));
Assert.True(DicomDatasetHelpers.ValueEquals(owDataset, recoOwDataset));
}
public void Test_Sequence()
{
var subDatasets = new List <DicomDataset>
{
new DicomDataset
{
new DicomShortString(DicomTag.CodeValue, "CPELVD")
}
};
var dicomDataset = new DicomDataset
{
{ DicomTag.ProcedureCodeSequence, subDatasets.ToArray() }
};
object result = DicomTypeTranslaterReader.GetCSharpValue(dicomDataset, DicomTag.ProcedureCodeSequence);
object flat = DicomTypeTranslater.Flatten(result);
Console.WriteLine(flat);
StringAssert.Contains("CPELVD", (string)flat);
StringAssert.Contains("(0008,0100)", (string)flat);
}
private void Validate(SeriesMessage message, BsonDocument document)
{
Assert.False(message == null || document == null);
BsonElement element;
Assert.True(document.TryGetElement("header", out element));
var docHeader = (BsonDocument)element.Value;
Assert.AreEqual(_seriesMessageProps.Count - 3, docHeader.ElementCount);
Assert.AreEqual(message.DirectoryPath, docHeader["DirectoryPath"].AsString);
Assert.AreEqual(message.NationalPACSAccessionNumber, docHeader["NationalPACSAccessionNumber"].AsString);
Assert.AreEqual(message.ImagesInSeries, docHeader["ImagesInSeries"].AsInt32);
DicomDataset dataset = DicomTypeTranslater.DeserializeJsonToDataset(message.DicomDataset);
Assert.NotNull(dataset);
BsonDocument datasetDocument = DicomTypeTranslaterReader.BuildBsonDocument(dataset);
document.Remove("_id");
document.Remove("header");
Assert.AreEqual(datasetDocument, document);
}
public void TestSequenceConversion()
{
var subDataset = new DicomDataset
{
new DicomShortString(DicomTag.SpecimenShortDescription, "short desc"),
new DicomAgeString(DicomTag.PatientAge, "99Y")
};
var ds = new DicomDataset
{
new DicomSequence(DicomTag.ReferencedImageSequence, subDataset)
};
object obj = DicomTypeTranslaterReader.GetCSharpValue(ds, ds.GetDicomItem <DicomItem>(DicomTag.ReferencedImageSequence));
var asArray = obj as Dictionary <DicomTag, object>[];
Assert.NotNull(asArray);
Assert.AreEqual(1, asArray.Length);
Assert.AreEqual(2, asArray[0].Count);
Assert.AreEqual("short desc", asArray[0][DicomTag.SpecimenShortDescription]);
Assert.AreEqual("99Y", asArray[0][DicomTag.PatientAge]);
}
public void TestMultipleElementSequences()
{
var subDatasets = new List <DicomDataset>();
for (var i = 0; i < 3; i++)
{
subDatasets.Add(new DicomDataset
{
{ DicomTag.ReferencedSOPClassUID, "ReferencedSOPClassUID-" + (i + 1) },
{ DicomTag.ReferencedSOPInstanceUID, "ReferencedSOPInstanceUID-" + (i + 1) }
});
}
var originalDataset = new DicomDataset
{
{ DicomTag.ReferencedImageSequence, subDatasets.ToArray() }
};
var translatedDataset = new Dictionary <DicomTag, object>();
foreach (DicomItem item in originalDataset)
{
object value = DicomTypeTranslaterReader.GetCSharpValue(originalDataset, item);
translatedDataset.Add(item.Tag, value);
}
var reconstructedDataset = new DicomDataset();
foreach (KeyValuePair <DicomTag, object> item in translatedDataset)
{
DicomTypeTranslaterWriter.SetDicomTag(reconstructedDataset, item.Key, item.Value);
}
Assert.True(DicomDatasetHelpers.ValueEquals(originalDataset, reconstructedDataset));
}
public SequenceElement[] GetSubsets(DicomDataset dataset)
{
if (!dataset.Contains(_tag))
{
return(new SequenceElement[0]);
}
return(ToSequenceElementArray((Dictionary <DicomTag, object>[])DicomTypeTranslaterReader.GetCSharpValue(dataset, _tag), null));
}
private static void VerifyBsonTripleTrip(DicomDataset ds)
{
BsonDocument bsonDoc = DicomTypeTranslaterReader.BuildBsonDocument(ds);
DicomDataset recoDataset = DicomTypeTranslaterWriter.BuildDicomDataset(bsonDoc);
BsonDocument recoDoc = DicomTypeTranslaterReader.BuildBsonDocument(recoDataset);
Assert.AreEqual(bsonDoc, recoDoc);
Assert.True(DicomDatasetHelpers.ValueEquals(ds, recoDataset));
}
public void TestGetCSharpValueThrowsException()
{
var ds = new DicomDataset
{
new DicomDecimalString(DicomTag.SelectorDSValue, "aaahhhhh")
};
Assert.Throws <FormatException>(() => DicomTypeTranslaterReader.GetCSharpValue(ds, DicomTag.SelectorDSValue));
}
public void TestBasicCSharpTranslation()
{
DicomDataset ds = TranslationTestHelpers.BuildVrDataset();
foreach (DicomItem item in ds)
{
Assert.NotNull(DicomTypeTranslaterReader.GetCSharpValue(ds, item));
}
}
public void DicomToBson_GroupLengthElements_AreIgnored()
{
var ds = new DicomDataset
{
new DicomCodeString(new DicomTag(123, 0), "abc")
};
Assert.IsEmpty(DicomTypeTranslaterReader.BuildBsonDocument(ds));
}
public void WorkedExampleTest()
{
//pick some tags that we are interested in (determines the table schema created)
var toCreate = new ImageTableTemplate()
{
Columns = new[] {
new ImageColumnTemplate(DicomTag.SOPInstanceUID),
new ImageColumnTemplate(DicomTag.Modality)
{
AllowNulls = true
},
new ImageColumnTemplate(DicomTag.PatientID)
{
AllowNulls = true
}
}
};
//load the Sql Server implementation of FAnsi
ImplementationManager.Load <MicrosoftSQLImplementation>();
//decide where you want to create the table
var server = new DiscoveredServer(@"Server=localhost\sqlexpress;Database=mydb;Integrated Security=true;", FAnsi.DatabaseType.MicrosoftSQLServer);
var db = server.ExpectDatabase("test");
//create the table
var tbl = db.CreateTable("MyCoolTable", toCreate.GetColumns(FAnsi.DatabaseType.MicrosoftSQLServer));
//add a column for where the image is on disk
tbl.AddColumn("FileLocation", new DatabaseTypeRequest(typeof(string), 500), true, 500);
//Create a DataTable in memory for the data we read from disk
DataTable dt = new DataTable();
dt.Columns.Add("SOPInstanceUID");
dt.Columns.Add("Modality");
dt.Columns.Add("PatientID");
dt.Columns.Add("FileLocation");
//Load some dicom files and copy tag data into DataTable (where tag exists)
foreach (string file in Directory.EnumerateFiles(@"C:\temp\TestDicomFiles", "*.dcm", SearchOption.AllDirectories))
{
var dcm = DicomFile.Open(file);
var ds = dcm.Dataset;
dt.Rows.Add(
DicomTypeTranslaterReader.GetCSharpValue(dcm.Dataset, DicomTag.SOPInstanceUID),
ds.Contains(DicomTag.Modality) ? DicomTypeTranslaterReader.GetCSharpValue(dcm.Dataset, DicomTag.Modality) : DBNull.Value,
ds.Contains(DicomTag.PatientID) ? DicomTypeTranslaterReader.GetCSharpValue(dcm.Dataset, DicomTag.PatientID) : DBNull.Value,
file);
}
//put the DataTable into the database
using (var insert = tbl.BeginBulkInsert())
insert.Upload(dt);
}
public void TestPatientAgeTag()
{
var dataset = new DicomDataset();
dataset.Add(new DicomAgeString(DicomTag.PatientAge, "009Y"));
var cSharpValue = DicomTypeTranslaterReader.GetCSharpValue(dataset, DicomTag.PatientAge);
Assert.AreEqual("009Y", cSharpValue);
}
private void WriteHeaders(CsvWriter writer)
{
foreach (var t in _tagsToWrite)
{
var colName = DicomTypeTranslaterReader.GetColumnNameForTag(t, false);
writer.WriteField(colName);
}
writer.NextRecord();
}
private void WriteValue(CsvWriter writer, DicomCFindResponse response, DicomTag tag)
{
var val = DicomTypeTranslaterReader.GetCSharpValue(response.Dataset, tag);
if (val == null)
{
writer.WriteField("");
}
else
{
writer.WriteField(DicomTypeTranslater.Flatten(val));
}
}
public void DicomToBson_TranslateEmptyElements_TagsRetainedValuesNull()
{
var dataset = new DicomDataset
{
new DicomFloatingPointSingle(DicomTag.SelectorFLValue),
new DicomApplicationEntity(DicomTag.SelectorAEValue)
};
BsonDocument document = DicomTypeTranslaterReader.BuildBsonDocument(dataset);
Assert.True(document.Count() == 2);
Assert.True(document[0] == BsonNull.Value);
Assert.True(document[1] == BsonNull.Value);
}
public void DicomToBson_EmptyPrivateElements_StoredAsBsonNull()
{
DicomDataset ds = TranslationTestHelpers.BuildAllTypesNullDataset();
BsonDocument doc = DicomTypeTranslaterReader.BuildBsonDocument(ds);
Assert.AreEqual(ds.Count(), doc.Count());
foreach (BsonElement element in doc)
{
BsonDocument asBsonDoc = element.Value.AsBsonDocument;
Assert.NotNull(asBsonDoc);
Assert.True(asBsonDoc.GetValue("val").IsBsonNull); // Private elements
}
}
private void ValidateDicomItem(IFileInfo fi, DicomFile dicomFile, DicomDataset dataset, DicomItem dicomItem)
{
//if it is a sequence get the Sequences dataset and then start processing that
if (dicomItem.ValueRepresentation.Code == "SQ")
{
var sequenceItemDataSets = dataset.GetSequence(dicomItem.Tag);
foreach (var sequenceItemDataSet in sequenceItemDataSets)
{
foreach (var sequenceItem in sequenceItemDataSet)
{
ValidateDicomItem(fi, dicomFile, sequenceItemDataSet, sequenceItem);
}
}
}
else
{
Object value;
try
{
value = DicomTypeTranslaterReader.GetCSharpValue(dataset, dicomItem);
}
catch (System.FormatException)
{
// TODO(rkm 2020-04-14) Fix this - we shouldn't just validate the "unknown value" string...
value = "Unknown value for " + dicomItem;
}
// Sometimes throws "Input string was not in a correct format"
//var value = DicomTypeTranslaterReader.GetCSharpValue(dataset, dicomItem);
if (value is string)
{
Validate(fi, dicomFile, dicomItem, value as string);
}
if (value is IEnumerable <string> )
{
foreach (var s in (IEnumerable <string>)value)
{
Validate(fi, dicomFile, dicomItem, s);
}
}
if (value is DateTime && _opts.NoDateFields && _zeroDate != (DateTime)value)
{
AddToReports(factory.Create(fi, dicomFile, value.ToString(), dicomItem.Tag.DictionaryEntry.Keyword, new[] { new FailurePart(value.ToString(), FailureClassification.Date, 0) }));
}
}
}
public void BsonRoundTrip_BlacklistPrivateDataset_ZeroAfterConversion()
{
DicomDataset ds = TranslationTestHelpers.BuildPrivateDataset();
ds = new DicomDataset(ds.Where(x => DicomTypeTranslater.DicomVrBlacklist.Contains(x.ValueRepresentation)));
BsonDocument doc = DicomTypeTranslaterReader.BuildBsonDocument(ds);
DicomDataset recoDataset = DicomTypeTranslaterWriter.BuildDicomDataset(doc);
BsonDocument recoDoc = DicomTypeTranslaterReader.BuildBsonDocument(recoDataset);
Assert.AreEqual(doc, recoDoc);
foreach (DicomElement element in recoDataset.Select(x => (DicomElement)x))
{
Assert.Zero(element.Buffer.Size);
}
}
public void DicomToBson_DicomAttributeTags_ConvertedCorrectly()
{
var ds = new DicomDataset
{
new DicomAttributeTag(DicomTag.SelectorATValue, DicomTag.SOPInstanceUID, DicomTag.SeriesInstanceUID)
};
var expected = new BsonDocument
{
{ "SelectorATValue", "00080018\\0020000E" }
};
BsonDocument actual = DicomTypeTranslaterReader.BuildBsonDocument(ds);
Assert.AreEqual(expected, actual);
}
public void BsonRoundTrip_StringEncoding_ConvertedCorrectly()
{
var ds = new DicomDataset
{
new DicomShortString(DicomTag.SelectorSHValue, Encoding.ASCII, "simples"),
new DicomLongString(DicomTag.SelectorLOValue, Encoding.UTF8, "(╯°□°）╯︵ ┻━┻")
};
DicomDataset recoDs = DicomTypeTranslaterWriter.BuildDicomDataset(DicomTypeTranslaterReader.BuildBsonDocument(ds));
foreach (DicomStringElement stringElement in recoDs.Select(x => x as DicomStringElement))
{
Assert.NotNull(stringElement);
Assert.AreEqual(Encoding.UTF8, stringElement.Encoding);
}
}
public void Test_DicomFileProcessor_ProcessDocument_NullAccNo()
{
var processor = new DicomFileProcessor(new DicomReprocessorOptions(), null, null);
BsonDocument datasetDoc = DicomTypeTranslaterReader.BuildBsonDocument(new DicomDataset());
var msg = new DicomFileMessage
{
DicomFilePath = "foo",
DicomFileSize = 123,
NationalPACSAccessionNumber = null,
};
datasetDoc.Add("_id", "foo");
BsonDocument bsonHeader = MongoDocumentHeaders.ImageDocumentHeader(msg, new MessageHeader());
BsonDocument document = new BsonDocument()
.Add("header", bsonHeader)
.AddRange(datasetDoc);
processor.ProcessDocument(document);
}
public void DicomToBson_EmptyElements_StoredAsBsonNull()
{
var ds = new DicomDataset
{
new DicomAttributeTag(DicomTag.SelectorATValue),
new DicomLongString(DicomTag.SelectorLOValue),
new DicomOtherLong(DicomTag.SelectorOLValue),
new DicomOtherWord(DicomTag.SelectorOWValue),
new DicomSequence(DicomTag.SelectorCodeSequenceValue)
};
BsonDocument doc = DicomTypeTranslaterReader.BuildBsonDocument(ds);
Assert.AreEqual(ds.Count(), doc.Count());
foreach (BsonElement element in doc)
{
Assert.True(element.Value.IsBsonNull);
}
}
private static void CreateTestData(IMongoDatabase testDatabase)
{
IMongoCollection <BsonDocument> testCollection = testDatabase.GetCollection <BsonDocument>(TEST_DATA_COLL_NAME);
// Only recreate the test data if we need to
if (testCollection.CountDocuments(FilterDefinition <BsonDocument> .Empty) != 0)
{
return;
}
var f = new FileInfo(Path.Combine(TestContext.CurrentContext.WorkDirectory, "mydicom.dcm"));
TestData.Create(f, TestData.IMG_013);
DicomDataset testDataset = DicomFile.Open(f.FullName).Dataset;
testDataset.Remove(DicomTag.PixelData);
testDataset.AddOrUpdate(DicomTag.PatientName, "Smith^David");
BsonDocument datasetDoc = DicomTypeTranslaterReader.BuildBsonDocument(testDataset);
// Add our header information
var header = new BsonDocument
{
{ "NationalPACSAccessionNumber", "test-NationalPACSAccessionNumber" },
{ "DicomFilePath", "path/to/file.dcm" },
{ "StudyInstanceUID", "test-StudyInstanceUID" },
{ "SeriesInstanceUID", "test-SeriesInstanceUID" },
{ "SOPInstanceUID", "test-SOPInstanceUID" }
};
BsonDocument testDocument = new BsonDocument()
.Add("header", header)
.AddRange(datasetDoc);
for (var i = 0; i < 50; ++i)
{
testCollection.InsertOne(new BsonDocument(testDocument));
}
}
private void ShowContentSequence(DicomDataset dataset, DicomTag tag = null)
{
tag = tag ?? DicomTag.ContentSequence;
Console.WriteLine(tag.DictionaryEntry.Keyword + " Contains the following:");
Console.WriteLine("-------------------------------------------------------------");
var array = (Dictionary <DicomTag, object>[])DicomTypeTranslaterReader.GetCSharpValue(dataset, tag);
var str = ArrayHelperMethods.AsciiArt(array);
foreach (var keyword in DicomDictionary.Default)
{
str = str.Replace(keyword.Tag.ToString(), keyword.Keyword);
}
Console.WriteLine(str);
Console.WriteLine();
Console.WriteLine("--------------------End Content Sequence--------------------------");
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
olvFileTags.ClearObjects();
try
{
var dicom = DicomFile.Open(_fileInfo.FullName, FileReadOption.ReadAll);
try
{
using var renderedImage = new DicomImage(dicom.Dataset).RenderImage().AsSharpImage();
using MemoryStream ms = new();
renderedImage.Save(ms, renderedImage.GetConfiguration().ImageFormatsManager.FindEncoder(PngFormat.Instance));
ms.Seek(0, SeekOrigin.Begin);
DicomImage = new(ms);
pictureBox1.Image = DicomImage;
}
catch (Exception)
{
//no picture
splitContainer1.Panel1Collapsed = true;
}
foreach (DicomItem item in dicom.Dataset)
{
var value = DicomTypeTranslater.Flatten(DicomTypeTranslaterReader.GetCSharpValue(dicom.Dataset, item));
olvFileTags.AddObject(new TagValueNode(item.Tag, value));
}
}
catch (Exception exception)
{
MessageBox.Show(exception.ToString(), "File Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public void DicomToBson_BothBsonKeyFormats_ConvertedCorrectly()
{
DicomPrivateCreator privateCreator = DicomDictionary.Default.GetPrivateCreator("TEST");
DicomDictionary pDict = DicomDictionary.Default[privateCreator];
pDict.Add(new DicomDictionaryEntry(DicomMaskedTag.Parse("0003", "xx02"), "Private Tag 02", "PrivateTag02", DicomVM.VM_1, false, DicomVR.AE));
var ds = new DicomDataset
{
{ DicomTag.SOPInstanceUID, "1.2.3.4" }
};
ds.Add(new DicomApplicationEntity(ds.GetPrivateTag(new DicomTag(3, 0x0002, privateCreator)), "AETITLE"));
BsonDocument bsonDoc = DicomTypeTranslaterReader.BuildBsonDocument(ds);
//NOTE: Ordering of items inside a MongoDB document is significant
var expected = new BsonDocument
{
{ "(0003,0010)-PrivateCreator",
new BsonDocument
{
{ "vr", "LO" },
{ "val", "TEST" }
} },
{ "(0003,1002:TEST)-PrivateTag02",
new BsonDocument
{
{ "vr", "AE" },
{ "val", "AETITLE" }
} },
{ "SOPInstanceUID", "1.2.3.4" }
};
Assert.AreEqual(expected, bsonDoc);
}
private void Validate(DicomFileMessage message, MessageHeader header, BsonDocument document)
{
Assert.False(message == null || document == null);
BsonElement element;
Assert.True(document.TryGetElement("header", out element));
var docHeader = (BsonDocument)element.Value;
Assert.AreEqual(_imageMessageProps.Count - 3, docHeader.ElementCount);
ValidateHeader(message, header, docHeader);
DicomDataset dataset = DicomTypeTranslater.DeserializeJsonToDataset(message.DicomDataset);
Assert.NotNull(dataset);
BsonDocument datasetDocument = DicomTypeTranslaterReader.BuildBsonDocument(dataset);
document.Remove("_id");
document.Remove("header");
Assert.AreEqual(datasetDocument, document);
}
