Merge branch 'dah' of github.com:commontk/CTK into dah

Conflicts:
	Plugins/org.commontk.dah.app/ctkDicomAbstractApp.cpp
	Plugins/org.commontk.dah.app/ctkDicomAbstractApp.h
	Plugins/org.commontk.dah.host/ctkDicomAbstractHost.cpp
	Plugins/org.commontk.dah.host/ctkDicomAbstractHost.h

Plugins/org.commontk.dah.app/ctkDicomAbstractApp.cpp

@@ -22,6 +22,7 @@
 // CTK includes
 #include "ctkDicomAbstractApp.h"
 #include <ctkDicomHostInterface.h>
+#include <ctkDicomObjectLocatorCache.h>
 #include <ctkPluginContext.h>
 #include <ctkServiceTracker.h>
 #include <ctkDicomAppHostingTypesHelper.h>
@@ -30,10 +31,11 @@ class ctkDicomAbstractAppPrivate
 {
 public:
   ctkDicomAbstractAppPrivate(ctkPluginContext* context);
-  ~ctkDicomAbstractAppPrivate();
 
   ctkServiceTracker<ctkDicomHostInterface*> HostTracker;
   ctkDicomAppHosting::State currentState;
+
+  ctkDicomObjectLocatorCache ObjectLocatorCache;
 };
 
 //----------------------------------------------------------------------------
@@ -46,11 +48,6 @@ ctkDicomAbstractAppPrivate::ctkDicomAbstractAppPrivate(ctkPluginContext * contex
 }
 
 //----------------------------------------------------------------------------
-ctkDicomAbstractAppPrivate::~ctkDicomAbstractAppPrivate()
-{
-}
-
-//----------------------------------------------------------------------------
 // ctkDicomAbstractApp methods
 
 //----------------------------------------------------------------------------
@@ -156,4 +153,33 @@ void ctkDicomAbstractApp::setInternalState(ctkDicomAppHosting::State state)
   d_ptr->currentState = state;
 }
 
+//----------------------------------------------------------------------------
+QList<ctkDicomAppHosting::ObjectLocator> ctkDicomAbstractApp::getData(
+  const QList<QUuid>& objectUUIDs,
+  const QList<QString>& acceptableTransferSyntaxUIDs,
+  bool includeBulkData)
+{
+  return this->objectLocatorCache()->getData(objectUUIDs, acceptableTransferSyntaxUIDs, includeBulkData);
+}
 
+//----------------------------------------------------------------------------
+ctkDicomObjectLocatorCache* ctkDicomAbstractApp::objectLocatorCache()const
+{
+  Q_D(const ctkDicomAbstractApp);
+  return const_cast<ctkDicomObjectLocatorCache*>(&d->ObjectLocatorCache);
+}
+
+//----------------------------------------------------------------------------
+bool ctkDicomAbstractApp::publishData(const ctkDicomAppHosting::AvailableData& availableData, bool lastData)
+{
+  if (!this->objectLocatorCache()->isCached(availableData))
+    {
+    return false;
+    }
+  bool success = this->getHostInterface()->notifyDataAvailable(availableData, lastData);
+  if(!success)
+    {
+    return false;
+    }
+  return true;
+}

Plugins/org.commontk.dah.app/ctkDicomAbstractApp.h

@@ -29,6 +29,8 @@
 class ctkDicomAbstractAppPrivate;
 class ctkDicomHostInterface;
 class ctkPluginContext;
+class ctkDicomObjectLocatorCache;
+
 /**
   * Provides a basic implementation for an application app.
   *
@@ -46,8 +48,22 @@ public:
 
   ctkDicomAbstractApp(ctkPluginContext* context);
   virtual ~ctkDicomAbstractApp();
+
+  /**
+    * Method triggered by the host. Changes the state of the hosted application.
+    * @return true if state received and not illegal in the transition diagram from the reference, false if illegal or not recognized.
+    */
   virtual bool setState(ctkDicomAppHosting::State newState);
   virtual ctkDicomAppHosting::State getState();
