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 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 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 DicomToBson_GroupLengthElements_AreIgnored()
{
var ds = new DicomDataset
{
new DicomCodeString(new DicomTag(123, 0), "abc")
};
Assert.IsEmpty(DicomTypeTranslaterReader.BuildBsonDocument(ds));
}
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 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
}
}
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 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);
}
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);
}
public override void AddToWriteQueue(SeriesMessage message, IMessageHeader header, ulong deliveryTag)
{
// Only time we are not processing is if we are shutting down anyway
if (IsStopping)
{
return;
}
if (Model == null)
{
throw new ApplicationException("Model needs to be set before messages can be processed");
}
DicomDataset dataset;
try
{
dataset = DicomTypeTranslater.DeserializeJsonToDataset(message.DicomDataset);
}
catch (Exception e)
{
throw new ApplicationException("Could not deserialize json to dataset", e);
}
BsonDocument datasetDoc;
try
{
datasetDoc = DicomTypeTranslaterReader.BuildBsonDocument(dataset);
}
catch (Exception e)
{
throw new ApplicationException("Exception converting dataset to BsonDocument", e);
}
BsonDocument bsonHeader = MongoDocumentHeaders.SeriesDocumentHeader(message);
BsonDocument document = new BsonDocument()
.Add("header", bsonHeader)
.AddRange(datasetDoc);
int docByteLength = document.ToBson().Length;
if (docByteLength > MaxDocumentSize)
{
throw new ApplicationException($"BsonDocument was larger than the max allowed size (have {docByteLength}, max is {MaxDocumentSize})");
}
var forceProcess = false;
lock (LockObj)
{
ToProcess.Enqueue(new Tuple <BsonDocument, ulong>(document, deliveryTag));
if (ToProcess.Count >= MaxQueueSize)
{
forceProcess = true;
}
}
if (!forceProcess)
{
return;
}
Logger.Debug("SeriesMessageProcessor: Max queue size reached, calling ProcessQueue");
ProcessQueue();
}
public void DicomToBson_VrInfo_StoredInBson()
{
// Dataset with:
// Standard SOPInstanceUID tag
// Private tags
// Tag with multiple possible VRs
// Sequence containing private tags
var ds = new DicomDataset
{
{ DicomTag.SOPInstanceUID, "1.2.3.4" },
{ DicomTag.SequenceOfUltrasoundRegions,
new DicomDataset
{
new DicomCodeString(new DicomTag(1953, 16), "ELSCINT1"),
new DicomUnsignedShort(new DicomTag(1953, 4176, "ELSCINT1"), 123),
},
new DicomDataset
{
new DicomCodeString(new DicomTag(1953, 16), "ELSCINT2"),
new DicomUnsignedShort(new DicomTag(1953, 4176, "ELSCINT2"), 456),
} },
{ DicomVR.US, DicomTag.GrayLookupTableDataRETIRED, ushort.MinValue, ushort.MaxValue },
new DicomCodeString(new DicomTag(1953, 16), "ELSCINT3"),
new DicomUnsignedShort(new DicomTag(1953, 4176, "ELSCINT3"), 789)
};
BsonDocument convertedDoc = DicomTypeTranslaterReader.BuildBsonDocument(ds);
var expectedDoc = new BsonDocument
{
{ "SOPInstanceUID", "1.2.3.4" },
{ "SequenceOfUltrasoundRegions",
new BsonArray
{
new BsonDocument
{
{ "(07a1,0010)-PrivateCreator",
new BsonDocument
{
{ "vr", "CS" },
{ "val", "ELSCINT1" }
} },
{ "(07a1,1050:ELSCINT1)-Unknown",
new BsonDocument
{
{ "vr", "US" },
{ "val",
new BsonArray
{
new BsonInt32(123)
} }
} }
},
new BsonDocument
{
{ "(07a1,0010)-PrivateCreator",
new BsonDocument
{
{ "vr", "CS" },
{ "val", "ELSCINT2" }
} },
{ "(07a1,1050:ELSCINT2)-Unknown",
new BsonDocument
{
{ "vr", "US" },
{ "val",
new BsonArray
{
new BsonInt32(456)
} }
} }
}
} },
{ "GrayLookupTableData",
new BsonDocument
{
{ "vr", "US" },
{ "val",
new BsonArray
{
ushort.MinValue,
ushort.MaxValue
} }
} },
{ "(07a1,0010)-PrivateCreator",
new BsonDocument
{
{ "vr", "CS" },
{ "val", "ELSCINT3" }
} },
{ "(07a1,1050:ELSCINT3)-Unknown",
new BsonDocument
{
{ "vr", "US" },
{ "val",
new BsonArray
{
new BsonInt32(789)
} }
} }
};
Assert.AreEqual(expectedDoc, convertedDoc);
}
public void DicomToBson_TranslatePrivateDataset_DoesNotThrow()
{
DicomDataset ds = TranslationTestHelpers.BuildPrivateDataset();
Assert.DoesNotThrow(() => DicomTypeTranslaterReader.BuildBsonDocument(ds));
}
