mitkUSTelemedDevice.cpp

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#include "mitkUSTelemedDevice.h"
#include "mitkImageReadAccessor.h"
#include "mitkUSTelemedSDKHeader.h"
 
mitk::USTelemedDevice::USTelemedDevice(std::string manufacturer, std::string model)
: mitk::USDevice(manufacturer, model),
m_ControlsProbes(mitk::USTelemedProbesControls::New(this)),
m_ControlsBMode(mitk::USTelemedBModeControls::New(this)),
m_ControlsDoppler(mitk::USTelemedDopplerControls::New(this)),
m_ImageSource(mitk::USTelemedImageSource::New()), m_UsgMainInterface(0),
m_Probe(0), m_UsgDataView(0), m_ProbesCollection(0)
{
  SetNumberOfIndexedOutputs(1);
  SetNthOutput(0, this->MakeOutput(0));
}
 
mitk::USTelemedDevice::~USTelemedDevice()
{
}
 
std::string mitk::USTelemedDevice::GetDeviceClass()
{
  return "org.mitk.modules.us.USTelemedDevice";
}
 
mitk::USControlInterfaceBMode::Pointer mitk::USTelemedDevice::GetControlInterfaceBMode()
{
  return m_ControlsBMode.GetPointer();
}
 
mitk::USControlInterfaceProbes::Pointer mitk::USTelemedDevice::GetControlInterfaceProbes()
{
  return m_ControlsProbes.GetPointer();
};
 
mitk::USControlInterfaceDoppler::Pointer mitk::USTelemedDevice::GetControlInterfaceDoppler()
{
  return m_ControlsDoppler.GetPointer();
};
 
bool mitk::USTelemedDevice::OnInitialization()
{
  CoInitialize(nullptr); // initialize COM library
 
  return true;
}
 
bool mitk::USTelemedDevice::OnConnection()
{
  // create main Telemed API COM library object
  HRESULT hr;
 
  hr = CoCreateInstance(Usgfw2Lib::CLSID_Usgfw2, nullptr, CLSCTX_INPROC_SERVER, Usgfw2Lib::IID_IUsgfw2,(LPVOID*) &m_UsgMainInterface);
  if (FAILED(hr))
  {
    SAFE_RELEASE(m_UsgMainInterface);
    MITK_ERROR("USDevice")("USTelemedDevice") << "Error at connecting to ultrasound device (" << hr << ").";
    return false;
  }
 
  this->ConnectDeviceChangeSink();
 
  return true;
}
 
bool mitk::USTelemedDevice::OnDisconnection()
{
  // control objects cannot be active anymore
  m_ControlsBMode->SetIsActive(false);
  m_ControlsDoppler->SetIsActive(false);
  m_ControlsProbes->SetIsActive(false);
 
  ReleaseUsgControls();
 
  return true;
}
 
bool mitk::USTelemedDevice::OnActivation()
{
  // probe controls are available now
  m_ControlsProbes->SetIsActive(true);
 
  if ( m_ControlsProbes->GetProbesCount() < 1 )
  {
    MITK_WARN("USDevice")("USTelemedDevice") << "No probe found.";
    return false;
  }
 
  // select first probe as a default
  m_ControlsProbes->SelectProbe(0);
 
  // set scan mode b as default for activation -
  // control interfaces can override this later
  HRESULT hr = m_UsgDataView->put_ScanMode(Usgfw2Lib::SCAN_MODE_B);
  if (FAILED(hr))
  {
    MITK_ERROR("USDevice")("USTelemedDevice") << "Could not set scan mode b (" << hr << ").";
    return false;
  }
 
  // start ultrasound scanning with selected scan mode
  hr = m_UsgDataView->put_ScanState(Usgfw2Lib::SCAN_STATE_RUN);
  if (FAILED(hr))
  {
    MITK_ERROR("USDevice")("USTelemedDevice") << "Start scanning failed (" << hr << ").";
    return false;
  }
 
  m_ControlsBMode->ReinitializeControls();
 
  return true;
}
 
bool mitk::USTelemedDevice::OnDeactivation()
{
  this->StopScanning();
  return true;
}
 
