←Select platform

OnReceive Method

Summary
Notifies a connection that data was received.
Syntax
C#
Objective-C
C++
protected virtual void OnReceive( 
   DicomExceptionCode error, 
   DicomPduType pduType, 
   IntPtr buffer, 
   int bytes 
) 
- (void)onReceive:(LTDicomErrorCode)error pduType:(LTDicomPduType)pduType buffer:(const void *)buffer length:(NSUInteger)length; 
protected: 
virtual void OnReceive(  
   DicomExceptionCode error, 
   DicomPduType pduType, 
   IntPtr buffer, 
   int bytes 
)  

Parameters

error
An error code.

pduType
The type of data that was sent.

buffer
Pointer to a buffer that contains all the data that was sent. This includes the Command Set and any associated Data Set.

bytes
The number of bytes of the data specified by buffer.

Remarks

This is a low level means of receiving DICOM messages and data. It allows you to process messages yourself, instead of using the high level message processing methods provided. This method is generated for each DicomNet.SendXXX method provided by LEADTOOLS.

Example

This is a comprehensive sample that shows how to process a DICOM C-Store operation on both the SCP (server) and the SCU (client) sides.

C#
using Leadtools.Dicom; 
 
using Leadtools.Dicom.Common.DataTypes.Status; 
using Leadtools.Dicom.Common.Extensions; 
 
[StructLayout(LayoutKind.Sequential)] 
public struct MSG 
{ 
   public IntPtr hwnd; 
   public uint message; 
   public IntPtr wParam; 
   public IntPtr lParam; 
   public uint time; 
   public System.Drawing.Point p; 
} 
 
public enum WaitReturn 
{ 
   Complete, 
   Timeout, 
} 
 
class Utils 
{ 
   [DllImport("user32.dll")] 
   [return: MarshalAs(UnmanagedType.Bool)] 
   static extern bool PeekMessage(out MSG lpMsg, IntPtr hWnd, 
                                  uint wMsgFilterMin, uint wMsgFilterMax, 
                                  uint wRemoveMsg); 
 
   [DllImport("user32.dll")] 
   static extern bool TranslateMessage([In] ref MSG lpMsg); 
   [DllImport("user32.dll")] 
   static extern IntPtr DispatchMessage([In] ref MSG lpmsg); 
 
   const uint PM_REMOVE = 1; 
 
   public static WaitReturn WaitForComplete(double mill, WaitHandle wh) 
   { 
      TimeSpan goal = new TimeSpan(DateTime.Now.AddMilliseconds(mill).Ticks); 
 
      do 
      { 
         MSG msg = new MSG(); 
 
         if (PeekMessage(out msg, IntPtr.Zero, 0, 0, PM_REMOVE)) 
         { 
            TranslateMessage(ref msg); 
            DispatchMessage(ref msg); 
         } 
 
         if (wh.WaitOne(new TimeSpan(0, 0, 0), false)) 
         { 
            return WaitReturn.Complete; 
         } 
 
         if (goal.CompareTo(new TimeSpan(DateTime.Now.Ticks)) < 0) 
         { 
            return WaitReturn.Timeout; 
         } 
 
      } while (true); 
   } 
} 
 
class Client : DicomNet 
{ 
   DicomExceptionCode _LastError = DicomExceptionCode.Success; 
   AutoResetEvent waitEvent = new AutoResetEvent(false); 
 
   public Client() 
       : base(null, DicomNetSecurityMode.None) 
   { 
   } 
 
   public DicomExceptionCode LastError 
   { 
      get 
      { 
         return _LastError; 
      } 
   } 
 
   public bool Wait() 
   { 
      WaitReturn ret; 
 
      _LastError = DicomExceptionCode.Success; 
      ret = Utils.WaitForComplete((5 * 60) * 1000, waitEvent); 
 
      return (ret == WaitReturn.Complete); 
   } 
 
   protected override void OnConnect(DicomExceptionCode error) 
   { 
      _LastError = error; 
      waitEvent.Set(); 
   } 
 
   protected override void OnReceiveAssociateAccept(DicomAssociate association) 
   { 
      waitEvent.Set(); 
   } 
 