+  virtual QList<ctkDicomAppHosting::ObjectLocator> getData(
+    const QList<QUuid>& objectUUIDs,
+    const QList<QString>& acceptableTransferSyntaxUIDs,
+    bool includeBulkData);
+
+  ctkDicomObjectLocatorCache* objectLocatorCache()const;
+
+  bool publishData(const ctkDicomAppHosting::AvailableData& availableData, bool lastData);
+
 protected:
   virtual ctkDicomHostInterface* getHostInterface() const;
  void setInternalState(ctkDicomAppHosting::State state);

Plugins/org.commontk.dah.core/CMakeLists.txt

@@ -11,6 +11,7 @@ SET(PLUGIN_SRCS
   ctkDicomExchangeInterface.h
   ctkDicomExchangeService.cpp
   ctkDicomHostInterface.h
+  ctkDicomObjectLocatorCache.cpp
   ctkExchangeSoapMessageProcessor.cpp
   ctkSimpleSoapClient.cpp
   ctkSimpleSoapServer.cpp

Plugins/org.commontk.dah.core/ctkDicomAppHostingTypesHelper.cpp

@@ -194,12 +194,12 @@ ctkDicomSoapArrayOfStringType::ctkDicomSoapArrayOfStringType(const QString& type
 }
 
 //----------------------------------------------------------------------------
-QStringList ctkDicomSoapArrayOfStringType::getArray(const QtSoapType& array)
+QStringList ctkDicomSoapArrayOfStringType::getArray(const QtSoapType& type)
 {
   QStringList list;
-  for (int i = 0; i < array.count() ; i++)
+  for (int i = 0; i < type.count() ; i++)
     {
-    const QString str = array[i].value().toString();
+    const QString str = type[i].value().toString();
     list << str;
     }
   return list;
@@ -241,12 +241,12 @@ ctkDicomSoapArrayOfUUIDS::ctkDicomSoapArrayOfUUIDS(const QString& name, const QL
 }
 
 //----------------------------------------------------------------------------
-QList<QUuid> ctkDicomSoapArrayOfUUIDS::getArray(const QtSoapType& array)
+QList<QUuid> ctkDicomSoapArrayOfUUIDS::getArray(const QtSoapType& type)
 {
   QList<QUuid> list;
-  for (int i = 0; i < array.count(); i++)
+  for (int i = 0; i < type.count(); i++)
     {
-    list << QUuid(array[i].value().toString());
+    list << QUuid(type[i].value().toString());
     }
   return list;
 }
@@ -346,14 +346,9 @@ ctkDicomSoapSeries::ctkDicomSoapSeries(const QString& name,
 ctkDicomAppHosting::Series ctkDicomSoapSeries::getSeries(const QtSoapType& type)
 {
   ctkDicomAppHosting::Series s;
-  const QtSoapType* ttype = &type;
-  if(type.name().name()=="item")
-    {
-    ttype = &(type["item"]);
-    }
 
-  s.seriesUID = (*ttype)["seriesUID"].value().toString();
-  s.objectDescriptors = ctkDicomSoapArrayOfObjectDescriptors::getArrayOfObjectDescriptors((*ttype)["objectDescriptors"]);
+  s.seriesUID = type["seriesUID"].value().toString();
+  s.objectDescriptors = ctkDicomSoapArrayOfObjectDescriptors::getArrayOfObjectDescriptors(type["objectDescriptors"]);
   return s;
 }
 
@@ -389,18 +384,12 @@ ctkDicomSoapStudy::ctkDicomSoapStudy(const QString& name,
 ctkDicomAppHosting::Study ctkDicomSoapStudy::getStudy(const QtSoapType& type)
 {
   ctkDicomAppHosting::Study s;
-
-  const QtSoapType* ttype = &type;
-  if(type.name().name() == "item")
-    {
-    ttype = &(type["item"]);
-    }
-
-  s.studyUID = (*ttype)["StudyUID"].value().toString();
-  s.objectDescriptors = ctkDicomSoapArrayOfObjectDescriptors::getArrayOfObjectDescriptors((*ttype)["objectDescriptors"]);
+ 
+  s.studyUID = type["StudyUID"].value().toString();
+  s.objectDescriptors = ctkDicomSoapArrayOfObjectDescriptors::getArrayOfObjectDescriptors(type["objectDescriptors"]);
 
   QList<ctkDicomAppHosting::Series> listSeries;
-  const QtSoapType& seriesArray = (*ttype)["Series"];
+  const QtSoapType& seriesArray = type["Series"];
   for (int i = 0; i < seriesArray.count() ; i++)
     {
     const ctkDicomAppHosting::Series series =
@@ -451,24 +440,18 @@ ctkDicomSoapPatient::ctkDicomSoapPatient(const QString& name,
 //----------------------------------------------------------------------------
 ctkDicomAppHosting::Patient ctkDicomSoapPatient::getPatient(const QtSoapType& type)
 {
-  const QtSoapType* ttype = &type;
-  if(type.name().name() == "item")
-    {
-    ttype = &(type["item"]);
-    }
-
   ctkDicomAppHosting::Patient p;
 
-  p.name = (*ttype)["Name"].value().toString();
-  p.id = (*ttype)["ID"].value().toString();
-  p.assigningAuthority = (*ttype)["AssigningAuthority"].value().toString();
-  p.sex = (*ttype)["Sex"].value().toString();
-  p.birthDate = (*ttype)["Birthdate"].value().toString();
+  p.name = type["Name"].value().toString();
+  p.id = type["ID"].value().toString();
+  p.assigningAuthority = type["AssigningAuthority"].value().toString();
+  p.sex = type["Sex"].value().toString();
+  p.birthDate = type["Birthdate"].value().toString();
 
-  p.objectDescriptors = ctkDicomSoapArrayOfObjectDescriptors::getArrayOfObjectDescriptors((*ttype)["objectDescriptors"]);
+  p.objectDescriptors = ctkDicomSoapArrayOfObjectDescriptors::getArrayOfObjectDescriptors(type["objectDescriptors"]);
 
   QList<ctkDicomAppHosting::Study> listPatient;
-  const QtSoapType& studiesArray = (*ttype)["Studies"];
+  const QtSoapType& studiesArray = type["Studies"];
   for (int i = 0; i < studiesArray.count() ; i++)
     {
     const ctkDicomAppHosting::Study study =
@@ -595,14 +578,14 @@ ctkDicomSoapArrayOfObjectLocators::ctkDicomSoapArrayOfObjectLocators(
 }
 
 //----------------------------------------------------------------------------
-QList<ctkDicomAppHosting::ObjectLocator> ctkDicomSoapArrayOfObjectLocators::getArray(const QtSoapType& array)
+QList<ctkDicomAppHosting::ObjectLocator> ctkDicomSoapArrayOfObjectLocators::getArray(const QtSoapType& type)
 {
   QList<ctkDicomAppHosting::ObjectLocator> list;
 
-  for (int i = 0; i < array.count(); i++)
+  for (int i = 0; i < type.count(); i++)
     {
     const ctkDicomAppHosting::ObjectLocator ol =
-        ctkDicomSoapObjectLocator::getObjectLocator(array[i]);
+        ctkDicomSoapObjectLocator::getObjectLocator(type[i]);
     list << ol;
     }
   return list;

Plugins/org.commontk.dah.core/ctkDicomExchangeInterface.h

@@ -25,10 +25,10 @@
 
 #include <QRect>
 #include <QObject>
-#include <QUuid>
-
 #include "ctkDicomAppHostingTypes.h"
 
+class QUuid;
+
 struct ctkDicomExchangeInterface
 {
 

Plugins/org.commontk.dah.core/ctkDicomObjectLocatorCache.cpp

@@ -0,0 +1,167 @@
+/*=========================================================================
+
+  Library:   CTK
+
+  Copyright (c) Kitware Inc.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.commontk.org/LICENSE
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+=========================================================================*/
+
+// Qt includes
+#include <QHash>
+#include <QUuid>
+
+// CTK includes
+#include "ctkDicomAppHostingTypes.h"
+#include "ctkDicomObjectLocatorCache.h"
+
+class ctkDicomObjectLocatorCachePrivate
+{
+public:
+  ctkDicomObjectLocatorCachePrivate();
+
+  QHash<QString, ctkDicomAppHosting::ObjectLocator> ObjectLocatorMap;
+};
+
+//----------------------------------------------------------------------------
+// ctkDicomObjectLocatorCachePrivate methods
+
+//----------------------------------------------------------------------------
+ctkDicomObjectLocatorCachePrivate::ctkDicomObjectLocatorCachePrivate()
+{
+}
+
+//----------------------------------------------------------------------------
+// ctkDicomObjectLocatorCache methods
+
+//----------------------------------------------------------------------------
+ctkDicomObjectLocatorCache::ctkDicomObjectLocatorCache() : d_ptr(new ctkDicomObjectLocatorCachePrivate())
+{
+}
+
+//----------------------------------------------------------------------------
+ctkDicomObjectLocatorCache::~ctkDicomObjectLocatorCache()
+{
+}
+
+//----------------------------------------------------------------------------
+bool ctkDicomObjectLocatorCache::isCached(const ctkDicomAppHosting::AvailableData& availableData)const
+{
+  Q_D(const ctkDicomObjectLocatorCache);
+  QList<QString> uuids = d->ObjectLocatorMap.keys();
+  // Loop over top level object descriptors
+  foreach(const ctkDicomAppHosting::ObjectDescriptor& objectDescriptor, availableData.objectDescriptors)
+    {
+    if (!uuids.contains(objectDescriptor.descriptorUUID))
+      {
+      return false;
+      }
+    }
+  // Loop over patients
+  foreach(const ctkDicomAppHosting::Patient& patient, availableData.patients)
+    {
+    // Loop over patient level object descriptors
+    foreach(const ctkDicomAppHosting::ObjectDescriptor& objectDescriptor, patient.objectDescriptors)
+      {
+      if (!uuids.contains(objectDescriptor.descriptorUUID))
+        {
+        return false;
+        }
+      }
+    // Loop over studies
+    foreach(const ctkDicomAppHosting::Study& study, patient.studies)
+      {
+      // Loop over study level object descriptors
+      foreach(const ctkDicomAppHosting::ObjectDescriptor& objectDescriptor, study.objectDescriptors)
+        {
+        if (!uuids.contains(objectDescriptor.descriptorUUID))
+          {
+          return false;
+          }
+        }
+      // Loop over series
+      foreach(const ctkDicomAppHosting::Series& series, study.series)
+        {
+        // Loop over series level object descriptors
+        foreach(const ctkDicomAppHosting::ObjectDescriptor& objectDescriptor, series.objectDescriptors)
+          {
+          if (!uuids.contains(objectDescriptor.descriptorUUID))
+            {
+            return false;
+            }
+          }
+        }
+      }
+    }
+}
+
+//----------------------------------------------------------------------------
+bool ctkDicomObjectLocatorCache::find(const QString& objectUuid,
+                                         ctkDicomAppHosting::ObjectLocator& objectLocator)const
+{
+  Q_D(const ctkDicomObjectLocatorCache);
+  if (!d->ObjectLocatorMap.contains(objectUuid))
+    {
+    return false;
+    }
+  objectLocator = d->ObjectLocatorMap.value(objectUuid);
+  return true;
+}
+
+//----------------------------------------------------------------------------
+void ctkDicomObjectLocatorCache::insert(const QString& objectUuid,
+                                        const ctkDicomAppHosting::ObjectLocator& objectLocator)
+{
+  Q_D(ctkDicomObjectLocatorCache);
+  if(d->ObjectLocatorMap.contains(objectUuid))
+    {
+    return;
+    }
+  d->ObjectLocatorMap.insert(objectUuid, objectLocator);
+}
+
+//----------------------------------------------------------------------------
+bool ctkDicomObjectLocatorCache::remove(const QString& objectUuid)
+{
+  Q_D(ctkDicomObjectLocatorCache);
+  int removed = d->ObjectLocatorMap.remove(objectUuid);
+  Q_ASSERT(removed > 1);
+  return (removed == 1);
+}
+
+//----------------------------------------------------------------------------
+QList<ctkDicomAppHosting::ObjectLocator> ctkDicomObjectLocatorCache::getData(
+  const QList<QUuid>& objectUUIDs,
+  const QList<QString>& acceptableTransferSyntaxUIDs,
+  bool includeBulkData)
+{
+  QList<ctkDicomAppHosting::ObjectLocator> objectLocators;
+  foreach(const QUuid& uuid, objectUUIDs)
+    {
+    ctkDicomAppHosting::ObjectLocator objectLocator;
+    bool found = this->find(uuid, objectLocator);
+    if (!found)
+      {
+      // What to do .. ? Create an empty objectLocator ...
+      continue;
+      }
+    if (includeBulkData)
+      {
+      Q_UNUSED(acceptableTransferSyntaxUIDs);
+      // Not implemented
+      }
+    objectLocators << objectLocator;
+    }
+  return objectLocators;
+}

Plugins/org.commontk.dah.core/ctkDicomObjectLocatorCache.h

@@ -0,0 +1,63 @@
+/*=========================================================================
+
+  Library:   CTK
+
+  Copyright (c) Kitware Inc.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.commontk.org/LICENSE
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+=========================================================================*/
+
+#ifndef CTKDICOMEXCHANGEIMPL_H
+#define CTKDICOMEXCHANGEIMPL_H
+
+// Qt includes
+#include <QScopedPointer>
+
+// CTK includes
+#include "ctkDicomAppHostingTypes.h"
+#include <org_commontk_dah_core_Export.h>
+
+class ctkDicomObjectLocatorCachePrivate;
+class QUuid;
+
+/**
+  *
+  */
+class org_commontk_dah_core_EXPORT ctkDicomObjectLocatorCache
+{
+
+public:
+
+  ctkDicomObjectLocatorCache();
+  virtual ~ctkDicomObjectLocatorCache();
+
+  bool isCached(const ctkDicomAppHosting::AvailableData& availableData)const;
+
+  bool find(const QString& objectUuid, ctkDicomAppHosting::ObjectLocator& objectLocator)const;
+
+  void insert(const QString& objectUuid, const ctkDicomAppHosting::ObjectLocator& objectLocator);
+
+  bool remove(const QString& objectUuid);
+
+  QList<ctkDicomAppHosting::ObjectLocator> getData(
+    const QList<QUuid>& objectUUIDs,
+    const QList<QString>& acceptableTransferSyntaxUIDs,
+    bool includeBulkData);
+
+private:
+  Q_DECLARE_PRIVATE(ctkDicomObjectLocatorCache)
+  const QScopedPointer<ctkDicomObjectLocatorCachePrivate> d_ptr;
+};
+
+#endif // CTKDICOMEXCHANGEIMPL_H

Plugins/org.commontk.dah.exampleapp/ctkExampleDicomAppLogic_p.h

@@ -23,6 +23,10 @@
 #ifndef CTKEXAMPLEDICOMAPPLOGIC_P_H
 #define CTKEXAMPLEDICOMAPPLOGIC_P_H
 
+// Qt includes
+#include <QUuid>
+
+// CTK includes
 #include <ctkDicomAbstractApp.h>
 #include <ctkDicomHostInterface.h>
 

Plugins/org.commontk.dah.host/ctkDicomAbstractHost.cpp

@@ -19,10 +19,13 @@
 
 =============================================================================*/
 
+// CTK includes
+#include "ctkDicomAppService.h"
 #include "ctkDicomAbstractHost.h"
 #include "ctkDicomHostServer.h"
 #include "ctkDicomAppService.h"
 #include "ctkDicomAppHostingTypesHelper.h"
+#include <ctkDicomObjectLocatorCache.h>
 
 class ctkDicomAbstractHostPrivate
 {
@@ -36,6 +39,7 @@ public:
   ctkDicomHostServer* Server;
   ctkDicomAppInterface* AppService;
   ctkDicomAppHosting::State AppState;
+  ctkDicomObjectLocatorCache ObjectLocatorCache;
   // ctkDicomAppHosting::Status
 
 };
@@ -48,11 +52,11 @@ ctkDicomAbstractHostPrivate::ctkDicomAbstractHostPrivate(
   ctkDicomAbstractHost* hostInterface, int hostPort, int appPort) : HostPort(hostPort), AppPort(appPort),AppState(ctkDicomAppHosting::EXIT)
 {
   // start server
-  if (this->HostPort==0)
+  if (this->HostPort == 0)
     {
     this->HostPort = 8080;
     }
-  if (this->AppPort==0)
+  if (this->AppPort == 0)
     {
     this->AppPort = 8081;
     }
@@ -82,6 +86,11 @@ ctkDicomAbstractHost::ctkDicomAbstractHost(int hostPort, int appPort) :
 }
 
 //----------------------------------------------------------------------------
+ctkDicomAbstractHost::~ctkDicomAbstractHost()
+{
+}
+
+//----------------------------------------------------------------------------
 int ctkDicomAbstractHost::getHostPort() const
 {
   Q_D(const ctkDicomAbstractHost);
@@ -96,15 +105,41 @@ int ctkDicomAbstractHost::getAppPort() const
 }
 
 //----------------------------------------------------------------------------
-ctkDicomAbstractHost::~ctkDicomAbstractHost()
+ctkDicomAppInterface* ctkDicomAbstractHost::getDicomAppService() const
 {
+  Q_D(const ctkDicomAbstractHost);
+  return d->AppService;
 }
 
 //----------------------------------------------------------------------------
-ctkDicomAppInterface* ctkDicomAbstractHost::getDicomAppService() const
+QList<ctkDicomAppHosting::ObjectLocator> ctkDicomAbstractHost::getData(
+  const QList<QUuid>& objectUUIDs,
+  const QList<QString>& acceptableTransferSyntaxUIDs,
+  bool includeBulkData)
+{
+  return this->objectLocatorCache()->getData(objectUUIDs, acceptableTransferSyntaxUIDs, includeBulkData);
+}
+
+//----------------------------------------------------------------------------
+ctkDicomObjectLocatorCache* ctkDicomAbstractHost::objectLocatorCache()const
 {
   Q_D(const ctkDicomAbstractHost);
-  return d->AppService;
+  return const_cast<ctkDicomObjectLocatorCache*>(&d->ObjectLocatorCache);
+}
+
+//----------------------------------------------------------------------------
+bool ctkDicomAbstractHost::publishData(const ctkDicomAppHosting::AvailableData& availableData, bool lastData)
+{
+  if (!this->objectLocatorCache()->isCached(availableData))
+    {
+    return false;
+    }
+  bool success = this->getDicomAppService()->notifyDataAvailable(availableData, lastData);
+  if(!success)
+    {
+    return false;
+    }
+  return true;
 }
 
 //----------------------------------------------------------------------------

Plugins/org.commontk.dah.host/ctkDicomAbstractHost.h

@@ -29,6 +29,7 @@
 #include <org_commontk_dah_host_Export.h>
 
 class ctkDicomAbstractHostPrivate;
+class ctkDicomObjectLocatorCache;
 
 
 /**
@@ -51,15 +52,23 @@ public:
     * Starts the soap sever on the specified port or choose port automatically.
     */
   ctkDicomAbstractHost(int hostPort = 0, int appPort = 0);
+  virtual ~ctkDicomAbstractHost();
   int getHostPort() const;
+
   int getAppPort() const;
 
   virtual void notifyStateChanged(ctkDicomAppHosting::State state);
 ctkDicomAppHosting::State getApplicationState()const;
+  ctkDicomAppInterface* getDicomAppService() const;
 
-  virtual ~ctkDicomAbstractHost();
+  virtual QList<ctkDicomAppHosting::ObjectLocator> getData(
+    const QList<QUuid>& objectUUIDs,
+    const QList<QString>& acceptableTransferSyntaxUIDs,
+    bool includeBulkData);
 
-  ctkDicomAppInterface* getDicomAppService() const;
+  ctkDicomObjectLocatorCache* objectLocatorCache()const;
+
+  bool publishData(const ctkDicomAppHosting::AvailableData& availableData, bool lastData);
 
 signals:
  void appReady();
@@ -73,8 +82,6 @@ signals:
  void stateChangedReceived(ctkDicomAppHosting::State state);
  void statusReceived(const ctkDicomAppHosting::Status& status);
 
-
-
 private:
 
   Q_DECLARE_PRIVATE(ctkDicomAbstractHost)