public void Constructor_FromDataset_SequenceItemsNotLinked()
{
var ds = new DicomDataset {
{ DicomTag.PatientID, "1" }
};
var sps = new DicomDataset {
{ DicomTag.ScheduledStationName, "1" }
};
var spcs = new DicomDataset {
{ DicomTag.ContextIdentifier, "1" }
};
sps.Add(new DicomSequence(DicomTag.ScheduledProtocolCodeSequence, spcs));
ds.Add(new DicomSequence(DicomTag.ScheduledProcedureStepSequence, sps));
var ds2 = new DicomDataset(ds);
ds2.AddOrUpdate(DicomTag.PatientID, "2");
ds2.GetSequence(DicomTag.ScheduledProcedureStepSequence).Items[0].AddOrUpdate(DicomTag.ScheduledStationName, "2");
ds2.GetSequence(DicomTag.ScheduledProcedureStepSequence).Items[0].GetSequence(
DicomTag.ScheduledProtocolCodeSequence).Items[0].AddOrUpdate(DicomTag.ContextIdentifier, "2");
Assert.Equal("1", ds.GetSingleValue <string>(DicomTag.PatientID));
Assert.Equal(
"1",
ds.GetSequence(DicomTag.ScheduledProcedureStepSequence).First().GetString(DicomTag.ScheduledStationName));
Assert.Equal(
"1",
ds.GetSequence(DicomTag.ScheduledProcedureStepSequence).First().GetSequence(
DicomTag.ScheduledProtocolCodeSequence).First().GetString(DicomTag.ContextIdentifier));
}
public void NestedSequencesBlankRemovalAllExceptSequence()
{
var ds = new DicomDataset(
new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"),
new DicomSequence(DicomTag.RTROIObservationsSequence,
new DicomDataset(new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"))));
var anon = GetAnonEngine(Mode.blank);
var th = new TestHandler(new Dictionary <DicomTag, AnonFunc>()
{
{ DicomTag.RTROIObservationsSequence, (x, s, y) => { return(y); } }
}, null);
anon.RegisterHandler(th);
var nds = anon.Anonymize(ds);
// Assert no changes happened to the original object
Assert.AreEqual("1.2.3", ds.GetSingleValue <string>(DicomTag.SOPInstanceUID));
Assert.IsTrue(ds.Contains(DicomTag.RTROIObservationsSequence));
Assert.AreEqual(1, ds.GetSequence(DicomTag.RTROIObservationsSequence).Items.Count);
Assert.AreEqual("1.2.3", ds.GetSequence(DicomTag.RTROIObservationsSequence).Items[0].GetSingleValue <string>(DicomTag.SOPInstanceUID));
Assert.IsFalse(nds.Contains(DicomTag.SOPInstanceUID));
Assert.IsTrue(nds.Contains(DicomTag.RTROIObservationsSequence));
Assert.AreEqual(0, nds.GetSequence(DicomTag.RTROIObservationsSequence).Items.Count);
}
public void InternalTransferSyntax_Setter_AppliesToAllSequenceDepths()
{
var ds = new DicomDataset {
{ DicomTag.PatientID, "1" }
};
var sps = new DicomDataset {
{ DicomTag.ScheduledStationName, "1" }
};
var spcs = new DicomDataset {
{ DicomTag.ContextIdentifier, "1" }
};
sps.Add(new DicomSequence(DicomTag.ScheduledProtocolCodeSequence, spcs));
ds.Add(new DicomSequence(DicomTag.ScheduledProcedureStepSequence, sps));
var newSyntax = DicomTransferSyntax.DeflatedExplicitVRLittleEndian;
ds.InternalTransferSyntax = newSyntax;
Assert.Equal(newSyntax, ds.InternalTransferSyntax);
Assert.Equal(
newSyntax,
ds.GetSequence(DicomTag.ScheduledProcedureStepSequence).First().InternalTransferSyntax);
Assert.Equal(
newSyntax,
ds.GetSequence(DicomTag.ScheduledProcedureStepSequence).First().GetSequence(
DicomTag.ScheduledProtocolCodeSequence).Items[0].InternalTransferSyntax);
}
private static Scan LoadEnhancedMRImage(DicomFile dicomFile)
{
var volume = new ImageSet();
var dataSet = dicomFile.Dataset;
var dicomPixelData = DicomPixelData.Create(dataSet);
var nrFrames = dicomPixelData.NumberOfFrames;
var functionalGroupShared = dataSet.GetSequence(DicomTag.SharedFunctionalGroupsSequence);
var frameDataSet = functionalGroupShared.ElementAt(0);
DicomDataset functionalGroupPerFrameDataSet = null;
for (int i = 0; i < nrFrames; i++)
{
var pixelData = PixelDataFactory.Create(dicomPixelData, i);
ImageData image = CreateImageData(pixelData);
if (image == null)
{
continue;
}
volume.Slices.Add(image);
var functionalGroupPerFrame = dataSet.GetSequence(DicomTag.PerFrameFunctionalGroupsSequence);
functionalGroupPerFrameDataSet = functionalGroupPerFrame.ElementAt(i);
var pixelMeasureSequence = functionalGroupPerFrameDataSet.GetSequence(DicomTag.PixelMeasuresSequence);
var pixelMeasureSequenceItem = pixelMeasureSequence.FirstOrDefault();
GetPixelSpacing(pixelMeasureSequenceItem, image);
var planeOrientations = functionalGroupPerFrameDataSet.GetSequence(DicomTag.PlaneOrientationSequence);
var planeOrientationDataSet = planeOrientations.ElementAt(0);
var dicomOrientationPatient = planeOrientationDataSet.GetDicomItem <DicomDecimalString>(DicomTag.ImageOrientationPatient);
GetImageOrientationPatient(image, dicomOrientationPatient);
var planePositionSequence = functionalGroupPerFrameDataSet.GetSequence(DicomTag.PlanePositionSequence);
var planePositionDataSet = planePositionSequence.ElementAt(0);
GetPositionPatient(planePositionDataSet, image);
ReadWindowing(image, functionalGroupPerFrameDataSet);
ReadPixelTransformation(image, frameDataSet, functionalGroupPerFrameDataSet);
}
DeriveVolumeFields(volume);
var patient = GetPatient(dataSet);
return(new Scan {
Volume = volume, Patient = patient
});
}
internal void SaveImage(DicomDataset dataset)
{
//var studyUid = dataset.GetSingleValue<string>(DicomTag.StudyInstanceUID);
var instUid = dataset.GetSingleValue <string>(DicomTag.SOPInstanceUID);
var path = Path.GetFullPath(StoragePath);
//path = Path.Combine(path, studyUid);
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
path = Path.Combine(path, instUid) + ".dcm";
new DicomFile(dataset).Save(path);
var FrameExtractionSequence = dataset.GetSequence(DicomTag.FrameExtractionSequence);
var items = FrameExtractionSequence.GetEnumerator();
while (items.MoveNext())
{
var oldSOPInstancUID = items.Current.GetSingleValue <String>(DicomTag.SOPInstanceUID);
var Framelist = items.Current.GetValues <uint>(DicomTag.SimpleFrameList);
for (int i = 0; i < Framelist.Length; i++)
{
DataManager.SetLocalFile(oldSOPInstancUID, (int)Framelist[i], path, i);
}
}
}
/// <summary>
/// Returns a list of observations found in the given data set.
/// </summary>
/// <remarks>
/// The standard does not impose any relationship between the number of observations and the
/// referenceROI there can be 0 or more.
/// </remarks>
/// <param name="ds"></param>
/// <returns></returns>
public static IReadOnlyList <DicomRTObservation> Read(DicomDataset ds)
{
var observations = new List <DicomRTObservation>();
if (ds.Contains(DicomTag.RTROIObservationsSequence))
{
// Changed for new OSS fo-dicom-desktop
var seq = ds.GetSequence(DicomTag.RTROIObservationsSequence);
foreach (var item in seq)
{
var roiNumber = item.GetStringOrEmpty(DicomTag.ReferencedROINumber);
var roiInterpreter = item.GetStringOrEmpty(DicomTag.ROIInterpreter);
var roiInterpretedTypeStr = item.GetStringOrEmpty(DicomTag.RTROIInterpretedType);
ROIInterpretedType roiInterpretedType;
if (Enum.IsDefined(typeof(ROIInterpretedType), roiInterpretedTypeStr))
{
Enum.TryParse(roiInterpretedTypeStr, true, out roiInterpretedType);
}
else
{
roiInterpretedType = ROIInterpretedType.None;
}
observations.Add(new DicomRTObservation(roiNumber, new DicomPersonNameConverter(roiInterpreter), roiInterpretedType));
}
}
return(observations);
}
public static bool IsOutOfRange(DicomDataset request)
{
if (request.Contains(DicomTag.ScheduledProcedureStepSequence))
{
DicomDataset procedureStep = request.GetSequence(DicomTag.ScheduledProcedureStepSequence).First();
var scheduledProcedureStepStartDate = procedureStep.GetSingleValueOrDefault(DicomTag.ScheduledProcedureStepStartDate, string.Empty);
Logger.Info($"scheduledProcedureStepStartDate: {scheduledProcedureStepStartDate}");
Log.Loger($"scheduledProcedureStepStartDate: {scheduledProcedureStepStartDate}");
if (!string.IsNullOrEmpty(scheduledProcedureStepStartDate) && scheduledProcedureStepStartDate != "*")
{
var index = scheduledProcedureStepStartDate.IndexOf("-");
if (index >= 0)
{
scheduledProcedureStepStartDate = scheduledProcedureStepStartDate.Substring(0, index);
Logger.Info($"New scheduledProcedureStepStartDate: {scheduledProcedureStepStartDate}");
Log.Loger($"New scheduledProcedureStepStartDate: {scheduledProcedureStepStartDate}");
}
if (string.IsNullOrEmpty(scheduledProcedureStepStartDate))
{
return(true);
}
DateTime endDate = System.DateTime.Today.AddDays(1).AddSeconds(-1);
DateTime startDate = endDate.AddDays(_cacheDays * -1);
//DicomDateRange range = new DicomDateTime(DicomTag.ScheduledProcedureStepStartDate, startDate).Get<DicomDateRange>();
DicomDateRange range = new DicomDateRange(startDate, endDate);
DateTime queryStartDate = new DicomDateTime(DicomTag.ScheduledProcedureStepStartDate, scheduledProcedureStepStartDate).Get <DateTime>();
return(!range.Contains(queryStartDate));
}
}
return(false);
}
public static IReadOnlyList <DicomRTContour> Read(DicomDataset ds)
{
var contours = new List <DicomRTContour>();
if (ds.Contains(DicomTag.ROIContourSequence))
{
// Changed for new OSS fo-dicom-desktop
var seq = ds.GetSequence(DicomTag.ROIContourSequence);
//var seq = ds.Get<DicomSequence>(DicomTag.ROIContourSequence);
foreach (var item in seq)
{
// Note this must be present but we should avoid throwing here
var referencedRoiNumber = item.GetString(DicomTag.ReferencedROINumber);
var color = item.GetValues <string>(DicomTag.ROIDisplayColor);
//var referencedRoiNumber = item.Get(DicomTag.ReferencedROINumber, string.Empty);
//var color = item.Get(DicomTag.ROIDisplayColor, new[] { "255", "255", "255" });
var contourItems = new List <DicomRTContourItem>();
if (item.Contains(DicomTag.ContourSequence))
{
var seqContour = item.GetSequence(DicomTag.ContourSequence);
contourItems.AddRange(seqContour.Select(DicomRTContourItem.Read));
}
contours.Add(new DicomRTContour(referencedRoiNumber, ParseColor(color), contourItems));
}
}
return(contours);
}
private static BsonValue CreateBsonValueFromSequence(DicomDataset ds, DicomTag tag, bool writeVr)
{
if (!ds.Contains(tag))
{
throw new ArgumentException("The DicomDataset does not contain the item");
}
var sequenceArray = new BsonArray();
foreach (DicomDataset sequenceElement in ds.GetSequence(tag))
{
sequenceArray.Add(BuildBsonDocument(sequenceElement));
}
if (sequenceArray.Count > 0)
{
return(sequenceArray);
}
return(writeVr
? (BsonValue) new BsonDocument
{
{ "vr", "SQ" },
{ "val", BsonNull.Value }
}
: BsonNull.Value);
}
public void Constructor_FromDataset_DataReproduced()
{
var ds = new DicomDataset {
{ DicomTag.PatientID, "1" }
};
var sps1 = new DicomDataset {
{ DicomTag.ScheduledStationName, "1" }
};
var sps2 = new DicomDataset {
{ DicomTag.ScheduledStationName, "2" }
};
var spcs1 = new DicomDataset {
{ DicomTag.ContextIdentifier, "1" }
};
var spcs2 = new DicomDataset {
{ DicomTag.ContextIdentifier, "2" }
};
var spcs3 = new DicomDataset {
{ DicomTag.ContextIdentifier, "3" }
};
sps1.Add(new DicomSequence(DicomTag.ScheduledProtocolCodeSequence, spcs1, spcs2));
sps2.Add(new DicomSequence(DicomTag.ScheduledProtocolCodeSequence, spcs3));
ds.Add(new DicomSequence(DicomTag.ScheduledProcedureStepSequence, sps1, sps2));
Assert.Equal("1", ds.GetString(DicomTag.PatientID));
Assert.Equal(
"1",
ds.GetSequence(DicomTag.ScheduledProcedureStepSequence).First().GetString(DicomTag.ScheduledStationName));
Assert.Equal(
"2",
ds.GetSequence(DicomTag.ScheduledProcedureStepSequence).Items[1].GetString(DicomTag.ScheduledStationName));
Assert.Equal(
"1",
ds.GetSequence(DicomTag.ScheduledProcedureStepSequence).First().GetSequence(
DicomTag.ScheduledProtocolCodeSequence).First().GetString(DicomTag.ContextIdentifier));
Assert.Equal(
"2",
ds.GetSequence(DicomTag.ScheduledProcedureStepSequence).First().GetSequence(
DicomTag.ScheduledProtocolCodeSequence).Items[1].GetString(DicomTag.ContextIdentifier));
Assert.Equal(
"3",
ds.GetSequence(DicomTag.ScheduledProcedureStepSequence).Items[1].GetSequence(
DicomTag.ScheduledProtocolCodeSequence).First().GetString(DicomTag.ContextIdentifier));
}
public void NestedSequencesInPlace()
{
var ds = new DicomDataset(
new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"),
new DicomSequence(DicomTag.RTROIObservationsSequence,
new DicomDataset(new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "1.2.3"))));
var anon = GetAnonEngine(Mode.inplace);
var th = new TestHandler(new Dictionary <DicomTag, AnonFunc>()
{
{ DicomTag.SOPInstanceUID, (x, s, y) => { return(new DicomUniqueIdentifier(DicomTag.SOPInstanceUID, "3.2.1")); } }
}, null);
anon.RegisterHandler(th);
anon.Anonymize(ds);
Assert.AreEqual("3.2.1", ds.GetSingleValue <string>(DicomTag.SOPInstanceUID));
Assert.AreEqual(1, ds.GetSequence(DicomTag.RTROIObservationsSequence).Items.Count);
Assert.AreEqual("3.2.1", ds.GetSequence(DicomTag.RTROIObservationsSequence).Items[0].GetSingleValue <string>(DicomTag.SOPInstanceUID));
}
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 static DicomRTReferencedStudy Read(DicomDataset ds)
{
var refSOPClass = ds.GetStringOrEmpty(DicomTag.ReferencedSOPClassUID);
var refSOPInstance = ds.GetStringOrEmpty(DicomTag.ReferencedSOPInstanceUID);
var listSeries = new List <DicomRTReferencedSeries>();
if (ds.Contains(DicomTag.RTReferencedSeriesSequence))
{
// Changed for new OSS fo-dicom-desktop
var seq = ds.GetSequence(DicomTag.RTReferencedSeriesSequence);
//var seq = ds.Get<DicomSequence>(DicomTag.RTReferencedSeriesSequence);
foreach (var item in seq)
{
listSeries.Add(DicomRTReferencedSeries.Read(item));
}
}
return(new DicomRTReferencedStudy(refSOPClass, refSOPInstance, listSeries));
}
/// <summary>
/// 转换DicomDataset为日志字符串
/// </summary>
/// <param name="ddt">DicomDataset</param>
/// <param name="lev">级别</param>
/// <returns></returns>
public static string LogToConsole(DicomDataset ddt, int lev = 0)
{
string log = string.Empty;
List <DicomItem> dicomItems = ddt.ToList();
int ddtCount = ddt.Count();
string sLev = " ";
for (int i = 0; i < lev; i++)
{
sLev += "\t";
}
for (int i = 0; i < ddtCount; i++)
{
DicomItem dicomItem = dicomItems[i];
if (dicomItem is Dicom.DicomSequence)
{
//log = $" Tag: \"{dicomItem.Tag.DictionaryEntry.Name}\" \"{dicomItem.Tag.DictionaryEntry.Tag.ToString()}\", VR: \"{dicomItem.ValueRepresentation.ToString()}\", VM: {ddt.GetSequence(dicomItem.Tag).Items.Count.ToString()}";
log = log + "\r\n" + $"{sLev}{dicomItem.Tag.DictionaryEntry.Tag.ToString().PadRight(12)} {dicomItem.ValueRepresentation.Code.ToString().PadRight(5)} ({ddt.GetSequence(dicomItem.Tag).Items.Count.ToString().PadLeft(3)}) {dicomItem.Tag.DictionaryEntry.Name}";
foreach (DicomDataset ddts in ddt.GetSequence(dicomItem.Tag).Items)
{
log = log + LogToConsole(ddts, lev + 1);
}
}
else
{
if (ddt.GetValueCount(dicomItem.Tag) > 0)
{
//log = $"{sLev}Tag: \"{dicomItem.Tag.DictionaryEntry.Name}\" \"{dicomItem.Tag.DictionaryEntry.Tag.ToString()}\", VR: \"{dicomItem.ValueRepresentation.Code.ToString()}\", VM: {((Dicom.DicomMultiStringElement)dicomItem).Count.ToString()}, Value: \"{ddt.GetValue<string>(dicomItem.Tag, 0)}\"";
log = log + "\r\n" + $"{sLev}{dicomItem.Tag.DictionaryEntry.Tag.ToString().PadRight(12)} {dicomItem.ValueRepresentation.Code.ToString().PadRight(5)} {($"|{ddt.GetValue<string>(dicomItem.Tag, 0)}|").PadRight(20)} ({((Dicom.DicomMultiStringElement)dicomItem).Count.ToString().PadLeft(3)}) {dicomItem.Tag.DictionaryEntry.Name}";
}
else
{
//log = $"{sLev}Tag: \"{dicomItem.Tag.DictionaryEntry.Name}\" \"{dicomItem.Tag.DictionaryEntry.Tag.ToString()}\", VR: \"{dicomItem.ValueRepresentation.Code.ToString()}\", VM: {((Dicom.DicomMultiStringElement)dicomItem).Count.ToString()}, Value: \"\"";
log = log + "\r\n" + $"{sLev}{dicomItem.Tag.DictionaryEntry.Tag.ToString().PadRight(12)} {dicomItem.ValueRepresentation.Code.ToString().PadRight(5)} {($"|<null>|").PadRight(20)} ({((Dicom.DicomMultiStringElement)dicomItem).Count.ToString().PadLeft(3)}) {dicomItem.Tag.DictionaryEntry.Name}";
}
}
}
return(log);
}
private static object GetSequenceFromDataset(DicomDataset ds, DicomTag tag)
{
var toReturn = new List <Dictionary <DicomTag, object> >();
foreach (DicomDataset sequenceElement in ds.GetSequence(tag))
{
IEnumerator <DicomItem> enumerator = sequenceElement.GetEnumerator();
var current = new Dictionary <DicomTag, object>();
toReturn.Add(current);
while (enumerator.MoveNext())
{
current.Add(enumerator.Current.Tag, GetCSharpValue(sequenceElement, enumerator.Current));
}
}
return(toReturn.Count != 0
? toReturn.ToArray()
: null);
}
public static DicomRTReferencedSeries Read(DicomDataset ds)
{
var seriesInstanceUID = ds.GetStringOrEmpty(DicomTag.SeriesInstanceUID);
var contourImages = new List <DicomRTContourImageItem>();
if (ds.Contains(DicomTag.ContourImageSequence))
{
// Changed for new OSS fo-dicom-desktop
var seq = ds.GetSequence(DicomTag.ContourImageSequence);
//var seq = ds.Get<DicomSequence>(DicomTag.ContourImageSequence);
foreach (var item in seq)
{
var contourImageItem = DicomRTContourImageItem.Read(item);
contourImages.Add(contourImageItem);
}
}
return(new DicomRTReferencedSeries(seriesInstanceUID, contourImages));
}
public static IReadOnlyDictionary <string, DicomRTStructureSetROI> Read(DicomDataset ds)
{
var rois = new Dictionary <string, DicomRTStructureSetROI>();
if (ds.Contains(DicomTag.StructureSetROISequence))
{
// Changed for new OSS fo-dicom-desktop
var seq = ds.GetSequence(DicomTag.StructureSetROISequence);
//var seq = ds.Get<DicomSequence>(DicomTag.StructureSetROISequence);
foreach (var item in seq)
{
var roiNumber = item.GetStringOrEmpty(DicomTag.ROINumber);
var referencedFrameUID = item.GetStringOrEmpty(DicomTag.ReferencedFrameOfReferenceUID);
var roiName = item.GetStringOrEmpty(DicomTag.ROIName);
var roiGenerationAlgorithm = ParseRoiAlgorithm(item.GetStringOrEmpty(DicomTag.ROIGenerationAlgorithm));
rois.Add(
roiNumber, new DicomRTStructureSetROI(roiNumber, roiName, referencedFrameUID, roiGenerationAlgorithm));
}
}
return(rois);
}
public static DicomRTFrameOFReference Read(DicomDataset ds)
{
// Changed for new OSS fo-dicom-desktop
var frameReferencedUID = ds.GetString(DicomTag.FrameOfReferenceUID);
//var frameReferencedUID = ds.Get(DicomTag.FrameOfReferenceUID, string.Empty);
var referencedStudies = new List <DicomRTReferencedStudy>();
if (ds.Contains(DicomTag.RTReferencedStudySequence))
{
// Changed for new OSS fo-dicom-desktop
var seq = ds.GetSequence(DicomTag.RTReferencedStudySequence);
//var seq = ds.Get<DicomSequence>(DicomTag.RTReferencedStudySequence);
foreach (var item in seq)
{
referencedStudies.Add(DicomRTReferencedStudy.Read(item));
}
}
return(new DicomRTFrameOFReference(
frameReferencedUID,
referencedStudies));
}
static private DicomItem GetAttributeValue(DicomDataset dataset, DicomTag attributeTag, DicomVR vr)
{
if (dataset.Contains(attributeTag) && dataset.GetDicomItem <DicomItem>(attributeTag).ValueRepresentation == vr)
{
return(dataset.GetDicomItem <DicomItem>(attributeTag));
}
foreach (var item in dataset)
{
if (item.ValueRepresentation != DicomVR.SQ)
{
continue;
}
foreach (var sequenceDataset in dataset.GetSequence(item.Tag))
{
var value = GetAttributeValue(sequenceDataset, attributeTag, vr);
if (value != null)
{
return(value);
}
}
}
return(null);
}
public static DicomRTStructureSet Read(DicomDataset ds)
{
var label = ds.GetTrimmedStringOrEmpty(DicomTag.StructureSetLabel);
var name = ds.GetTrimmedStringOrEmpty(DicomTag.StructureSetName);
var description = ds.GetTrimmedStringOrEmpty(DicomTag.StructureSetDescription);
var date = ds.GetStringOrEmpty(DicomTag.StructureSetDate);
var time = ds.GetStringOrEmpty(DicomTag.StructureSetTime);
var frames = new List <DicomRTFrameOFReference>();
if (!ds.Contains(DicomTag.ReferencedFrameOfReferenceSequence))
{
return(new DicomRTStructureSet(label, name, description, date, time, frames));
}
// Changed for new OSS fo-dicom-desktop
var seq = ds.GetSequence(DicomTag.ReferencedFrameOfReferenceSequence);
//var seq = ds.Get<DicomSequence>(DicomTag.ReferencedFrameOfReferenceSequence);
frames.AddRange(seq.Select(DicomRTFrameOFReference.Read));
return(new DicomRTStructureSet(label, name, description, date, time, frames));
}
private void CreateSequence(List <string> elements, int currentElementIndex, DicomDataset dicomRequest, string value)
{
uint tag = GetTagValue(elements[currentElementIndex]);
var dicEntry = DicomDictionary.Default[tag];
DicomSequence sequence;
DicomDataset item;
dicomRequest.AddOrUpdate(new DicomSequence(dicEntry.Tag));
sequence = dicomRequest.GetSequence(dicEntry.Tag);
item = new DicomDataset( )
{
AutoValidate = false
};
sequence.Items.Add(item);
for (int index = (currentElementIndex + 1); index < elements.Count; index++)
{
tag = GetTagValue(elements[index]);
dicEntry = DicomDictionary.Default[tag];
if (dicEntry.ValueRepresentations.Contains(DicomVR.SQ))
{
CreateSequence(elements, index, item, value);
break;
}
else
{
item.AddOrUpdate <string> (tag, value);
}
}
}
/// <summary>
/// Read an RT Contour Item from the given dataset.
/// </summary>
/// <param name="ds"></param>
/// <returns></returns>
public static DicomRTContourItem Read(DicomDataset ds)
{
// Changed for new OSS fo-dicom-desktop
var numberOfPoints = ds.GetSingleValue <int>(DicomTag.NumberOfContourPoints);
// fo-dicom internally parses strings to decimal using InvariantCulture and then converts to double
var data = ds.GetValues <double>(DicomTag.ContourData);
//var numberOfPoints = ds.Get<int>(DicomTag.NumberOfContourPoints);
//// fo-dicom internally parses strings to decimal using InvariantCulture and then converts to double
//var data = ds.Get<double[]>(DicomTag.ContourData);
var geometricType = ds.GetTrimmedStringOrEmpty(DicomTag.ContourGeometricType);
List <DicomRTContourImageItem> listImages = new List <DicomRTContourImageItem>();
if (ds.Contains(DicomTag.ContourImageSequence))
{
// Changed for new OSS fo-dicom-desktop
var seqImages = ds.GetSequence(DicomTag.ContourImageSequence);
//var seqImages = ds.Get<DicomSequence>(DicomTag.ContourImageSequence);
foreach (var item in seqImages)
{
listImages.Add(DicomRTContourImageItem.Read(item));
}
}
return(new DicomRTContourItem(data, numberOfPoints, geometricType, listImages));
}
public async Task <bool> SendMppsCompletedAsync(string serverIp, int serverPort, string serverAET, string localAET, string studyInstanceUid, DicomUID affectedInstanceUid, DicomDataset worklistItem)
{
DicomSequence procedureStepSq = worklistItem.GetSequence(DicomTag.ScheduledProcedureStepSequence);
// A worklistitem may have a list of scheduledprocedureSteps.
// For each of them you have to send separate MPPS InProgress- and Completed-messages.
// there in this example we will only send for the first procedure step
DicomDataset procedureStep = procedureStepSq.First();
// data
DicomDataset dataset = new DicomDataset
{
{ DicomTag.StudyInstanceUID, studyInstanceUid },
{ DicomTag.PerformedProcedureStepEndDate, DateTime.Now },
{ DicomTag.PerformedProcedureStepEndTime, DateTime.Now },
{ DicomTag.PerformedProcedureStepStatus, COMPLETED },
{ DicomTag.PerformedProcedureStepDescription, procedureStep.GetSingleValueOrDefault(DicomTag.ScheduledProcedureStepID, string.Empty) },
{ DicomTag.PerformedProcedureTypeDescription, string.Empty },
{ DicomTag.PerformedProtocolCodeSequence, new DicomDataset() },
{ DicomTag.ProcedureCodeSequence, new DicomDataset() },
// dose and reports
{ DicomTag.ImageAndFluoroscopyAreaDoseProduct, 0.0m }, // if there has bee sone dose while examination
{ DicomTag.CommentsOnRadiationDose, string.Empty }, // a free text that contains all dose parameters
{ DicomTag.PerformedSeriesSequence, new DicomDataset()
{
{ DicomTag.RetrieveAETitle, string.Empty }, // the aetitle of the archive where the images have been sent to
{ DicomTag.SeriesDescription, "series 1" },
{ DicomTag.PerformingPhysicianName, string.Empty },
{ DicomTag.OperatorsName, string.Empty },
{ DicomTag.ProtocolName, "protocol 1" },
{ DicomTag.SeriesInstanceUID, DicomUID.Generate() },
{ DicomTag.ReferencedImageSequence, new DicomDataset()
{
{ DicomTag.ReferencedSOPClassUID, DicomUID.SecondaryCaptureImageStorage },
{ DicomTag.ReferencedSOPInstanceUID, DicomUID.Generate() }
} },
} }
};
//// images created
//DicomSequence performedSeriesSq = new DicomSequence(DicomTag.PerformedSeriesSequence);
//// iterate all Series that have been created while examination
//DicomDataset serie = new DicomDataset()
//{
// { DicomTag.RetrieveAETitle, string.Empty }, // the aetitle of the archive where the images have been sent to
// { DicomTag.SeriesDescription, "serie 1" },
// { DicomTag.PerformingPhysicianName, string.Empty },
// { DicomTag.OperatorsName, string.Empty },
// { DicomTag.ProtocolName, string.Empty },
// { DicomTag.SeriesInstanceUID, DicomUID.Generate() }
//};
//DicomSequence refImagesInSerie = new DicomSequence(DicomTag.ReferencedImageSequence);
//// iterate all images in the serie
//DicomDataset image = new DicomDataset()
//{
// { DicomTag.ReferencedSOPClassUID, DicomUID.SecondaryCaptureImageStorage },
// { DicomTag.ReferencedSOPInstanceUID, DicomUID.Generate() }
//};
//refImagesInSerie.Items.Add(image);
//serie.Add(refImagesInSerie);
//performedSeriesSq.Items.Add(serie);
//dataset.Add(performedSeriesSq);
bool result = false;
DicomNSetRequest dicomFinished = new DicomNSetRequest(DicomUID.ModalityPerformedProcedureStepSOPClass, affectedInstanceUid)
{
Dataset = dataset,
OnResponseReceived = (req, res) =>
{
if (res != null)
{
if (res.Status == DicomStatus.Success)
{
result = true;
Logger.Debug("Set study [{0}] [Complete] Success.", studyInstanceUid);
}
else
{
Logger.Warn("Set study [{0}] [Complete] Failed. [{1}]", studyInstanceUid, res.Status);
}
}
}
};
DicomClient client = new DicomClient(serverIp, serverPort, false, localAET, serverAET);
await client.AddRequestAsync(dicomFinished);
await client.SendAsync();
return(result);
}
public async Task <bool> SendMppsDiscontinuedAsync(string serverIp, int serverPort, string serverAET, string localAET, string studyInstanceUid, DicomUID affectedInstanceUid, DicomDataset worklistItem)
{
DicomSequence procedureStepSq = worklistItem.GetSequence(DicomTag.ScheduledProcedureStepSequence);
// A worklistitem may have a list of scheduledprocedureSteps.
// For each of them you have to send separate MPPS InProgress- and Completed-messages.
// there in this example we will only send for the first procedure step
DicomDataset procedureStep = procedureStepSq.First();
DicomDataset dataset = new DicomDataset()
{
{ DicomTag.StudyInstanceUID, studyInstanceUid },
{ DicomTag.PerformedProcedureStepEndDate, DateTime.Now },
{ DicomTag.PerformedProcedureStepEndTime, DateTime.Now },
{ DicomTag.PerformedProcedureStepStatus, DISCONTINUED },
{ DicomTag.PerformedProcedureStepDescription, procedureStep.GetSingleValueOrDefault(DicomTag.ScheduledProcedureStepID, string.Empty) },
{ DicomTag.PerformedProcedureTypeDescription, string.Empty },
{ DicomTag.PerformedProtocolCodeSequence, new DicomDataset() },
{ DicomTag.ProcedureCodeSequence, new DicomDataset() },
{ DicomTag.PerformedSeriesSequence, new DicomDataset()
{
{ DicomTag.RetrieveAETitle, string.Empty }, // the aetitle of the archive where the images have been sent to
{ DicomTag.SeriesDescription, "series 1" },
{ DicomTag.PerformingPhysicianName, string.Empty },
{ DicomTag.OperatorsName, string.Empty },
{ DicomTag.ProtocolName, "protocol 1" },
{ DicomTag.SeriesInstanceUID, DicomUID.Generate() },
{ DicomTag.ReferencedImageSequence, new DicomDataset()
{
{ DicomTag.ReferencedSOPClassUID, DicomUID.SecondaryCaptureImageStorage },
{ DicomTag.ReferencedSOPInstanceUID, DicomUID.Generate() }
} },
} }
};
bool result = false;
DicomNSetRequest dicomAbort = new DicomNSetRequest(DicomUID.ModalityPerformedProcedureStepSOPClass, affectedInstanceUid)
{
Dataset = dataset,
OnResponseReceived = (req, res) =>
{
if (res != null)
{
if (res.Status == DicomStatus.Success)
{
result = true;
Logger.Debug("Set study [{0}] [Discontinued] Success.", studyInstanceUid);
}
else
{
Logger.Warn("Set study [{0}] [Discontinued] Failed. [{1}]", studyInstanceUid, res.Status);
}
}
}
};
DicomClient client = new DicomClient(serverIp, serverPort, false, localAET, serverAET);
await client.AddRequestAsync(dicomAbort);
await client.SendAsync();
return(result);
}
public async Task <(DicomUID affectedInstanceUid, string studyInstanceUid, bool result)> SendMppsInProgressAsync(string serverIp, int serverPort, string serverAET, string localAET, DicomDataset worklistItem)
{
DicomSequence procedureStepSeq = worklistItem.GetSequence(DicomTag.ScheduledProcedureStepSequence);
// A worklistitem may have a list of scheduledprocedureSteps.
// For each of them you have to send separate MPPS InProgress- and Completed-messages.
// there in this example we will only send for the first procedure step
DicomDataset procedureStep = procedureStepSeq.First();
// get study instance UID from MWL query resault
string studyInstanceUID = worklistItem.GetSingleValueOrDefault(DicomTag.StudyInstanceUID, DicomUIDGenerator.GenerateDerivedFromUUID().UID);
DicomDataset dataset = new DicomDataset
{
{ DicomTag.PatientName, worklistItem.GetSingleValueOrDefault(DicomTag.PatientName, string.Empty) },
{ DicomTag.PatientID, worklistItem.GetSingleValueOrDefault(DicomTag.PatientID, string.Empty) },
{ DicomTag.PatientBirthDate, worklistItem.GetSingleValueOrDefault(DicomTag.PatientBirthDate, string.Empty) },
{ DicomTag.PatientSex, worklistItem.GetSingleValueOrDefault(DicomTag.PatientSex, string.Empty) },
{ DicomTag.StudyID, worklistItem.GetSingleValueOrDefault(DicomTag.StudyID, string.Empty) },
{ DicomTag.StudyInstanceUID, studyInstanceUID },
{ DicomTag.PerformedProcedureStepID, procedureStep.GetSingleValueOrDefault(DicomTag.ScheduledProcedureStepID, string.Empty) },
{ DicomTag.PerformedProcedureStepDescription, procedureStep.GetSingleValueOrDefault(DicomTag.ScheduledProcedureStepID, string.Empty) },
// set status
{ DicomTag.PerformedProcedureStepStatus, IN_PROGRESS },
{ DicomTag.PerformedProcedureTypeDescription, string.Empty },
{ DicomTag.PerformedProcedureStepStartDate, DateTime.Now },
{ DicomTag.PerformedProcedureStepStartTime, DateTime.Now },
{ DicomTag.PerformedProcedureStepEndDate, string.Empty },
{ DicomTag.PerformedProcedureStepEndTime, string.Empty },
{ DicomTag.PerformedLocation, string.Empty },
{ DicomTag.PerformedStationAETitle, localAET },
{ DicomTag.PerformedStationName, localAET },
// get modality from MWL query result
{ DicomTag.Modality, procedureStep.GetSingleValueOrDefault(DicomTag.Modality, string.Empty) },
{ DicomTag.PerformedProtocolCodeSequence, new DicomDataset() },
{ DicomTag.ProcedureCodeSequence, new DicomDataset() },
{ DicomTag.ReferencedPatientSequence, new DicomDataset() }
};
// set Attribute Sequence data
DicomDataset content = new DicomDataset
{
{ DicomTag.AccessionNumber, worklistItem.GetSingleValueOrDefault(DicomTag.AccessionNumber, string.Empty) },
{ DicomTag.StudyInstanceUID, studyInstanceUID },
{ DicomTag.ReferencedStudySequence, new DicomDataset() },
{ DicomTag.RequestedProcedureID, worklistItem.GetSingleValueOrDefault(DicomTag.RequestedProcedureID, string.Empty) },
{ DicomTag.RequestedProcedureDescription, worklistItem.GetSingleValueOrDefault(DicomTag.RequestedProcedureDescription, string.Empty) },
{ DicomTag.ScheduledProcedureStepID, procedureStep.GetSingleValueOrDefault(DicomTag.ScheduledProcedureStepID, string.Empty) },
{ DicomTag.ScheduledProcedureStepDescription, procedureStep.GetSingleValueOrDefault(DicomTag.ScheduledProcedureStepDescription, string.Empty) },
{ DicomTag.ScheduledProtocolCodeSequence, new DicomDataset() }
};
DicomSequence attr_Sequence = new DicomSequence(DicomTag.ScheduledStepAttributesSequence, content);//"Scheduled Step Attribute Sequence"
dataset.Add(attr_Sequence);
dataset.Add(DicomTag.PerformedSeriesSequence, new DicomDataset());
// create an unique UID as the effectedinstamceUid, this id will be needed for the N-SET also
DicomUID effectedinstamceUid = DicomUID.Generate();
DicomNCreateRequest dicomStartRequest = new DicomNCreateRequest(DicomUID.ModalityPerformedProcedureStepSOPClass, effectedinstamceUid)
{
Dataset = dataset
};
bool result = false;
dicomStartRequest.OnResponseReceived += (req, res) =>
{
if (res != null)
{
if (res.Status == DicomStatus.Success)
{
Logger.Debug("Set study [{0}] [In Progress] Success.", studyInstanceUID);
result = true;
}
else
{
Logger.Warn("Set study [{0}] [In Progress] Failed. [{1}]", studyInstanceUID, res.Status);
}
}
};
DicomClient client = new DicomClient(serverIp, serverPort, false, localAET, serverAET);
await client.AddRequestAsync(dicomStartRequest);
await client.SendAsync();
return(effectedinstamceUid, studyInstanceUID, result);
}
private static (string responseStatus, string responseMessage) SendMppsCompleted(string serverIP, int serverPort, string serverAET, string clientAET, DicomUID affectedInstanceUid, DicomDataset worklistItem)
{
var client = new DicomClient();
var dataset = new DicomDataset();
DicomSequence procedureStepSq = worklistItem.GetSequence(DicomTag.ScheduledProcedureStepSequence);
// A worklistitem may have a list of scheduledprocedureSteps.
// For each of them you have to send separate MPPS InProgress- and Completed-messages.
// there in this example we will only send for the first procedure step
var procedureStep = procedureStepSq.First();
// data
dataset.Add(DicomTag.PerformedProcedureStepEndDate, DateTime.Now);
dataset.Add(DicomTag.PerformedProcedureStepEndTime, DateTime.Now);
dataset.Add(DicomTag.PerformedProcedureStepStatus, "COMPLETED");
dataset.Add(DicomTag.PerformedProcedureStepDescription, procedureStep.GetSingleValueOrDefault(DicomTag.ScheduledProcedureStepID, String.Empty));
dataset.Add(DicomTag.PerformedProcedureTypeDescription, string.Empty);
dataset.Add(DicomTag.PerformedProtocolCodeSequence, new DicomDataset());
// dose and reports
dataset.Add(DicomTag.ImageAndFluoroscopyAreaDoseProduct, 0.0m); // if there has bee sone dose while examination
dataset.Add(DicomTag.CommentsOnRadiationDose, string.Empty); // a free text that contains all dose parameters
// images created
var performedSeriesSq = new DicomSequence(DicomTag.PerformedSeriesSequence);
// iterate all Series that have been created while examination
var serie = new DicomDataset
{
{ DicomTag.RetrieveAETitle, string.Empty }, // the aetitle of the archive where the images have been sent to
{ DicomTag.SeriesDescription, "serie 1" },
{ DicomTag.PerformingPhysicianName, string.Empty },
{ DicomTag.OperatorsName, string.Empty },
{ DicomTag.ProtocolName, string.Empty },
{ DicomTag.SeriesInstanceUID, DicomUID.Generate() }
};
var refImagesInSerie = new DicomSequence(DicomTag.ReferencedImageSequence);
// iterate all images in the serie
var image = new DicomDataset
{
{ DicomTag.ReferencedSOPClassUID, DicomUID.SecondaryCaptureImageStorage },
{ DicomTag.ReferencedSOPInstanceUID, DicomUID.Generate() }
};
refImagesInSerie.Items.Add(image);
serie.Add(refImagesInSerie);
performedSeriesSq.Items.Add(serie);
dataset.Add(performedSeriesSq);
var dicomFinished = new DicomNSetRequest(DicomUID.ModalityPerformedProcedureStepSOPClass, affectedInstanceUid)
{
Dataset = dataset
};
string responseStatus = string.Empty;
string responseMessage = string.Empty;
dicomFinished.OnResponseReceived += (req, response) =>
{
if (response != null)
{
Console.WriteLine(response);
responseStatus = response.Status.ToString();
responseMessage = response.ToString();
}
};
client.AddRequest(dicomFinished);
client.SendAsync(serverIP, serverPort, false, clientAET, serverAET).Wait();
return(responseStatus, responseMessage);
}
private static (DicomUID affectedInstanceUid, string responseStatus, string responseMessage) SendMppsInProgress(string serverIP, int serverPort, string serverAET, string clientAET, DicomDataset worklistItem)
{
var client = new DicomClient();
var dataset = new DicomDataset();
DicomSequence procedureStepSq = worklistItem.GetSequence(DicomTag.ScheduledProcedureStepSequence);
// A worklistitem may have a list of scheduledprocedureSteps.
// For each of them you have to send separate MPPS InProgress- and Completed-messages.
// there in this example we will only send for the first procedure step
var procedureStep = procedureStepSq.First();
DicomDataset content = new DicomDataset();
// get study instance UID from MWL query resault
string studyInstanceUID = worklistItem.GetSingleValueOrDefault(DicomTag.StudyInstanceUID, DicomUID.Generate().ToString());
// set Attribute Sequence data
content.Add(DicomTag.StudyInstanceUID, studyInstanceUID);
content.Add(DicomTag.ReferencedStudySequence, new DicomDataset());
content.Add(DicomTag.AccessionNumber, worklistItem.GetSingleValueOrDefault(DicomTag.AccessionNumber, String.Empty));
content.Add(DicomTag.RequestedProcedureID, worklistItem.GetSingleValueOrDefault(DicomTag.RequestedProcedureID, String.Empty));
content.Add(DicomTag.RequestedProcedureDescription, worklistItem.GetSingleValueOrDefault(DicomTag.RequestedProcedureDescription, String.Empty));
content.Add(DicomTag.ScheduledProcedureStepID, procedureStep.GetSingleValueOrDefault(DicomTag.ScheduledProcedureStepID, String.Empty));
content.Add(DicomTag.ScheduledProcedureStepDescription, procedureStep.GetSingleValueOrDefault(DicomTag.ScheduledProcedureStepDescription, String.Empty));
content.Add(DicomTag.ScheduledProtocolCodeSequence, new DicomDataset());
DicomSequence attr_Sequence = new DicomSequence(DicomTag.ScheduledStepAttributesSequence, content);//"Scheduled Step Attribute Sequence"
dataset.Add(attr_Sequence);
dataset.Add(DicomTag.PatientName, worklistItem.GetSingleValueOrDefault(DicomTag.PatientName, String.Empty));
dataset.Add(DicomTag.PatientID, worklistItem.GetSingleValueOrDefault(DicomTag.PatientID, String.Empty));
dataset.Add(DicomTag.PatientBirthDate, worklistItem.GetSingleValueOrDefault(DicomTag.PatientBirthDate, String.Empty));
dataset.Add(DicomTag.PatientSex, worklistItem.GetSingleValueOrDefault(DicomTag.PatientSex, String.Empty));
dataset.Add(DicomTag.ReferencedPatientSequence, new DicomDataset());
dataset.Add(DicomTag.PerformedProcedureStepID, procedureStep.GetSingleValueOrDefault(DicomTag.ScheduledProcedureStepID, String.Empty));
dataset.Add(DicomTag.PerformedStationAETitle, PerformedStationAETitle);
dataset.Add(DicomTag.PerformedStationName, PerformedStationName);
dataset.Add(DicomTag.PerformedLocation, string.Empty);
dataset.Add(DicomTag.PerformedProcedureStepStartDate, DateTime.Now);
dataset.Add(DicomTag.PerformedProcedureStepStartTime, DateTime.Now);
// set status
dataset.Add(DicomTag.PerformedProcedureStepStatus, "IN PROGRESS");
dataset.Add(DicomTag.PerformedProcedureStepDescription, procedureStep.GetSingleValueOrDefault(DicomTag.ScheduledProcedureStepID, String.Empty));
dataset.Add(DicomTag.PerformedProcedureTypeDescription, string.Empty);
dataset.Add(DicomTag.PerformedProcedureStepEndDate, string.Empty);
dataset.Add(DicomTag.PerformedProcedureStepEndTime, string.Empty);
// get modality from MWL query resault
dataset.Add(DicomTag.Modality, procedureStep.GetSingleValueOrDefault(DicomTag.Modality, String.Empty));
dataset.Add(DicomTag.StudyID, worklistItem.GetSingleValueOrDefault(DicomTag.StudyID, string.Empty));
dataset.Add(DicomTag.PerformedProtocolCodeSequence, new DicomDataset());
// create an unique UID as the effectedinstamceUid, this id will be needed for the N-SET also
DicomUID effectedinstamceUid = DicomUID.Generate("effectedinstamceUid");
var dicomStartRequest = new DicomNCreateRequest(DicomUID.ModalityPerformedProcedureStepSOPClass, effectedinstamceUid)
{
Dataset = dataset
};
string responseStatus = string.Empty;
string responseMessage = string.Empty;
dicomStartRequest.OnResponseReceived += (req, response) =>
{
if (response != null)
{
Console.WriteLine(response);
responseStatus = response.Status.ToString();
responseMessage = response.ToString();
}
};
client.AddRequest(dicomStartRequest);
client.SendAsync(serverIP, serverPort, false, clientAET, serverAET).Wait();
return(effectedinstamceUid, responseStatus, responseMessage);
}
public static List <DicomDataset> QueryWorklistItems(DicomDataset request)
{
if (_isRealTime)
{
//记录查询时间
System.Diagnostics.Stopwatch stopWatch1 = new System.Diagnostics.Stopwatch();
stopWatch1.Start();
DateTime dtRequestBeg = DateTime.Now;
Logger.Info($">>QueryWorklistItems CreateWorklistQuery BeginTime: {dtRequestBeg.ToString("yyyy-MM-dd HH:mm:ss")}");
Log.Loger($">>QueryWorklistItems CreateWorklistQuery BeginTime: {dtRequestBeg.ToString("yyyy-MM-dd HH:mm:ss")}");
DateTime endDate = System.DateTime.Today.AddDays(1).AddSeconds(-1);
DateTime startDate = endDate.AddDays(_cacheDays * -1);
string patientId = string.Empty;
if (!request.TryGetSingleValue(DicomTag.PatientID, out patientId))
{
patientId = null;
}
if (request.Contains(DicomTag.ScheduledProcedureStepSequence))
{
DicomDataset procedureStep = request.GetSequence(DicomTag.ScheduledProcedureStepSequence).First();
var scheduledProcedureStepStartDate = procedureStep.GetSingleValueOrDefault(DicomTag.ScheduledProcedureStepStartDate, string.Empty);
var scheduledProcedureStepEndDate = procedureStep.GetSingleValueOrDefault(DicomTag.ScheduledProcedureStepEndDate, string.Empty);
Logger.Info($"Exam scheduledProcedureStepStartDate: {scheduledProcedureStepStartDate}");
Log.Loger($"Exam scheduledProcedureStepStartDate: {scheduledProcedureStepStartDate}");
Logger.Info($"Exam scheduledProcedureStepEndDate: {scheduledProcedureStepEndDate}");
Log.Loger($"Exam scheduledProcedureStepEndDate: {scheduledProcedureStepEndDate}");
var index = scheduledProcedureStepStartDate.IndexOf("-");
if (index >= 0)
{
scheduledProcedureStepEndDate = scheduledProcedureStepStartDate.Substring(index + 1);
Logger.Info($"Exam New scheduledProcedureStepEndDate: {scheduledProcedureStepEndDate}");
Log.Loger($"Exam New scheduledProcedureStepEndDate: {scheduledProcedureStepEndDate}");
scheduledProcedureStepStartDate = scheduledProcedureStepStartDate.Substring(0, index);
Logger.Info($"Exam New scheduledProcedureStepStartDate: {scheduledProcedureStepStartDate}");
Log.Loger($"Exam New scheduledProcedureStepStartDate: {scheduledProcedureStepStartDate}");
}
scheduledProcedureStepStartDate = scheduledProcedureStepStartDate.Replace(":", "").Replace(" ", "");
scheduledProcedureStepEndDate = scheduledProcedureStepEndDate.Replace(":", "").Replace(" ", "");
if (!string.IsNullOrEmpty(scheduledProcedureStepStartDate) && scheduledProcedureStepStartDate != "*")
{
startDate = new DicomDateTime(DicomTag.ScheduledProcedureStepStartDate, scheduledProcedureStepStartDate).Get <System.DateTime>();
}
if (!string.IsNullOrEmpty(scheduledProcedureStepEndDate) && scheduledProcedureStepEndDate != "*")
{
endDate = new DicomDateTime(DicomTag.ScheduledProcedureStepStartDate, scheduledProcedureStepEndDate).Get <System.DateTime>();
}
}
DicomDateRange dr = new DicomDateRange(startDate, endDate);
var cfind = DicomCFindRequest.CreateWorklistQuery(patientId, null, null, null, null, dr);
//记录查询时间
DateTime dtRequestEnd = DateTime.Now;
Logger.Info($">>CreateWorklistQuery EndTime: {dtRequestEnd.ToString("yyyy-MM-dd HH:mm:ss")}");
Log.Loger($">>CreateWorklistQuery EndTime: {dtRequestEnd.ToString("yyyy-MM-dd HH:mm:ss")}");
stopWatch1.Stop();
Logger.Info($">>CreateWorklistQuery SpentTime: {stopWatch1.Elapsed.TotalSeconds}");
Log.Loger($">>CreateWorklistQuery SpentTime: {stopWatch1.Elapsed.TotalSeconds}");
Log.Loger($"\r\n");
var newWorklistItems = GetWorkList(cfind);
Logger.Info($"Get new work list, length: {newWorklistItems.Count}");
Log.Loger($"Get new work list, length: {newWorklistItems.Count}");
return(newWorklistItems);
}
else
{
if (CurrentWorklistItems != null && CurrentWorklistItems.Count == 0)
{
var newWorklistItems = GetCachedWorklist();
Logger.Info($"Get new work list, length: {newWorklistItems.Count}");
Log.Loger($"Get new work list, length: {newWorklistItems.Count}");
CurrentWorklistItems = newWorklistItems;
}
return(CurrentWorklistItems);
}
}
public static IEnumerable <DicomDataset> FilterWorklistItems(DicomDataset request, List <WorklistItem> allWorklistItems)
{
var exams = allWorklistItems.AsQueryable();
if (request.TryGetSingleValue(DicomTag.PatientID, out string patientId))
{
exams = exams.Where(x => x.PatientID.Equals(patientId));
}
var patientName = request.GetSingleValueOrDefault(DicomTag.PatientName, string.Empty);
if (!string.IsNullOrEmpty(patientName))
{
exams = AddNameCondition(exams, patientName);
}
DicomDataset procedureStep = null;
if (request.Contains(DicomTag.ScheduledProcedureStepSequence))
{
procedureStep = request.GetSequence(DicomTag.ScheduledProcedureStepSequence).First();
// Required Matching keys
var scheduledStationAET = procedureStep.GetSingleValueOrDefault(DicomTag.ScheduledStationAETitle, string.Empty);
if (!string.IsNullOrEmpty(scheduledStationAET))
{
exams = exams.Where(x => x.ScheduledAET == scheduledStationAET);
}
var performingPhysician = procedureStep.GetSingleValueOrDefault(DicomTag.PerformingPhysicianName, string.Empty);
if (!string.IsNullOrEmpty(performingPhysician))
{
exams = exams.Where(x => x.PerformingPhysician == performingPhysician);
}
var modality = procedureStep.GetSingleValueOrDefault(DicomTag.Modality, string.Empty);
if (!string.IsNullOrEmpty(modality))
{
exams = exams.Where(x => x.Modality == modality);
}
// if only date is specified, then using standard matching
// but if both are specified, then MWL defines a combined match
var scheduledProcedureStepStartDateTime = procedureStep.GetSingleValueOrDefault(DicomTag.ScheduledProcedureStepStartDateTime, string.Empty);
if (!string.IsNullOrEmpty(scheduledProcedureStepStartDateTime))
{
exams = AddDateCondition(exams, scheduledProcedureStepStartDateTime);
}
// Optional (but commonly used) matching keys.
var procedureStepLocation = procedureStep.GetSingleValueOrDefault(DicomTag.ScheduledProcedureStepLocation, string.Empty);
if (!string.IsNullOrEmpty(procedureStepLocation))
{
exams = exams.Where(x => x.ExamRoom.Equals(procedureStepLocation));
}
var procedureDescription = procedureStep.GetSingleValueOrDefault(DicomTag.ScheduledProcedureStepDescription, string.Empty);
if (!string.IsNullOrEmpty(procedureDescription))
{
exams = exams.Where(x => x.ExamDescription.Equals(procedureDescription));
}
}
var results = exams.ToList();
// Parsing result
foreach (var result in results)
{
var resultingSPS = new DicomDataset();
var resultDataset = new DicomDataset();
var resultingSPSSequence = new DicomSequence(DicomTag.ScheduledProcedureStepSequence, resultingSPS);
if (procedureStep != null)
{
resultDataset.Add(resultingSPSSequence);
}
// add results to "main" dataset
AddIfExistsInRequest(resultDataset, request, DicomTag.AccessionNumber, result.AccessionNumber); // T2
AddIfExistsInRequest(resultDataset, request, DicomTag.InstitutionName, result.HospitalName);
AddIfExistsInRequest(resultDataset, request, DicomTag.ReferringPhysicianName, result.ReferringPhysician); // T2
AddIfExistsInRequest(resultDataset, request, DicomTag.PatientName, result.Surname + "^" + result.Forename + "^^" + result.Title); //T1
AddIfExistsInRequest(resultDataset, request, DicomTag.PatientID, result.PatientID); // T1
AddIfExistsInRequest(resultDataset, request, DicomTag.PatientBirthDate, result.DateOfBirth); // T2
AddIfExistsInRequest(resultDataset, request, DicomTag.PatientSex, result.Sex); //T2
AddIfExistsInRequest(resultDataset, request, DicomTag.StudyInstanceUID, result.StudyUID); // T1
AddIfExistsInRequest(resultDataset, request, DicomTag.RequestingPhysician, result.ReferringPhysician); //T2
AddIfExistsInRequest(resultDataset, request, DicomTag.RequestedProcedureDescription, result.ExamDescription); //T1C
AddIfExistsInRequest(resultDataset, request, DicomTag.RequestedProcedureID, result.ProcedureID); // T1
// Scheduled Procedure Step sequence T1
// add results to procedure step dataset
// Return if requested
if (procedureStep != null)
{
AddIfExistsInRequest(resultingSPS, procedureStep, DicomTag.ScheduledStationAETitle, result.ScheduledAET); // T1
AddIfExistsInRequest(resultingSPS, procedureStep, DicomTag.ScheduledProcedureStepStartDate, result.ExamDateAndTime); //T1
AddIfExistsInRequest(resultingSPS, procedureStep, DicomTag.ScheduledProcedureStepStartTime, result.ExamDateAndTime); //T1
AddIfExistsInRequest(resultingSPS, procedureStep, DicomTag.Modality, result.Modality); // T1
AddIfExistsInRequest(resultingSPS, procedureStep, DicomTag.ScheduledPerformingPhysicianName, result.PerformingPhysician); //T2
AddIfExistsInRequest(resultingSPS, procedureStep, DicomTag.ScheduledProcedureStepDescription, result.ExamDescription); // T1C
AddIfExistsInRequest(resultingSPS, procedureStep, DicomTag.ScheduledProcedureStepID, result.ProcedureStepID); // T1
AddIfExistsInRequest(resultingSPS, procedureStep, DicomTag.ScheduledStationName, result.ExamRoom); //T2
AddIfExistsInRequest(resultingSPS, procedureStep, DicomTag.ScheduledProcedureStepLocation, result.ExamRoom); //T2
}
// Put blanks in for unsupported fields which are type 2 (i.e. must have a value even if NULL)
// In a real server, you may wish to support some or all of these, but they are not commonly supported
AddIfExistsInRequest(resultDataset, request, DicomTag.ReferencedStudySequence, new DicomDataset()); // Ref//d Study Sequence
AddIfExistsInRequest(resultDataset, request, DicomTag.Priority, ""); // Priority
AddIfExistsInRequest(resultDataset, request, DicomTag.PatientTransportArrangements, ""); // Transport Arrangements
AddIfExistsInRequest(resultDataset, request, DicomTag.AdmissionID, ""); // Admission ID
AddIfExistsInRequest(resultDataset, request, DicomTag.CurrentPatientLocation, ""); // Patient Location
AddIfExistsInRequest(resultDataset, request, DicomTag.ReferencedPatientSequence, new DicomDataset()); // Ref//d Patient Sequence
AddIfExistsInRequest(resultDataset, request, DicomTag.PatientWeight, ""); // Weight
AddIfExistsInRequest(resultDataset, request, DicomTag.ConfidentialityConstraintOnPatientDataDescription, ""); // Confidentiality Constraint
// Send Reponse Back
yield return(resultDataset);
}
}
public void AddResult(DicomDataset ds, Exception ex)
{
var referencedInstance = GetReferencedInstsance(ds);
var failedSeq = (_dataset.Contains(DicomTag.FailedSOPSequence)) ? _dataset.GetSequence(DicomTag.FailedSOPSequence) : new DicomSequence(DicomTag.FailedSOPSequence);
var item = new DicomDataset( )
{
AutoValidate = false
};
referencedInstance.Merge(item);
_dataset.AddOrUpdate(failedSeq);
failedSeq.Items.Add(item);
if (_successAdded)
{
HttpStatus = HttpStatusCode.Accepted;
}
else
{
SetError(ex, item);
}
_failureAdded = true;
}