   protected override void OnReceiveCStoreResponse(byte presentationID, int messageID, string affectedClass, string instance, DicomCommandStatusType status) 
   { 
      Debug.Assert(status == DicomCommandStatusType.Success, "Status should be success"); 
 
      DicomDataSet cs = this.GetCommandSet(); 
      string statusAllString = string.Empty; 
 
      if (cs != null) 
      { 
         StatusAll statusAll = cs.Get<StatusAll>(); 
         if (statusAll != null) 
         { 
            StatusFormatFlags flags = StatusFormatFlags.None; 
            statusAllString = statusAll.ToString(flags, "\n\t", "\t"); 
 
            // Print the friendly-string showing status-related elements 
            Debug.WriteLine(statusAllString); 
         } 
      } 
 
      waitEvent.Set(); 
   } 
 
   protected override void OnReceive(DicomExceptionCode error, DicomPduType pduType, IntPtr buffer, int bytes) 
   { 
      base.OnReceive(error, pduType, buffer, bytes); 
   } 
 
   protected override void OnSend(DicomExceptionCode error, DicomPduType type, int length) 
   { 
      base.OnSend(error, type, length); 
   } 
} 
 
class ServerConnection : DicomNet 
{ 
   public ServerConnection() 
       : base(null, DicomNetSecurityMode.None) 
   { 
   } 
 
   protected override void OnReceiveAssociateRequest(DicomAssociate association) 
   { 
      DicomAssociate retAssociation = new DicomAssociate(false); 
 
      Debug.Assert(association.Called == "ServerTest", "Called AETitle should be ServerTest"); 
      Debug.Assert(association.Calling == "ClientTest", "Calling AETitle should be ClientTest"); 
      Debug.Assert(association.ImplementClass == "1.2.840.114257.1", "Implementation class should be 1.2.840.114257.1"); 
      Debug.Assert(association.ImplementationVersionName == "1", "Implementation version should be 1"); 
      Debug.Assert(association.MaxLength == 0x100000, "Max length should be 0x100000"); 
      Debug.Assert(association.GetAbstract(1) == DicomUidType.VerificationClass, "Presentation index 1 should be " + DicomUidType.VerificationClass); 
      Debug.Assert(association.GetTransfer(1, 0) == DicomUidType.ImplicitVRLittleEndian, "Abstract Syntax (1,0) should be " + DicomUidType.ImplicitVRLittleEndian); 
 
      // 
      // Build our Association Accept 
      // 
      retAssociation.Called = association.Called; 
      retAssociation.Calling = association.Calling; 
      retAssociation.ImplementClass = association.ImplementClass; 
      retAssociation.ImplementationVersionName = association.ImplementationVersionName; 
      for (int x = 0; x < association.PresentationContextCount; x++) 
      { 
         byte id = association.GetPresentationContextID(x); 
         string abSyntax = association.GetAbstract(id); 
         string trSyntax = DicomUidType.ImplicitVRLittleEndian; 
 
         retAssociation.AddPresentationContext(id, 0, abSyntax); 
         if (association.GetTransferCount(id) > 0) 
         { 
            trSyntax = association.GetTransfer(id, 0); 
         } 
 
         retAssociation.AddTransfer(id, trSyntax); 
      } 
      SendAssociateAccept(retAssociation); 
   } 
 
   protected override void OnReceiveCStoreRequest(byte presentationID, int messageID, string affectedClass, string instance, DicomCommandPriorityType priority, string moveAE, int moveMessageID, DicomDataSet dataSet) 
   { 
      byte id = Association.FindAbstract(affectedClass); 
 
      Debug.Assert(id == presentationID, "PresentationID is invalid"); 
      Debug.Assert(messageID == 2, "Invalid message id.  Should be 2"); 
      Debug.Assert(dataSet != null, "Dataset should not be null"); 
      Debug.Assert(moveAE == "NONE", "Move AE should be NONE"); 
      Debug.Assert(moveMessageID == 1, "Move message id should be 1"); 
      Debug.Assert(priority == DicomCommandPriorityType.Medium, "Priority should be medium"); 
 
      SendCStoreResponse(presentationID, messageID, affectedClass, instance, DicomCommandStatusType.Success); 
   } 
} 
 
class Server : DicomNet 
{ 
   ServerConnection client; 
 
   public Server() 
       : base(null, DicomNetSecurityMode.None) 
   { 
   } 
 
