←Select platform

GetCommandSet Method

Summary

Returns a DicomDataSet containing the Command Set portion of a DIMSE DICOM message.

Syntax
C#
C++
public DicomDataSet GetCommandSet() 
vb[VB Syntax] 
Public Function GetCommandSet() As DicomDataSet 
public:  
   DicomDataSet^ GetCommandSet() 

Return Value

A DicomDataSet containing the Command Set portion of a DIMSE DICOM message.

Remarks

This method returns a DicomDataSet containing the Command Set portion of a DIMSE DICOM message.

The Command Set contains a Status (0000,0900) element. If the Status does not contain a DicomCommandStatusType.Success, then the Command Set may contain other status-related elements.

The example shows how to easily retrieve the status-related elements, and generate a friendly-string showing this information.

Call this method in any of the DicomNet OnReceiveXxxxResponse DIMSE messages including:

Example

This example shows how to override the OnReceiveCStoreResponse callback. In the example, the OnReceiveCStoreResponse callback gets the command set and displays the values all status related elements.

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

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