Add MWL & MPPS proxy SCP

Desktop/ProxySCP/App.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2"/>
+    </startup>
+</configuration>

Desktop/ProxySCP/CoreProxySCP.cs

@@ -0,0 +1,102 @@
+using Dicom;
+using Dicom.Log;
+using Dicom.Network;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ProxySCP
+{
+    public abstract class CoreProxySCP : DicomService, IDicomServiceProvider, IDicomCEchoProvider
+    {
+        protected static DicomTransferSyntax[] AcceptedTransferSyntaxes = new DicomTransferSyntax[]
+                                                                            {
+                                                                                    DicomTransferSyntax
+                                                                                        .ExplicitVRLittleEndian,
+                                                                                    DicomTransferSyntax
+                                                                                        .ExplicitVRBigEndian,
+                                                                                    DicomTransferSyntax
+                                                                                        .ImplicitVRLittleEndian
+                                                                            };
+
+        protected static DicomTransferSyntax[] AcceptedImageTransferSyntaxes = new DicomTransferSyntax[]
+                                                                                 {
+                                                                                         // Lossless
+                                                                                         DicomTransferSyntax
+                                                                                             .JPEGLSLossless,
+                                                                                         DicomTransferSyntax
+                                                                                             .JPEG2000Lossless,
+                                                                                         DicomTransferSyntax
+                                                                                             .JPEGProcess14SV1,
+                                                                                         DicomTransferSyntax
+                                                                                             .JPEGProcess14,
+                                                                                         DicomTransferSyntax
+                                                                                             .RLELossless,
+
+                                                                                         // Lossy
+                                                                                         DicomTransferSyntax
+                                                                                             .JPEGLSNearLossless,
+                                                                                         DicomTransferSyntax
+                                                                                             .JPEG2000Lossy,
+                                                                                         DicomTransferSyntax
+                                                                                             .JPEGProcess1,
+                                                                                         DicomTransferSyntax
+                                                                                             .JPEGProcess2_4,
+
+                                                                                         // Uncompressed
+                                                                                         DicomTransferSyntax
+                                                                                             .ExplicitVRLittleEndian,
+                                                                                         DicomTransferSyntax
+                                                                                             .ExplicitVRBigEndian,
+                                                                                         DicomTransferSyntax
+                                                                                             .ImplicitVRLittleEndian
+                                                                                 };
+
+        protected abstract IList<DicomUID> GetSupportedFeatures();
+
+        protected CoreProxySCP(INetworkStream stream, Encoding fallbackEncoding, Logger log) : base(stream, fallbackEncoding, log)
+        {
+        }
+
+        public virtual DicomCEchoResponse OnCEchoRequest(DicomCEchoRequest request)
+        {
+            return new DicomCEchoResponse(request, DicomStatus.Success);
+        }
+
+        public virtual void OnConnectionClosed(Exception exception)
+        {
+        }
+
+        public virtual void OnReceiveAbort(DicomAbortSource source, DicomAbortReason reason)
+        {
+        }
+
+        public virtual void OnReceiveAssociationReleaseRequest()
+        {
+            SendAssociationReleaseResponse();
+        }
+
+        public virtual void OnReceiveAssociationRequest(DicomAssociation association)
+        {
+            //if (association.CalledAE != "STORESCP")
+            //{
+            //    SendAssociationReject(
+            //        DicomRejectResult.Permanent,
+            //        DicomRejectSource.ServiceUser,
+            //        DicomRejectReason.CalledAENotRecognized);
+            //    return;
+            //}
+
+            var supportedFeatures = this.GetSupportedFeatures();
+
+            foreach (var pc in association.PresentationContexts)
+            {
+                if (supportedFeatures.Contains(pc.AbstractSyntax)) pc.AcceptTransferSyntaxes(AcceptedTransferSyntaxes);
+                else if (pc.AbstractSyntax.StorageCategory != DicomStorageCategory.None) pc.AcceptTransferSyntaxes(AcceptedImageTransferSyntaxes);
+            }
+
+            SendAssociationAccept(association);
+        }
+
+    }
+}

Desktop/ProxySCP/MPPSProxySCP.cs