void mitk::USTelemedDevice::OnFreeze(bool freeze)
{
  if ( freeze )
  {
    m_UsgDataView->put_ScanState(Usgfw2Lib::SCAN_STATE_FREEZE);
  }
  else
  {
    m_UsgDataView->put_ScanState(Usgfw2Lib::SCAN_STATE_RUN);
  }
}
 
void mitk::USTelemedDevice::GenerateData()
{
  mitk::USTelemedImageSource::Pointer s = dynamic_cast<mitk::USTelemedImageSource*>(GetUSImageSource().GetPointer());
  s->GetNextRawImage(m_ImageVector);
  Superclass::GenerateData();
}
 
mitk::USImageSource::Pointer mitk::USTelemedDevice::GetUSImageSource()
{
  return m_ImageSource.GetPointer();
}
 
void mitk::USTelemedDevice::ReleaseUsgControls()
{
  if (m_UsgDataView) { this->StopScanning(); };
 
  SAFE_RELEASE(m_UsgMainInterface);
  SAFE_RELEASE(m_Probe);
  SAFE_RELEASE(m_UsgDataView);
  SAFE_RELEASE(m_ProbesCollection);
}
 
void mitk::USTelemedDevice::StopScanning()
{
  if ( ! m_UsgDataView )
  {
    MITK_WARN("USDevice")("USTelemedDevice") << "Cannot stop scanning as Telemed Data View is null.";
    return;
  }
 
  HRESULT hr;
  hr = m_UsgDataView->put_ScanState(Usgfw2Lib::SCAN_STATE_STOP);
 
  if (FAILED(hr))
  {
    MITK_ERROR("USDevice")("USTelemedDevice") << "Stop scanning failed (" << hr << ").";
    mitkThrow() << "Stop scanning failed (" << hr << ").";
  }
}
 
std::vector<mitk::USProbe::Pointer> mitk::USTelemedDevice::GetAllProbes(){
  return m_ControlsProbes->GetProbeSet();
}
 
mitk::USProbe::Pointer mitk::USTelemedDevice::GetCurrentProbe(){
  return m_ControlsProbes->GetSelectedProbe();
}
 
mitk::USProbe::Pointer mitk::USTelemedDevice::GetProbeByName(std::string name){
  for (mitk::USProbe::Pointer p : m_ControlsProbes->GetProbeSet()){
    if (p->GetName().compare(name)==0) {return p;}
  }
  return nullptr;
}
 
Usgfw2Lib::IUsgfw2* mitk::USTelemedDevice::GetUsgMainInterface()
{
  return m_UsgMainInterface;
}
 
void mitk::USTelemedDevice::SetActiveDataView(Usgfw2Lib::IUsgDataView* usgDataView)
{
  // do nothing if the usg data view hasn't changed
  if ( m_UsgDataView != usgDataView )
  {
    // scan converter plugin is connected to IUsgDataView -> a new plugin
    // must be created when changing IUsgDataView
    m_UsgDataView = usgDataView;
    if ( ! m_ImageSource->CreateAndConnectConverterPlugin(m_UsgDataView, Usgfw2Lib::SCAN_MODE_B)) { return; }
 
    // b mode control object must know about active data view
    m_ControlsBMode->SetUsgDataView(m_UsgDataView);
  }
}
 
void mitk::USTelemedDevice::ConnectDeviceChangeSink( )
{
  IConnectionPointContainer* cpc = nullptr;
  HRESULT hr = m_UsgMainInterface->QueryInterface(IID_IConnectionPointContainer, (void**)&cpc);
  if (hr != S_OK)
    cpc = nullptr;
 
  if (cpc != nullptr)
    hr = cpc->FindConnectionPoint(Usgfw2Lib::IID_IUsgDeviceChangeSink, &m_UsgDeviceChangeCpnt);
 
  if (hr != S_OK)
  {
    m_UsgDeviceChangeCpnt = nullptr;
    m_UsgDeviceChangeCpntCookie = 0;
  }
  SAFE_RELEASE(cpc);
 
  if (m_UsgDeviceChangeCpnt != nullptr)
    hr = m_UsgDeviceChangeCpnt->Advise((IUnknown*)((Usgfw2Lib::IUsgDeviceChangeSink*)this), &m_UsgDeviceChangeCpntCookie);
}
 
