public DicomNGetRequest(
DicomUID requestedClassUid,
DicomUID requestedInstanceUid)
: base(DicomCommandField.NGetRequest, requestedClassUid)
{
SOPInstanceUID = requestedInstanceUid;
}
/// <summary>
/// Add item for creating extended negotiation sub-items.
/// </summary>
/// <param name="uid">Associated UID.</param>
/// <param name="creator">Creator instance.</param>
public static void AddSubItemCreator(DicomUID uid, CreateIExtendedNegotiationSubItemDelegate creator)
{
if (false == subItemCreators.ContainsKey(uid))
{
subItemCreators.Add(uid, creator);
}
}
public DicomPresentationContext(byte pcid, DicomUID abstractSyntax)
{
_pcid = pcid;
_result = DicomPresentationContextResult.Proposed;
_abstract = abstractSyntax;
_transferSyntaxes = new List<DicomTransferSyntax>();
}
internal DicomPresentationContext(byte pcid, DicomUID abstractSyntax, DicomTransferSyntax transferSyntax, DicomPresentationContextResult result) {
_pcid = pcid;
_result = result;
_abstract = abstractSyntax;
_transferSyntaxes = new List<DicomTransferSyntax>();
_transferSyntaxes.Add(transferSyntax);
}
/// <summary>
/// Initializes new Basic Film Box
/// </summary>
/// <param name="session">Basic Film Session</param>
/// <param name="sopInstance">SOP Instance UID</param>
/// <param name="dataset">Dataset</param>
public DcmFilmBox(DcmFilmSession session, DicomUID sopInstance, DcmDataset dataset)
{
_session = session;
_sopInstance = sopInstance;
_dataset = dataset;
_boxes = new List<DcmImageBox>();
}
private List<UpdateData> generateUpdateObjectList(string studyDir)
{
toolstripStatuslbl.Text = "Preparing files for anonymization";
Random randomNumber = new Random();
List<UpdateData> updateList = new List<UpdateData>();
//Set Study ID
_studyID = DicomUID.Generate();
//Set Patient ID and Accession Number based on user random request
if (chkbxRandomPatientId.Checked == true)
{
_patientId = randomNumber.Next(1000, 99999).ToString();
}
if (chkbxRandomAccessionNumber.Checked == true)
{
_accessionNumber = randomNumber.Next(1000, 99999).ToString();
}
foreach (string dcmFile in Directory.GetFiles(studyDir, "*", SearchOption.AllDirectories))
{
if(dcmFile.EndsWith(".dcm"))
{
int seriesNumber = getSeriesNumberFromDcm(dcmFile);
updateList.Add(createUpdateObject(dcmFile, seriesNumber));
}
}
return updateList;
}
public DicomNCreateRequest(
DicomUID affectedClassUid,
DicomUID affectedInstanceUid)
: base(DicomCommandField.NCreateRequest, affectedClassUid)
{
SOPInstanceUID = affectedInstanceUid;
}
/// <summary>
/// Initializes new Basic Film Box
/// </summary>
/// <param name="session">Basic Film Session</param>
/// <param name="sopInstance">SOP Instance UID</param>
public DcmFilmBox(DcmFilmSession session, DicomUID sopInstance)
{
_session = session;
_sopInstance = sopInstance;
_dataset = new DcmDataset(DicomTransferSyntax.ImplicitVRLittleEndian);
_boxes = new List<DcmImageBox>();
}
protected DicomRequest(DicomCommandField type, DicomUID affectedClassUid, DicomPriority priority) : base() {
Type = type;
SOPClassUID = affectedClassUid;
MessageID = GetNextMessageID();
Priority = priority;
Dataset = null;
}
/// <summary>
/// Construct new film session from scratch
/// </summary>
public FilmSession(DicomUID sopClassUID, DicomUID sopInstance = null, bool isColor = false)
: base()
{
this.InternalTransferSyntax = DicomTransferSyntax.ExplicitVRLittleEndian;
if (sopClassUID == null)
{
throw new ArgumentNullException("sopClassUID");
}
SOPClassUID = sopClassUID;
if (sopInstance == null || sopInstance.UID == string.Empty)
{
SOPInstanceUID = DicomUID.Generate();
}
else
{
SOPInstanceUID = sopInstance;
}
this.Add(DicomTag.SOPClassUID, SOPClassUID);
this.Add(DicomTag.SOPInstanceUID, SOPInstanceUID);
BasicFilmBoxes = new List<FilmBox>();
PresentationLuts = new List<PresentationLut>();
IsColor = isColor;
}
/// <summary>
/// Initializes a new instance of the <see cref="DicomRequest"/> class.
/// </summary>
/// <param name="type">
/// The command field type.
/// </param>
/// <param name="requestedClassUid">
/// The requested Class Uid.
/// </param>
protected DicomRequest(DicomCommandField type, DicomUID requestedClassUid)
{
Type = type;
SOPClassUID = requestedClassUid;
MessageID = GetNextMessageID();
Dataset = null;
}
public PresentationLut(DicomUID sopInstance, DicomDataset dataset)
{
if (dataset == null)
{
throw new ArgumentNullException("dataset");
}
dataset.CopyTo(this);
}
public DicomNDeleteRequest(
DicomUID requestedClassUid,
DicomUID requestedInstanceUid,
DicomPriority priority = DicomPriority.Medium)
: base(DicomCommandField.NDeleteRequest, requestedClassUid, priority)
{
SOPInstanceUID = requestedInstanceUid;
}
public DicomNGetRequest(
DicomUID requestedClassUid,
DicomUID requestedInstanceUid,
DicomTag[] attributes,
DicomPriority priority = DicomPriority.Medium)
: base(DicomCommandField.NGetRequest, requestedClassUid, priority)
{
SOPInstanceUID = requestedInstanceUid;
}
public DicomNCreateRequest(
DicomUID affectedClassUid,
DicomUID affectedInstanceUid,
ushort eventTypeId,
DicomPriority priority = DicomPriority.Medium)
: base(DicomCommandField.NCreateRequest, affectedClassUid, priority)
{
SOPInstanceUID = affectedInstanceUid;
}
public DicomNEventReportRequest(
DicomUID requestedClassUid,
DicomUID requestedInstanceUid,
ushort eventTypeId)
: base(DicomCommandField.NEventReportRequest, requestedClassUid)
{
SOPInstanceUID = requestedInstanceUid;
EventTypeID = eventTypeId;
}
public DicomNActionRequest(
DicomUID requestedClassUid,
DicomUID requestedInstanceUid,
ushort actionTypeId)
: base(DicomCommandField.NActionRequest, requestedClassUid)
{
SOPInstanceUID = requestedInstanceUid;
ActionTypeID = actionTypeId;
}
public DicomNActionRequest(
DicomUID requestedClassUid,
DicomUID requestedInstanceUid,
ushort actionTypeId,
DicomPriority priority = DicomPriority.Medium)
: base(DicomCommandField.NActionRequest, requestedClassUid, priority)
{
SOPInstanceUID = requestedInstanceUid;
ActionTypeID = actionTypeId;
}
/// <summary>
/// Construct new film session for specified SOP instance UID
/// </summary>
/// <param name="sopInstance">Film session SOP instance UID</param>
/// <param name="dataset">Film session dataset</param>
public FilmSession(DicomUID sopClassUID, DicomUID sopInstance, DicomDataset dataset, bool isColor = false)
: this(sopClassUID, sopInstance)
{
if (dataset == null)
{
throw new ArgumentNullException("dataset");
}
dataset.CopyTo(this);
this.InternalTransferSyntax = dataset.InternalTransferSyntax;
IsColor = isColor;
}
public PresentationLut(DicomUID sopInstance = null)
: base()
{
this.InternalTransferSyntax = DicomTransferSyntax.ExplicitVRLittleEndian;
if (sopInstance == null || sopInstance.UID == string.Empty)
{
SopInstanceUid = DicomUID.Generate();
}
else
{
SopInstanceUid = sopInstance;
}
CreateLutSequence();
}
/// <summary>
/// Create baisc film box for specified film session
/// </summary>
/// <param name="filmSession">Film session instance</param>
/// <param name="sopInstance">Basic film box SOP Instance UID</param>
public FilmBox(FilmSession filmSession, DicomUID sopInstance, DicomTransferSyntax transferSyntax)
: base()
{
this.InternalTransferSyntax = transferSyntax;
_filmSession = filmSession;
if (sopInstance == null || sopInstance.UID == string.Empty)
{
SOPInstanceUID = DicomUID.Generate();
}
else
{
SOPInstanceUID = sopInstance;
}
this.Add(DicomTag.SOPClassUID, SOPClassUID);
this.Add(DicomTag.SOPInstanceUID, SOPInstanceUID);
BasicImageBoxes = new List<ImageBox>();
}
/// <summary>
/// Construct new ImageBox for specified filmBox using specified SOP class UID and SOP instance UID
/// </summary>
/// <param name="filmBox"></param>
/// <param name="sopClass"></param>
/// <param name="sopInstance"></param>
public ImageBox(FilmBox filmBox, DicomUID sopClass, DicomUID sopInstance)
: base()
{
this.InternalTransferSyntax = DicomTransferSyntax.ExplicitVRLittleEndian;
FilmBox = filmBox;
SOPClassUID = sopClass;
if (sopInstance == null || sopInstance.UID == string.Empty)
{
SOPInstanceUID = DicomUID.Generate();
}
else
{
SOPInstanceUID = sopInstance;
}
this.Add(DicomTag.SOPClassUID, SOPClassUID);
this.Add(DicomTag.SOPInstanceUID, SOPInstanceUID);
}
/// <summary>
/// Construct new print job using specified SOP instance UID. If passed SOP instance UID is missing, new UID will
/// be generated
/// </summary>
/// <param name="sopInstance">New print job SOP instance uID</param>
/// <param name="printer">The printer.</param>
/// <param name="originator">The originator.</param>
/// <param name="log">The log.</param>
/// <param name="session">The session.</param>
/// <exception cref="System.ArgumentNullException">printer</exception>
/// /
public PrintJob(DicomUID sopInstance, Printer printer, string originator, Log.Logger log, FilmSession session)
{
if (printer == null)
{
throw new ArgumentNullException("printer");
}
Log = log;
if (sopInstance == null || sopInstance.UID == string.Empty)
SOPInstanceUID = DicomUID.Generate();
else
SOPInstanceUID = sopInstance;
Add(DicomTag.SOPClassUID, SOPClassUID);
Add(DicomTag.SOPInstanceUID, SOPInstanceUID);
Printer = printer;
Status = PrintJobStatus.Pending;
PrinterName = Printer.PrinterAet;
Session = session;
Originator = originator;
if (CreationDateTime == DateTime.MinValue)
{
CreationDateTime = DateTime.Now;
}
PrintJobFolder = SOPInstanceUID.UID;
var receivingFolder = Environment.CurrentDirectory + @"\PrintJobs";
FullPrintJobFolder = string.Format(@"{0}\{1}", receivingFolder.TrimEnd('\\'), PrintJobFolder);
FilmBoxFolderList = new List<string>();
}
protected override void OnReceiveNCreateRequest(byte presentationID, ushort messageID,
DicomUID affectedClass, DicomUID affectedInstance, DcmDataset dataset) {
DicomUID sopClass = Associate.GetAbstractSyntax(presentationID);
if (affectedClass == DicomUID.BasicFilmSessionSOPClass) {
if (_session != null) {
Log.Error("{0} -> Attempted to create second Basic Film Session on association", LogID);
SendAbort(DcmAbortSource.ServiceProvider, DcmAbortReason.NotSpecified);
return;
}
_session = new DcmFilmSession(sopClass, affectedInstance, dataset);
SendNCreateResponse(presentationID, messageID, affectedClass, _session.SOPInstanceUID, null, DcmStatus.Success);
return;
}
if (affectedClass == DicomUID.BasicFilmBoxSOPClass) {
if (_session == null) {
Log.Error("{0} -> A Basic Film Session does not exist for this association", LogID);
SendAbort(DcmAbortSource.ServiceProvider, DcmAbortReason.NotSpecified);
return;
}
DcmFilmBox box = _session.CreateFilmBox(affectedInstance, dataset);
if (!box.Initialize()) {
SendAbort(DcmAbortSource.ServiceProvider, DcmAbortReason.NotSpecified);
return;
}
SendNCreateResponse(presentationID, messageID, affectedClass, box.SOPInstanceUID, dataset, DcmStatus.Success);
return;
}
SendAbort(DcmAbortSource.ServiceProvider, DcmAbortReason.NotSpecified);
}
/// <summary> /// Platform-specific implementation to attempt to obtain a unique network identifier, e.g. based on a MAC address. /// </summary> /// <param name="identifier">Unique network identifier, if found.</param> /// <returns>True if network identifier could be obtained, false otherwise.</returns> protected abstract bool TryGetNetworkIdentifierImpl(out DicomUID identifier);
protected override void OnReceiveCStoreResponse(byte presentationID, ushort messageIdRespondedTo, DicomUID affectedInstance, DcmStatus status)
{
_current.Status = status;
if (OnCStoreResponseReceived != null)
{
try {
OnCStoreResponseReceived(this, _current);
}
catch (Exception e) {
Log.Error("Unhandled exception in user C-Store Response Callback: {0}", e.ToString());
}
}
_current.Unload();
_current = null;
SendNextCStoreRequest();
}
internal void SendCStoreRequest(byte pcid, DicomUID instUid, DcmDataset dataset)
{
SendCStoreRequest(pcid, NextMessageID(), instUid, Priority, dataset);
}
private void btnCreateSRDicom_Click(object sender, EventArgs e)
{
string deviceObserverUID = "1.1.1.1.1"; // TODO (121012)
string studyInstanceUid = "1.1.1.1.1.1.1";
string seriesInstanceUid = "1.1.1.1.1.1.1.2";
string accessionNo = "298347982347598";
int imageCount = 3;
DateTime now = DateTime.Now;
string dateTagValue = DateTime.Now.ToString("yyyyMMdd", CultureInfo.InvariantCulture);
string timeTagValue = DateTime.Now.ToString("HHmmss", CultureInfo.InvariantCulture);
DicomDataset seqContent = new DicomDataset(); //Content of the sequence
DicomDataset ds = new DicomDataset(); //Main dataset
ds.Add(DicomTag.SpecificCharacterSet, "ISO_IR 100"); //Add some items
ds.Add(DicomTag.PatientName, "Last^First^Middle=Last2^First2^Middle2=Last3^First3^Middle3");
ds.Add(DicomTag.PatientID, "ID0001");
ds.Add(DicomTag.PatientBirthDate, dateTagValue);
ds.Add(DicomTag.PatientSex, "M");
ds.Add(DicomTag.StudyDate, dateTagValue);
ds.Add(DicomTag.StudyTime, timeTagValue);
ds.Add(DicomTag.AccessionNumber, accessionNo);
ds.Add(DicomTag.ReferringPhysicianName, "RefPhysicianName Kim");
ds.Add(DicomTag.StudyDescription, "CHEST");
ds.Add(DicomTag.StudyInstanceUID, studyInstanceUid);
ds.Add(DicomTag.StudyID, "0");
ds.Add(DicomTag.SeriesDate, dateTagValue);
ds.Add(DicomTag.SeriesTime, timeTagValue);
ds.Add(DicomTag.Modality, "SR");
ds.Add(DicomTag.SeriesDescription, "Description");
ds.Add(DicomTag.SeriesInstanceUID, seriesInstanceUid);
ds.Add(DicomTag.SeriesNumber, "2");
ds.Add(DicomTag.Manufacturer, "Manufacturer");
ds.Add(DicomTag.InstitutionName, "Hospital Name");
ds.Add(DicomTag.StationName, "Room 1");
ds.Add(DicomTag.SoftwareVersions, "1.0.0.0");
ds.Add(DicomTag.ContentDate, dateTagValue);
ds.Add(DicomTag.ContentTime, timeTagValue);
ds.Add(DicomTag.InstanceNumber, "1");
ds.Add(DicomTag.NumberOfStudyRelatedInstances, imageCount);
ds.Add(DicomTag.ValueType, DicomValueType.Container);
DicomSequence conceptNameCodeSequence = new DicomSequence(DicomTag.ConceptNameCodeSequence, new DicomCodeItem("113701", "DCM", "X-Ray Radiation Dose Report", "01"));
ds.Add(conceptNameCodeSequence);
ds.Add(DicomTag.ContinuityOfContent, DicomContinuity.Separate);
seqContent.Clear();
seqContent.Add(DicomTag.AccessionNumber, accessionNo);
seqContent.Add(DicomTag.StudyInstanceUID, studyInstanceUid);
seqContent.Add(DicomTag.RequestedProcedureDescription, string.Empty);
seqContent.Add(DicomTag.RequestedProcedureCodeSequence, new DicomDataset());
seqContent.Add(DicomTag.RequestedProcedureID, string.Empty);
seqContent.Add(DicomTag.PlacerOrderNumberImagingServiceRequest, string.Empty);
seqContent.Add(DicomTag.FillerOrderNumberImagingServiceRequest, string.Empty);
DicomSequence referenceRequestSequence = new DicomSequence(DicomTag.ReferencedRequestSequence, seqContent);
ds.Add(referenceRequestSequence);
ds.Add(DicomTag.PerformedProcedureCodeSequence, new DicomDataset());
ds.Add(DicomTag.CompletionFlag, "COMPLETE");
ds.Add(DicomTag.CompletionFlagDescription, "Completed on Study close");
ds.Add(DicomTag.VerificationFlag, "UNVERIFIED");
ds.Add(DicomTag.PreliminaryFlag, "FINAL");
DicomDataset ContentTemplateSequenceDataset = new DicomDataset();
ContentTemplateSequenceDataset.Add(DicomTag.MappingResource, "DCMR");
ContentTemplateSequenceDataset.Add(DicomTag.TemplateIdentifier, "10001");
DicomSequence contentTemplateSequence = new DicomSequence(DicomTag.ContentTemplateSequence, ContentTemplateSequenceDataset);
ds.Add(contentTemplateSequence);
seqContent.Clear();
DicomStructuredReport sr = new DicomStructuredReport(ds);
{
DicomContentItem item = new DicomContentItem(
GetDcmTypeCodeItem(121058, "Procedure reported"),
DicomRelationship.HasConceptModifier,
GetDcmTypeCodeItem(113704, "Projection X-Ray"));
item.Add(new DicomContentItem(
GetSrtTypeCodeItem("G-C0E8", "Has Intent"),
DicomRelationship.HasConceptModifier,
GetSrtTypeCodeItem("R-408C3", "Diagnostic Intent")));
sr.Add(item);
}
sr.Add(new DicomContentItem(
GetDcmTypeCodeItem(121005, "Observer Type"),
DicomRelationship.HasObservationContext,
GetDcmTypeCodeItem(121007, "Device")));
sr.Add(new DicomContentItem(
GetDcmTypeCodeItem(121012, "Device Observer UID"),
DicomRelationship.HasObservationContext,
DicomUID.Parse("2222222222222222"))); // TODO : set real value
sr.Add(new DicomContentItem(
GetDcmTypeCodeItem(121013, "Device Observer Name"),
DicomRelationship.HasObservationContext,
DicomValueType.Text,
"22222222222222222")); // TODO : set real value
sr.Add(new DicomContentItem(
GetDcmTypeCodeItem(121014, "Device Observer Manufacturer"),
DicomRelationship.HasObservationContext,
DicomValueType.Text,
"Rayence"));
sr.Add(new DicomContentItem(
GetDcmTypeCodeItem(121015, "Device Observer Model Name"),
DicomRelationship.HasObservationContext,
DicomValueType.Text,
"XMARU SERIES")); // TODO : set real value
sr.Add(new DicomContentItem(
GetDcmTypeCodeItem(121016, "Device Observer Serial Number"),
DicomRelationship.HasObservationContext,
DicomValueType.Text,
"Unknown")); // TODO : set real value
sr.Add(new DicomContentItem(
GetDcmTypeCodeItem(121017, "Device Observer Physical Location During Observation"),
DicomRelationship.HasObservationContext,
DicomValueType.Text,
"Unknown")); // TODO : set real value
sr.Add(new DicomContentItem(
GetDcmTypeCodeItem(113876, "Device Role in Procedure"),
DicomRelationship.HasObservationContext,
GetDcmTypeCodeItem(121097, "Recording")));
{
DicomContentItem item = new DicomContentItem(
GetDcmTypeCodeItem(113705, "Scope of Accumulation"),
DicomRelationship.HasObservationContext,
GetDcmTypeCodeItem(113014, "Study"));
item.Add(new DicomContentItem(
GetDcmTypeCodeItem(110180, "Study Instance UID"),
DicomRelationship.HasProperties,
DicomUID.Parse(studyInstanceUid)));
sr.Add(item);
}
sr.Add(new DicomContentItem(
GetDcmTypeCodeItem(113944, "X-Ray Mechanical Data Available"),
DicomRelationship.Contains,
GetSrtTypeCodeItem("R-00339", "No")));
//-------------- TID 10002 ------------------
{
DicomContentItem containerItem = new DicomContentItem(
GetDcmTypeCodeItem(113702, "Accumulated X-Ray Dose Data"),
DicomRelationship.Contains,
DicomContinuity.Separate);
DicomSequence sequence = new DicomSequence(DicomTag.ContentTemplateSequence);
sequence.Items.Add(new DicomDataset()
.Add(DicomTag.MappingResource, "DCMR")
.Add(DicomTag.TemplateIdentifier, "10002"));
containerItem.Dataset.Add(sequence);
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(113764, "Acquisition Plane"),
DicomRelationship.HasConceptModifier,
GetDcmTypeCodeItem(113622, "Single Plane")));
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(113722, "Dose Area Product Total"),
DicomRelationship.Contains,
new DicomMeasuredValue(new Decimal(1.224), // TODO : set real value
new DicomCodeItem("Gy.m2", "UCUM", "Gy.m2"))));
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(113725, "Dose (RP) Total"),
DicomRelationship.Contains,
new DicomMeasuredValue(new Decimal(0), // TODO : set real value
new DicomCodeItem("Gy", "UCUM", "Gy"))));
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(113727, "Acquisition Dose Area Product Total"),
DicomRelationship.Contains,
new DicomMeasuredValue(new Decimal(1.224), // TODO : set real value
new DicomCodeItem("Gy.m2", "UCUM", "Gy.m2"))));
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(113729, "Acquisition Dose (RP) Total"),
DicomRelationship.Contains,
new DicomMeasuredValue(new Decimal(0), // TODO : set real value
new DicomCodeItem("Gy", "UCUM", "Gy"))));
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(113855, "Total Acquisition Time"),
DicomRelationship.Contains,
new DicomMeasuredValue(new Decimal(0.672), // TODO : set real value
new DicomCodeItem("s", "UCUM", "s"))));
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(113731, "Total Number of Radiographic Frames"),
DicomRelationship.Contains,
new DicomMeasuredValue(new Decimal(imageCount),
new DicomCodeItem("1", "UCUM", "no units"))));
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(113780, "Reference Point Definition"),
DicomRelationship.Contains,
DicomValueType.Text,
"In Detector Plane"));
DicomContentItem IrradiatingDevice = new DicomContentItem(
GetDcmTypeCodeItem(113876, "Device Role in Procedure"),
DicomRelationship.Contains,
GetDcmTypeCodeItem(113859, "Irradiating Device"));
{
IrradiatingDevice.Add(new DicomContentItem(
GetDcmTypeCodeItem(113877, "Device Name"),
DicomRelationship.HasProperties,
DicomValueType.Text,
"DX3605801"));
IrradiatingDevice.Add(new DicomContentItem(
GetDcmTypeCodeItem(113878, "Device Manufacturer"),
DicomRelationship.HasProperties,
DicomValueType.Text,
"Manufacturer"));
IrradiatingDevice.Add(new DicomContentItem(
GetDcmTypeCodeItem(113879, "Device Model Name"),
DicomRelationship.HasProperties,
DicomValueType.Text,
"ManufacturerModelName"));
IrradiatingDevice.Add(new DicomContentItem(
GetDcmTypeCodeItem(113880, "Device Serial Number"),
DicomRelationship.HasProperties,
DicomValueType.Text,
"Unknown"));
IrradiatingDevice.Add(new DicomContentItem(
GetDcmTypeCodeItem(121012, "Device Observer UID"),
DicomRelationship.HasProperties,
DicomUID.Parse(deviceObserverUID)));
}
containerItem.Add(IrradiatingDevice);
sr.Add(containerItem);
}
//-------------- TID 10003 ------------------
for (int i = 0; i < imageCount; i++)
{
DicomContentItem containerItem = new DicomContentItem(
GetDcmTypeCodeItem(113706, "Irradiation Event X-Ray Data"),
DicomRelationship.Contains,
DicomContinuity.Separate);
DicomSequence sequence = new DicomSequence(DicomTag.ContentTemplateSequence);
sequence.Items.Add(new DicomDataset()
.Add(DicomTag.MappingResource, "DCMR")
.Add(DicomTag.TemplateIdentifier, "10003"));
containerItem.Dataset.Add(sequence);
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(113764, "Acquisition Plane"),
DicomRelationship.HasConceptModifier,
GetDcmTypeCodeItem(113622, "Single Plane")));
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(113769, "Irradiation Event UID"),
DicomRelationship.Contains,
DicomUID.Parse($"{seriesInstanceUid}.{i}")));
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(111526, "DateTime Started"),
DicomRelationship.Contains,
DicomValueType.DateTime,
DateTime.Now));
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(113721, "Irradiation Event Type"),
DicomRelationship.Contains,
GetDcmTypeCodeItem(113611, "Stationary Acquisition")));
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(125203, "Acquisition Protocol"),
DicomRelationship.Contains,
DicomValueType.Text,
"1.1"));
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(123014, "Target Region"),
DicomRelationship.Contains,
GetSrtTypeCodeItem("Undefin", "ed")));
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(122130, "Dose Area Product"),
DicomRelationship.Contains,
new DicomMeasuredValue(new Decimal(0.25),
new DicomCodeItem("Gy.m2", "UCUM", "Gy.m2"))));
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(113845, "Exposure Index"),
DicomRelationship.Contains,
new DicomMeasuredValue(new Decimal(500),
new DicomCodeItem("1", "UCUM", "no units"))));
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(113846, "Target Exposure Index"),
DicomRelationship.Contains,
new DicomMeasuredValue(new Decimal(300),
new DicomCodeItem("1", "UCUM", "no units"))));
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(113738, "Dose (RP)"),
DicomRelationship.Contains,
new DicomMeasuredValue(new Decimal(0),
new DicomCodeItem("Gy", "UCUM", "Gy"))));
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(113780, "Reference Point Definition"),
DicomRelationship.Contains,
DicomValueType.Text,
"In Detector Plane"));
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(113768, "Number of Pulses"),
DicomRelationship.Contains,
new DicomMeasuredValue(new Decimal(1),
new DicomCodeItem("1", "UCUM", "no units"))));
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(113733, "KVP"),
DicomRelationship.Contains,
new DicomMeasuredValue(new Decimal(75),
new DicomCodeItem("kV", "UCUM", "kV"))));
containerItem.Add(new DicomContentItem(
GetDcmTypeCodeItem(113736, "Exposure"),
DicomRelationship.Contains,
new DicomMeasuredValue(new Decimal(50),
new DicomCodeItem("uA.s", "UCUM", "uA.s"))));
DicomContentItem IrradiatingDevice = new DicomContentItem(
GetDcmTypeCodeItem(113876, "Device Role in Procedure"),
DicomRelationship.Contains,
GetDcmTypeCodeItem(113859, "Irradiating Device"));
{
IrradiatingDevice.Add(new DicomContentItem(
GetDcmTypeCodeItem(113877, "Device Name"),
DicomRelationship.HasProperties,
DicomValueType.Text,
"DX3605801"));
IrradiatingDevice.Add(new DicomContentItem(
GetDcmTypeCodeItem(113878, "Device Manufacturer"),
DicomRelationship.HasProperties,
DicomValueType.Text,
"Manufacturer"));
IrradiatingDevice.Add(new DicomContentItem(
GetDcmTypeCodeItem(113879, "Device Model Name"),
DicomRelationship.HasProperties,
DicomValueType.Text,
"ManufacturerModelName"));
IrradiatingDevice.Add(new DicomContentItem(
GetDcmTypeCodeItem(113880, "Device Serial Number"),
DicomRelationship.HasProperties,
DicomValueType.Text,
"Unknown"));
IrradiatingDevice.Add(new DicomContentItem(
GetDcmTypeCodeItem(121012, "Device Observer UID"),
DicomRelationship.HasProperties,
DicomUID.Parse(deviceObserverUID)));
}
containerItem.Add(IrradiatingDevice);
sr.Add(containerItem);
}
sr.Add(new DicomContentItem(
GetDcmTypeCodeItem(113854, "Source of Dose Information"),
DicomRelationship.Contains,
GetSrtTypeCodeItem("A-2C090", "Dosimeter")));
DicomFile file = new DicomFile();
file.FileMetaInfo.AddOrUpdate(DicomTag.MediaStorageSOPClassUID, DicomUID.Parse("1.2.840.10008.5.1.4.1.1.88.67"));
file.FileMetaInfo.AddOrUpdate(DicomTag.MediaStorageSOPInstanceUID, DicomUID.Parse("1.2.840.10008.1.2.1"));
file.FileMetaInfo.AddOrUpdate(DicomTag.ImplementationClassUID, "1.2.410.200067.141");
file.FileMetaInfo.AddOrUpdate(DicomTag.SourceApplicationEntityTitle, "Rayence");
file.Dataset.Add(ds);
file.FileMetaInfo.TransferSyntax = DicomTransferSyntax.ImplicitVRLittleEndian;
file.Save("SR.dcm");
System.Diagnostics.Process.Start("SR.dcm");
}
private DicomCStoreRequest GenerateRequest(string patientId, DicomUID studyInstanceUid, DicomUID seriesInstanceUid)
{
var dataset = new DicomDataset();
dataset.Add(DicomTag.PatientID, patientId);
dataset.Add(DicomTag.StudyInstanceUID, studyInstanceUid);
dataset.Add(DicomTag.SeriesInstanceUID, seriesInstanceUid);
dataset.Add(DicomTag.SOPInstanceUID, DicomUIDGenerator.GenerateDerivedFromUUID());
dataset.Add(DicomTag.SOPClassUID, DicomUID.SecondaryCaptureImageStorage.UID);
var file = new DicomFile(dataset);
return(new DicomCStoreRequest(file));
}
public bool Supports(DicomUID ax)
{
return(AbstractSyntaxes.Contains(ax.UID));
}
public DicomNSetRequest(DicomUID requestedClassUid, DicomUID requestedInstanceUid, DicomPriority priority = DicomPriority.Medium) : base(DicomCommandField.NSetRequest, requestedClassUid, priority)
{
SOPInstanceUID = requestedInstanceUid;
}
/// <summary>
/// Initializes new Basic Film Session
/// </summary>
/// <param name="sessionClass">Color or Grayscale Basic Print Management UID</param>
public DcmFilmSession(DicomUID sessionClass)
{
_sessionClass = sessionClass;
_dataset = new DcmDataset(DicomTransferSyntax.ImplicitVRLittleEndian);
_boxes = new List <DcmFilmBox>();
}
/// <summary>
/// Attempt to obtain a unique network identifier, e.g. based on a MAC address.
/// </summary>
/// <param name="identifier">Unique network identifier, if found.</param>
/// <returns>True if network identifier could be obtained, false otherwise.</returns>
public static bool TryGetNetworkIdentifier(out DicomUID identifier)
{
return implementation.TryGetNetworkIdentifierImpl(out identifier);
}
/// <summary>
/// Reads A-ASSOCIATE-AC from PDU buffer
/// </summary>
/// <param name="raw">PDU buffer</param>
public void Read(RawPDU raw)
{
// reset async ops in case remote end does not negotiate
_assoc.MaxAsyncOpsInvoked = 1;
_assoc.MaxAsyncOpsPerformed = 1;
uint l = raw.Length - 6;
ushort c = 0;
raw.ReadUInt16("Version");
raw.SkipBytes("Reserved", 2);
raw.SkipBytes("Reserved", 16);
raw.SkipBytes("Reserved", 16);
raw.SkipBytes("Reserved", 32);
l -= 68;
while (l > 0)
{
byte type = raw.ReadByte("Item-Type");
l -= 1;
if (type == 0x10)
{
// Application Context
raw.SkipBytes("Reserved", 1);
c = raw.ReadUInt16("Item-Length");
raw.SkipBytes("Value", (int)c);
l -= 3 + (uint)c;
}
else if (type == 0x21)
{
// Presentation Context
raw.ReadByte("Reserved");
ushort pl = raw.ReadUInt16("Presentation Context Item-Length");
byte id = raw.ReadByte("Presentation Context ID");
raw.ReadByte("Reserved");
byte res = raw.ReadByte("Presentation Context Result/Reason");
raw.ReadByte("Reserved");
l -= (uint)pl + 3;
pl -= 4;
// Presentation Context Transfer Syntax
raw.ReadByte("Presentation Context Item-Type (0x40)");
raw.ReadByte("Reserved");
ushort tl = raw.ReadUInt16("Presentation Context Item-Length");
string tx = raw.ReadString("Presentation Context Syntax UID", tl);
pl -= (ushort)(tl + 4);
_assoc.PresentationContexts[id].SetResult(
(DicomPresentationContextResult)res,
DicomTransferSyntax.Parse(tx));
}
else if (type == 0x50)
{
// User Information
raw.ReadByte("Reserved");
ushort il = raw.ReadUInt16("User Information Item-Length");
l -= (uint)(il + 3);
while (il > 0)
{
byte ut = raw.ReadByte("User Item-Type");
raw.ReadByte("Reserved");
ushort ul = raw.ReadUInt16("User Item-Length");
il -= (ushort)(ul + 4);
if (ut == 0x51)
{
_assoc.MaximumPDULength = raw.ReadUInt32("Max PDU Length");
}
else if (ut == 0x52)
{
_assoc.RemoteImplemetationClassUID =
DicomUID.Parse(raw.ReadString("Implementation Class UID", ul));
}
else if (ut == 0x53)
{
_assoc.MaxAsyncOpsInvoked = raw.ReadUInt16("Asynchronous Operations Invoked");
_assoc.MaxAsyncOpsPerformed = raw.ReadUInt16("Asynchronous Operations Performed");
}
else if (ut == 0x55)
{
_assoc.RemoteImplementationVersion = raw.ReadString("Implementation Version", ul);
}
else
{
raw.SkipBytes("User Item Value", (int)ul);
}
}
}
else
{
raw.SkipBytes("Reserved", 1);
ushort il = raw.ReadUInt16("User Item-Length");
raw.SkipBytes("Unknown User Item", il);
l -= (uint)(il + 3);
}
}
}
public void Constructor_AffectedSopClassUid_ThrowWhenNotSupported(DicomUID affectedSopClassUid, bool throws)
{
var exception = Record.Exception(() => new DicomCFindRequest(affectedSopClassUid));
Assert.Equal(throws, exception != null);
}
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);
}
private static async Task <(string responseStatus, string responseMessage)> SendMppsCompletedAsync(string serverIP, int serverPort, string serverAET, string clientAET, DicomUID affectedInstanceUid, DicomDataset worklistItem)
{
var client = new DicomClient(serverIP, serverPort, false, clientAET, serverAET);
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();
}
};
await client.AddRequestAsync(dicomFinished);
await client.SendAsync();
return(responseStatus, responseMessage);
}
/// <summary>
/// Add Extended Negotiation with Service Class Application Info
/// </summary>
/// <param name="sopClassUid">SOP Class UID.</param>
/// <param name="applicationInfo">Service Class Application Info.</param>
public void Add(DicomUID sopClassUid, DicomServiceApplicationInfo applicationInfo)
{
Add(new DicomExtendedNegotiation(sopClassUid, applicationInfo));
}
/// <summary>
/// Add (Common) Extended Negotiation with Application Info, Service Class UID and Related General SOP Class UIDs
/// </summary>
/// <param name="sopClassUid">SOP Class UID.</param>
/// <param name="applicationInfo">Service Class Application Info.</param>
/// <param name="serviceClassUid">Common Service Class UID.</param>
/// <param name="relatedGeneralSopClasses">Related General SOP Classes.</param>
public void Add(DicomUID sopClassUid, DicomServiceApplicationInfo applicationInfo, DicomUID serviceClassUid, params DicomUID[] relatedGeneralSopClasses)
{
Add(new DicomExtendedNegotiation(sopClassUid, applicationInfo, serviceClassUid, relatedGeneralSopClasses));
}
/// <summary>
/// Reads A-ASSOCIATE-AC from PDU buffer
/// </summary>
/// <param name="raw">PDU buffer</param>
public void Read(RawPDU raw)
{
uint l = raw.Length;
ushort c = 0;
raw.ReadUInt16("Version");
raw.SkipBytes("Reserved", 2);
raw.SkipBytes("Reserved", 16);
raw.SkipBytes("Reserved", 16);
raw.SkipBytes("Reserved", 32);
l -= 68;
while (l > 0)
{
byte type = raw.ReadByte("Item-Type");
l -= 1;
if (type == 0x10)
{
// Application Context
raw.SkipBytes("Reserved", 1);
c = raw.ReadUInt16("Item-Length");
raw.SkipBytes("Value", (int)c);
l -= 3 + (uint)c;
}
else
if (type == 0x21)
{
// Presentation Context
raw.ReadByte("Reserved");
ushort pl = raw.ReadUInt16("Presentation Context Item-Length");
byte id = raw.ReadByte("Presentation Context ID");
raw.ReadByte("Reserved");
byte res = raw.ReadByte("Presentation Context Result/Reason");
raw.ReadByte("Reserved");
l -= (uint)pl + 3;
pl -= 4;
// Presentation Context Transfer Syntax
raw.ReadByte("Presentation Context Item-Type (0x40)");
raw.ReadByte("Reserved");
ushort tl = raw.ReadUInt16("Presentation Context Item-Length");
string tx = raw.ReadString("Presentation Context Syntax UID", tl);
pl -= (ushort)(tl + 4);
_assoc.SetPresentationContextResult(id, (DcmPresContextResult)res);
_assoc.SetAcceptedTransferSyntax(id, DicomTransferSyntax.Lookup(tx));
}
else
if (type == 0x50)
{
// User Information
raw.ReadByte("Reserved");
ushort il = raw.ReadUInt16("User Information Item-Length");
l -= (uint)(il + 3);
while (il > 0)
{
byte ut = raw.ReadByte("User Item-Type");
raw.ReadByte("Reserved");
ushort ul = raw.ReadUInt16("User Item-Length");
il -= (ushort)(ul + 4);
if (ut == 0x51)
{
_assoc.MaximumPduLength = raw.ReadUInt32("Max PDU Length");
}
else if (ut == 0x52)
{
_assoc.ImplementationClass = DicomUID.Lookup(raw.ReadString("Implementation Class UID", ul));
}
else if (ut == 0x53)
{
_assoc.AsyncOpsInvoked = raw.ReadUInt16("Asynchronous Operations Invoked");
_assoc.AsyncOpsPerformed = raw.ReadUInt16("Asynchronous Operations Performed");
}
else if (ut == 0x55)
{
_assoc.ImplementationVersion = raw.ReadString("Implementation Version", ul);
}
else
{
raw.SkipBytes("User Item Value", (int)ul);
}
}
}
else
{
raw.SkipBytes("Reserved", 1);
ushort il = raw.ReadUInt16("User Item-Length");
raw.SkipBytes("Unknown User Item", il);
l -= (uint)(il + 3);
}
}
}
private static async Task <(DicomUID affectedInstanceUid, string responseStatus, string responseMessage)> SendMppsInProgressAsync(string serverIP, int serverPort, string serverAET, string clientAET, DicomDataset worklistItem)
{
var client = new DicomClient(serverIP, serverPort, false, clientAET, serverAET);
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();
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();
}
};
await client.AddRequestAsync(dicomStartRequest);
await client.SendAsync();
return(effectedinstamceUid, responseStatus, responseMessage);
}
/// <summary>
/// Initialize and add new presentation context.
/// </summary>
/// <param name="abstractSyntax">Abstract syntax of the presentation context.</param>
/// <param name="transferSyntaxes">Supported transfer syntaxes.</param>
public void Add(DicomUID abstractSyntax, params DicomTransferSyntax[] transferSyntaxes)
{
Add(abstractSyntax, null, null, transferSyntaxes);
}
protected override void OnReceiveCStoreRequest(byte presentationID, ushort messageID, DicomUID affectedInstance,
DcmPriority priority, string moveAE, ushort moveMessageID, DcmDataset dataset, string fileName)
{
DcmStatus status = DcmStatus.Success;
if (OnCStoreRequest != null)
{
status = OnCStoreRequest(this, presentationID, messageID, affectedInstance, priority, moveAE, moveMessageID, dataset, fileName);
}
SendCStoreResponse(presentationID, messageID, affectedInstance, status);
}
/// <summary>
/// Attempt to load a volume from the given SeriesUID for the given DicomFolderContents
/// </summary>
/// <param name="dfc">A pre-built description of DICOM contents within a particular folder</param>
/// <param name="seriesUID">The DICOM seriesUID you wish to construct a volume for</param>
/// <param name="acceptanceTests">An implementation of IVolumeGeometricAcceptanceTest defining the geometric constraints of your application</param>
/// <param name="loadStructuresIfExists">True if rt-structures identified in the folder and referencing seriesUID should be loaded</param>
/// <param name="supportLossyCodecs">If you wish to accept lossy encodings of image pixel data</param>
/// <returns></returns>
private static VolumeLoaderResult LoadDicomSeries(
DicomFolderContents dfc, DicomUID seriesUID, IVolumeGeometricAcceptanceTest acceptanceTests, bool loadStructuresIfExists, bool supportLossyCodecs)
{
try
{
var dicomSeriesContent = dfc.Series.FirstOrDefault((s) => s.SeriesUID == seriesUID);
var warnings = new List <string>();
RadiotherapyStruct rtStruct = null;
if (dicomSeriesContent != null)
{
var volumeData = DicomSeriesReader.BuildVolume(dicomSeriesContent.Content.Select(x => x.File.Dataset), acceptanceTests, supportLossyCodecs);
if (volumeData != null && loadStructuresIfExists)
{
var rtStructData = dfc.RTStructs.FirstOrDefault(rt => rt.SeriesUID == seriesUID);
if (rtStructData != null)
{
if (rtStructData.Content.Count == 1)
{
var rtStructAndWarnings = RtStructReader.LoadContours(
rtStructData.Content.First().File.Dataset,
volumeData.Transform.DicomToData,
seriesUID.UID,
null,
false);
rtStruct = rtStructAndWarnings.Item1;
var warning = rtStructAndWarnings.Item2;
if (!string.IsNullOrEmpty(warning))
{
warnings.Add(warning);
}
}
else if (rtStructData.Content.Count > 1)
{
warnings.Add("There is more than 1 RT STRUCT referencing this series - skipping structure set load");
}
}
}
var dicomIdentifiers = dicomSeriesContent.Content.Select((v) => DicomIdentifiers.ReadDicomIdentifiers(v.File.Dataset)).ToArray();
if (rtStruct == null)
{
rtStruct = RadiotherapyStruct.CreateDefault(dicomIdentifiers);
}
var result = new MedicalVolume(
volumeData,
dicomIdentifiers,
dicomSeriesContent.Content.Select((d) => d.Path).ToArray(),
rtStruct);
return(new VolumeLoaderResult(seriesUID.UID, result, null, warnings));
}
throw new Exception("Could not find that series");
}
catch (Exception oops)
{
return(new VolumeLoaderResult(seriesUID.UID, null, oops, new List <string>()));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DicomPresentationContext"/> class.
/// </summary>
/// <param name="pcid">
/// The presentation context ID.
/// </param>
/// <param name="abstractSyntax">
/// The abstract syntax associated with the presentation context.
/// </param>
public DicomPresentationContext(byte pcid, DicomUID abstractSyntax)
: this(pcid, abstractSyntax, null, null)
{
}
/// <summary>
/// Add or update (Common) Extended Negotiation with Application Info, Service Class UID and Related General SOP Class UIDs
/// </summary>
/// <param name="sopClassUid">SOP Class UID.</param>
/// <param name="applicationInfo">Service Class Application Info.</param>
/// <param name="serviceClassUid">Common Service Class UID.</param>
/// <param name="relatedGeneralSopClasses">Related General SOP Classes.</param>
public void AddOrUpdate(DicomUID sopClassUid, DicomServiceApplicationInfo applicationInfo, DicomUID serviceClassUid, params DicomUID[] relatedGeneralSopClasses)
{
if (_ec.TryGetValue(sopClassUid, out var en))
{
en.RequestedApplicationInfo = applicationInfo ?? en.RequestedApplicationInfo;
if (serviceClassUid != null)
{
en.ServiceClassUid = serviceClassUid;
en.RelatedGeneralSopClasses.Clear();
en.RelatedGeneralSopClasses.AddRange(relatedGeneralSopClasses);
}
}
Add(new DicomExtendedNegotiation(sopClassUid, applicationInfo, serviceClassUid, relatedGeneralSopClasses));
}
public DicomReferencedSOP(DicomUID inst, DicomUID clazz)
{
Add(DicomTag.ReferencedSOPInstanceUID, inst);
Add(DicomTag.ReferencedSOPClassUID, clazz);
}
/// <summary>
/// Indicates if specified uid is contained in collection
/// </summary>
/// <param name="item">SOP Class UID to search for.</param>
/// <returns><code>true</code> if <paramref name="item"/> is contained in collection, <code>false</code> otherwise.</returns>
public bool Contains(DicomUID item)
{
return(_ec.ContainsKey(item));
}
internal void SendCStoreRequest(byte pcid, DicomUID instUid, Stream stream)
{
SendCStoreRequest(pcid, NextMessageID(), instUid, Priority, stream);
}
/// <summary> /// Gets the Extended negotiation associated with <paramref name="id"/>. /// </summary> /// <param name="id">SOP Class UID.</param> /// <returns>Extended negotiation associated with <paramref name="id"/></returns> public DicomExtendedNegotiation this[DicomUID id] => _ec[id];
/// <summary>
/// Find image box instance with specified SOP instance UID
/// </summary>
/// <param name="sopInstnace">Target image box SOP instance UID</param>
/// <returns>Target image box instance or null if no matching found</returns>
public ImageBox FindImageBox(DicomUID sopInstnace)
{
foreach (var filmBox in BasicFilmBoxes)
{
var imageBox = filmBox.FindImageBox(sopInstnace);
if (imageBox != null)
{
return imageBox;
}
}
return null;
}
/// <summary>
/// Attempt to obtain a unique network identifier, e.g. based on a MAC address.
/// </summary>
/// <param name="identifier">Unique network identifier, if found.</param>
/// <returns>True if network identifier could be obtained, false otherwise.</returns>
public static bool TryGetNetworkIdentifier(out DicomUID identifier)
{
return(implementation.TryGetNetworkIdentifierImpl(out identifier));
}
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 PresentationLut FindPresentationLut(DicomUID sopInstance)
{
return PresentationLuts.FirstOrDefault(p => p.SopInstanceUid == sopInstance);
}
public PresentationLut CreatePresentationLut(DicomUID sopInstance, DicomDataset dataset)
{
DicomUID uid = sopInstance;
if (uid == null || uid.UID == string.Empty)
{
uid = new DicomUID(
string.Format("{0}.{1}", SOPInstanceUID.UID, BasicFilmBoxes.Count + 1),
SOPInstanceUID.Name,
SOPInstanceUID.Type);
}
var presentationLut = new PresentationLut(uid, dataset);
PresentationLuts.Add(presentationLut);
return presentationLut;
}
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);
}
public void DeletePresentationLut(DicomUID sopInstance)
{
var presentationLut = FindPresentationLut(sopInstance);
if (presentationLut != null)
{
PresentationLuts.Remove(presentationLut);
}
}
public AcceptOnlyEchoStoreProvider(INetworkStream stream, Encoding fallbackEncoding, Logger log,
ILogManager logManager, INetworkManager networkManager, ITranscoderManager transcoderManager) : base(stream, fallbackEncoding, log, logManager, networkManager, transcoderManager)
{
AcceptedSopClasses.Add(DicomUID.Verification);
AcceptedSopClasses.AddRange(DicomUID.Enumerate().Where(u => u.IsImageStorage));
}
/// <summary> /// Platform-specific implementation to attempt to obtain a unique network identifier, e.g. based on a MAC address. /// </summary> /// <param name="identifier">Unique network identifier, if found.</param> /// <returns>True if network identifier could be obtained, false otherwise.</returns> protected abstract bool TryGetNetworkIdentifierImpl(out DicomUID identifier);
/// <summary>
/// Reads A-ASSOCIATE-RQ from PDU buffer
/// </summary>
/// <param name="raw">PDU buffer</param>
public void Read(RawPDU raw)
{
uint l = raw.Length;
raw.ReadUInt16("Version");
raw.SkipBytes("Reserved", 2);
_assoc.CalledAE = raw.ReadString("Called AE", 16);
_assoc.CallingAE = raw.ReadString("Calling AE", 16);
raw.SkipBytes("Reserved", 32);
l -= 2 + 2 + 16 + 16 + 32;
while (l > 0)
{
byte type = raw.ReadByte("Item-Type");
raw.SkipBytes("Reserved", 1);
ushort il = raw.ReadUInt16("Item-Length");
l -= 4 + (uint)il;
if (type == 0x10)
{
// Application Context
raw.SkipBytes("Application Context", il);
}
else
if (type == 0x20)
{
// Presentation Context
byte id = raw.ReadByte("Presentation Context ID");
raw.SkipBytes("Reserved", 3);
il -= 4;
while (il > 0)
{
byte pt = raw.ReadByte("Presentation Context Item-Type");
raw.SkipBytes("Reserved", 1);
ushort pl = raw.ReadUInt16("Presentation Context Item-Length");
string sx = raw.ReadString("Presentation Context Syntax UID", pl);
if (pt == 0x30)
{
_assoc.AddPresentationContext(id, DicomUID.Lookup(sx));
}
else if (pt == 0x40)
{
_assoc.AddTransferSyntax(id, DicomTransferSyntax.Lookup(sx));
}
il -= (ushort)(4 + pl);
}
}
else
if (type == 0x50)
{
// User Information
while (il > 0)
{
byte ut = raw.ReadByte("User Information Item-Type");
raw.SkipBytes("Reserved", 1);
ushort ul = raw.ReadUInt16("User Information Item-Length");
il -= (ushort)(4 + ul);
if (ut == 0x51)
{
_assoc.MaximumPduLength = raw.ReadUInt32("Max PDU Length");
}
else if (ut == 0x52)
{
_assoc.ImplementationClass = new DicomUID(raw.ReadString("Implementation Class UID", ul), "Implementation Class UID", DicomUidType.Unknown);
}
else if (ut == 0x55)
{
_assoc.ImplementationVersion = raw.ReadString("Implementation Version", ul);
}
else if (ut == 0x53)
{
_assoc.AsyncOpsInvoked = raw.ReadUInt16("Asynchronous Operations Invoked");
_assoc.AsyncOpsPerformed = raw.ReadUInt16("Asynchronous Operations Performed");
}
else if (ut == 0x54)
{
raw.SkipBytes("SCU/SCP Role Selection", ul);
/*
* ushort rsul = raw.ReadUInt16();
* if ((rsul + 4) != ul) {
* throw new DicomNetworkException("SCU/SCP role selection length (" + ul + " bytes) does not match uid length (" + rsul + " + 4 bytes)");
* }
* raw.ReadChars(rsul); // Abstract Syntax
* raw.ReadByte(); // SCU role
* raw.ReadByte(); // SCP role
*/
}
else
{
Debug.Log.Error("Unhandled user item: 0x{0:x2} ({1} + 4 bytes)", ut, ul);
raw.SkipBytes("Unhandled User Item", ul);
}
}
}
}
}