@@ -0,0 +1,108 @@
+using Dicom;
+using Dicom.Log;
+using Dicom.Network;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+
+namespace ProxySCP
+{
+    public class MPPSProxySCP : CoreProxySCP, IDicomNServiceProvider
+    {
+        public MPPSProxySCP(INetworkStream stream, Encoding fallbackEncoding, Logger log) : base(stream, fallbackEncoding, log)
+        {
+        }
+        protected override IList<DicomUID> GetSupportedFeatures()
+        {
+            return new List<DicomUID>() {
+                DicomUID.ModalityPerformedProcedureStepSOPClass
+            };
+        }
+
+        public DicomNActionResponse OnNActionRequest(DicomNActionRequest request)
+        {
+
+            throw new System.NotImplementedException();
+        }
+
+        public DicomNCreateResponse OnNCreateRequest(DicomNCreateRequest request)
+        {
+            var signal = new ManualResetEventSlim(false);
+            DicomNCreateResponse result = null;
+
+            var client = new DicomClient();
+            client.NegotiateAsyncOps();
+
+            var newRequest = CloneNCreateRequest(request);
+            newRequest.OnResponseReceived += (req, response) =>
+            {
+                result = new DicomNCreateResponse(request, response.Status)
+                {
+                    Dataset = response.Dataset
+                };
+
+                signal.Set();
+            };
+            client.AddRequest(newRequest);
+            client.Send("localhost", 108, false, "scu", "scp");
+
+            signal.Wait();
+            return result;
+        }
+        public DicomNSetResponse OnNSetRequest(DicomNSetRequest request)
+        {
+            var signal = new ManualResetEventSlim(false);
+            DicomNSetResponse result = null;
+
+            var client = new DicomClient();
+            client.NegotiateAsyncOps();
+
+            var newRequest = CloneOnNSetRequest(request);
+            newRequest.OnResponseReceived += (req, response) =>
+            {
+                result = new DicomNSetResponse(request, response.Status);
+                result.Dataset = response.Dataset;
+
+                signal.Set();
+            };
+            client.AddRequest(newRequest);
+            client.Send("localhost", 108, false, "scu", "scp");
+
+            signal.Wait();
+            return result;
+        }
+
+        public DicomNDeleteResponse OnNDeleteRequest(DicomNDeleteRequest request)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public DicomNEventReportResponse OnNEventReportRequest(DicomNEventReportRequest request)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public DicomNGetResponse OnNGetRequest(DicomNGetRequest request)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        private DicomNCreateRequest CloneNCreateRequest(DicomNCreateRequest req)
+        {
+            var request = new DicomNCreateRequest(req.Command);
+            request.Dataset = req.Dataset;
+
+            return request;
+        }
+
+        private DicomNSetRequest CloneOnNSetRequest(DicomNSetRequest req)
+        {
+            var request = new DicomNSetRequest(req.Command)
+            {
+                Dataset = req.Dataset
+            };
+
+            return request;
+        }
+    }
+}

Desktop/ProxySCP/MWLProxySCP.cs

@@ -0,0 +1,64 @@
+using Dicom;
+using Dicom.Log;
+using Dicom.Network;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+
+namespace ProxySCP
+{
+    public class MWLProxySCP : CoreProxySCP, IDicomCFindProvider
+    {
+        public MWLProxySCP(INetworkStream stream, Encoding fallbackEncoding, Logger log)
+                : base(stream, fallbackEncoding, log)
+            {
+        }
+
+        protected override IList<DicomUID> GetSupportedFeatures()
+        {
+            return new List<DicomUID>() {
+                DicomUID.ModalityWorklistInformationModelFIND
+            };
+        }
+
+        IEnumerable<DicomCFindResponse> IDicomCFindProvider.OnCFindRequest(DicomCFindRequest request)
+        {
+            var signal = new ManualResetEventSlim(false);
+
+            var worklist = new List<DicomCFindResponse>();
+
+            var client = new DicomClient();
+            client.NegotiateAsyncOps();
+
+            var newRequest = CloneRequest(request);
+            newRequest.OnResponseReceived += (req, response) =>
+            {
+                var result = new DicomCFindResponse(request, response.Status)
+                {
+                    Dataset = response.Dataset
+                };
+                worklist.Add(result);
+
+                if (response.Status != DicomStatus.Pending)
+                {
+                    signal.Set();
+                }
+            };
+            client.AddRequest(newRequest);
+            client.Send("localhost", 107, false, "scu", "scp");
+
+            signal.Wait();
+            return worklist;
+        }
+
+        private DicomCFindRequest CloneRequest(DicomCFindRequest req)
+        {
+            var request = new DicomCFindRequest(req.Command)
+            {
+                Dataset = req.Dataset
+            };
+
+            return request;
+        }
+    }
+}

Desktop/ProxySCP/Program.cs

@@ -0,0 +1,25 @@
+using Dicom;
+using Dicom.Network;
+using System;
+
+namespace ProxySCP
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            // preload dictionary to prevent timeouts
+            var dict = DicomDictionary.Default;
+
+
+            // start DICOM server
+            var serverMWL = DicomServer.Create<MWLProxySCP>(9107);      // host on 9107, forward request to 107
+            var serverMPPS = DicomServer.Create<MPPSProxySCP>(9108);    // host on 9108, forward request to 108
+            Console.WriteLine("MWL & MPPS Proxy started.");
+
+            // end process
+            Console.WriteLine("Press <return> to end...");
+            Console.ReadLine();
+        }
+    }
+}

Desktop/ProxySCP/Properties/AssemblyInfo.cs

@@ -0,0 +1,18 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("ProxySCP")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("7143700b-2391-4643-9ccc-b19f24e2ca2d")]