// --- Methods for Telemed API Interfaces
 
HRESULT __stdcall mitk::USTelemedDevice::raw_OnBeamformerArrive(IUnknown *pUsgBeamformer, ULONG *reserved)
{
  this->Connect();
 
  return S_OK;
}
 
HRESULT __stdcall mitk::USTelemedDevice::raw_OnBeamformerRemove(IUnknown *pUsgBeamformer, ULONG *reserved)
{
  if ( this->GetIsActive() ) { this->Deactivate(); }
 
  this->Disconnect();
 
  return S_OK;
}
 
HRESULT __stdcall mitk::USTelemedDevice::raw_OnProbeArrive(IUnknown*, ULONG* probeIndex)
{
  m_ControlsProbes->ProbeAdded(static_cast<unsigned int>(*probeIndex));
 
  this->Activate();
 
  return S_OK;
};
 
HRESULT __stdcall mitk::USTelemedDevice::raw_OnProbeRemove(IUnknown*, ULONG* probeIndex)
{
  m_ControlsProbes->ProbeRemoved(static_cast<unsigned int>(*probeIndex));
 
  if ( this->GetIsActive() ) { this->Deactivate(); }
 
  return S_OK;
};
 
STDMETHODIMP_(ULONG) mitk::USTelemedDevice::AddRef()
{
  ++m_RefCount;
  return m_RefCount;
}
 
STDMETHODIMP_(ULONG) mitk::USTelemedDevice::Release()
{
  --m_RefCount;
  return m_RefCount;
}
 
STDMETHODIMP  mitk::USTelemedDevice::QueryInterface(REFIID riid, void** ppv)
{
  if (riid == IID_IUnknown || riid == Usgfw2Lib::IID_IUsgDeviceChangeSink)
  {
    *ppv = (IUsgDeviceChangeSink*)this;
    return S_OK;
  }
  if (riid == IID_IDispatch)
  {
    *ppv = (IDispatch*)this;
    return S_OK;
  }
  return E_NOINTERFACE;
}
 
HRESULT mitk::USTelemedDevice::GetTypeInfoCount(UINT *pctinfo)
{
  if (pctinfo == nullptr) return E_INVALIDARG;
  *pctinfo = 0;
  return S_OK;
}
 
HRESULT mitk::USTelemedDevice::GetTypeInfo(UINT itinfo, LCID lcid, ITypeInfo** pptinfo)
{
  if (pptinfo == nullptr) return E_INVALIDARG;
  *pptinfo = nullptr;
  if(itinfo != 0) return DISP_E_BADINDEX;
  return S_OK;
}
 
HRESULT mitk::USTelemedDevice::GetIDsOfNames(const IID &riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgdispid)
{
  // this is not used - must use the same fixed dispid's from Usgfw2 idl file
  return S_OK;
}
 
HRESULT mitk::USTelemedDevice::Invoke(DISPID dispIdMember, const IID &riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
{
  if ( (dispIdMember >= 1) && (dispIdMember <= 6) )
  {
    if (pDispParams->cArgs != 2) // we need 2 arguments
      return S_OK;
 
    IUnknown *unkn = nullptr;
    ULONG *res = nullptr;
 
    VARIANTARG* p1;
    VARIANTARG* p;
    p1 = pDispParams->rgvarg;
 
    p = p1;
    if (p->vt == (VT_BYREF|VT_UI4))
      res = p->pulVal;
    p1++;
 
    p = p1;
    if (p->vt == VT_UNKNOWN)
      unkn = (IUnknown*)(p->punkVal);
 
    if (dispIdMember == 1)
      OnProbeArrive(unkn, res);
    else if (dispIdMember == 2)
      OnBeamformerArrive(unkn, res);
    else if (dispIdMember == 3)
      OnProbeRemove(unkn, res);
    else if (dispIdMember == 4)
      OnBeamformerRemove(unkn, res);
    else if (dispIdMember == 5)
      OnProbeStateChanged(unkn, res);
    else if (dispIdMember == 6)
      OnBeamformerStateChanged(unkn, res);
  }
 
  return S_OK;
}