   protected override void OnAccept(DicomExceptionCode error) 
   { 
      client = new ServerConnection(); 
 
      Accept(client); 
   } 
} 
 
public void SendCStoreRequestSample() 
{ 
   DicomEngine.Startup(); 
   DicomNet.Startup(); 
 
   using (Server server = new Server()) 
   { 
      using (Client client = new Client()) 
      { 
         string storageClass = ""; 
         string storageInstance = "998.998.1.1.19950214.94000.1.102"; 
         DicomDataSet ds = new DicomDataSet(); 
         DicomElement element; 
         string transferSyntax = DicomUidType.JPEGLosslessNonhier14; 
         string dicomFileName = Path.Combine(LEAD_VARS.ImagesDir, "DICOM","image3.dcm"); 
 
         // 
         // Connect to server 
         // 
         server.Listen("127.0.0.1", 104, 1); // start server 
         client.Connect(null, 1000, "127.0.0.1", 104); // connect to server 
         if (!client.Wait()) // wait for connection to finish 
         { 
            Debug.Fail("Connection timed out"); 
         } 
         Debug.Assert(client.LastError == DicomExceptionCode.Success, "Connection failed"); 
         Debug.Assert(client.IsConnected(), "Client not connected"); 
 
         ds.Load(dicomFileName, DicomDataSetLoadFlags.LoadAndClose); 
         element = ds.FindFirstElement(null, DicomTag.MediaStorageSOPClassUID, true); 
         if (element != null) 
         { 
            storageClass = ds.GetStringValue(element, 0); 
         } 
 
         if (storageClass.Length == 0) 
         { 
            element = ds.FindFirstElement(null, DicomTag.SOPInstanceUID, true); 
            if (element != null) 
            { 
               storageClass = ds.GetStringValue(element, 0); 
            } 
         } 
 
         if (storageClass.Length == 0) 
            storageClass = "1.1.1.1"; 
 
         // 
         // Get Image transfer syntax 
         // 
         element = ds.FindFirstElement(null, DicomTag.TransferSyntaxUID, true); 
         if (element != null) 
         { 
            transferSyntax = ds.GetStringValue(element, 0); 
         } 
 
         element = ds.FindFirstElement(null, DicomTag.SOPInstanceUID, true); 
         if (element != null) 
         { 
            storageInstance = ds.GetStringValue(element, 0); 
         } 
 
         // 
         // Send associate request 
         // 
         DicomAssociate associate = new DicomAssociate(true); 
 
         associate.Called = "ServerTest"; 
         associate.Calling = "ClientTest"; 
         associate.ImplementClass = "1.2.840.114257.1"; 
         associate.ImplementationVersionName = "1"; 
         associate.MaxLength = 0x100000; 
         associate.AddPresentationContext(1, 0, DicomUidType.VerificationClass); 
         associate.AddTransfer(1, DicomUidType.ImplicitVRLittleEndian); 
         associate.AddPresentationContext(3, 0, storageClass); 
         associate.AddTransfer(3, transferSyntax); 
         client.SendAssociateRequest(associate); 
         if (!client.Wait()) // wait for connection to finish 
         { 
            Debug.Fail("SendAssociateRequest timed out"); 
         } 
 
         // 
         // Send Echo Request 
         // 
         byte pid = client.Association.FindAbstract(storageClass); 
 
         client.SendCStoreRequest(pid, 2, storageClass, storageInstance, 
                                  DicomCommandPriorityType.Medium, "NONE", 1, ds); 
         if (!client.Wait()) // wait for connection to finish 
         { 
            Debug.Fail("SendCStoreRequest timed out"); 
         } 
 
         client.CloseForced(true); 
      } 
      server.CloseForced(true); 
   } 
 
   DicomEngine.Shutdown(); 
   DicomNet.Shutdown(); 
} 
 
static class LEAD_VARS 
{ 
   public const string ImagesDir = @"C:\LEADTOOLS22\Resources\Images"; 
} 
Requirements

Target Platforms

See Also

Reference

DicomNet Class

DicomNet Members

Help Version 22.0.2022.4.4
Products | Support | Contact Us | Intellectual Property Notices
© 1991-2022 LEAD Technologies, Inc. All Rights Reserved.

Leadtools.Dicom Assembly