mitkIGTLMessageToUSImageFilter.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 <mitkIGTLMessageToUSImageFilter.h>
#include <igtlImageMessage.h>
#include <itkByteSwapper.h>

#include <vtkSmartPointer.h>

void mitk::IGTLMessageToUSImageFilter::GetNextRawImage(
  std::vector<mitk::Image::Pointer>& imgVector)
{
  if (imgVector.size() != 1)
    imgVector.resize(1);

  mitk::Image::Pointer& img = imgVector[0];
  m_upstream->Update();

  mitk::IGTLMessage* msg = m_upstream->GetOutput();

  if (msg != nullptr && (!msg->IsDataValid() || std::strcmp(msg->GetIGTLMessageType(), "IMAGE") != 0))
  {
    img = m_previousImage;
    return;
  }

  igtl::MessageBase::Pointer msgBase = msg->GetMessage();
  igtl::ImageMessage* imgMsg = (igtl::ImageMessage*)(msgBase.GetPointer());

  bool big_endian = (imgMsg->GetEndian() == igtl::ImageMessage::ENDIAN_BIG);

  if (imgMsg->GetCoordinateSystem() != igtl::ImageMessage::COORDINATE_RAS)
  {
    // TODO: Which coordinate system does MITK use?
    mitkThrow() << "Can not handle messages with LPS coordinate system";
  }

  switch (imgMsg->GetScalarType())
  {
  case igtl::ImageMessage::TYPE_UINT8:
    Initiate<unsigned char>(img, imgMsg, big_endian);
    break;
  case igtl::ImageMessage::TYPE_INT8:
    Initiate<char>(img, imgMsg, big_endian);
    break;
  case igtl::ImageMessage::TYPE_UINT16:
    Initiate<unsigned short>(img, imgMsg, big_endian);
    break;
  case igtl::ImageMessage::TYPE_INT16:
    Initiate<short>(img, imgMsg, big_endian);
    break;
  case igtl::ImageMessage::TYPE_UINT32:
    Initiate<unsigned int>(img, imgMsg, big_endian);
    break;
  case igtl::ImageMessage::TYPE_INT32:
    Initiate<int>(img, imgMsg, big_endian);
    break;
  case igtl::ImageMessage::TYPE_FLOAT32:
    Initiate<float>(img, imgMsg, big_endian);
    break;
  case igtl::ImageMessage::TYPE_FLOAT64:
    Initiate<double>(img, imgMsg, big_endian);
    break;
  default:
    mitkThrow() << "Incompatible PixelType " << imgMsg;
  }
}

template <typename TPixel>
void mitk::IGTLMessageToUSImageFilter::Initiate(mitk::Image::Pointer& img,
  igtl::ImageMessage* msg,
  bool big_endian)
{
  typedef itk::Image<TPixel, 3> ImageType;

  typename ImageType::Pointer output = ImageType::New();
  typename ImageType::RegionType region;
  typename ImageType::RegionType::SizeType size;
  typename ImageType::RegionType::IndexType index;
  typename ImageType::SpacingType spacing;
  typename ImageType::PointType origin;

  // Copy dimensions
  int dims[3];
  msg->GetDimensions(dims);
  size_t num_pixel = 1;
  for (size_t i = 0; i < 3; i++)
  {
    size[i] = dims[i];
    num_pixel *= dims[i];
  }

  // Handle subvolume information. We want the subvolume to be the whole image
  // for now.
  int sdims[3], offs[3];
  msg->GetSubVolume(sdims, offs);
  for (size_t i = 0; i < 3; i++)
  {
    if (offs[i] != 0 || sdims[i] != dims[i])
    {
      // TODO: Handle messages with smaller subvolume than whole image
      throw("Can not handle message with smaller subvolume than whole image");
    }
  }

  index.Fill(0);

  float matF[4][4];
  msg->GetMatrix(matF);
  vtkSmartPointer<vtkMatrix4x4> vtkMatrix = vtkSmartPointer<vtkMatrix4x4>::New();

  for (size_t i = 0; i < 4; ++i)
    for (size_t j = 0; j < 4; ++j)
      vtkMatrix->SetElement(i, j, matF[i][j]);

  float spacingMsg[3];

  msg->GetSpacing(spacingMsg);

  for (int i = 0; i < 3; ++i)
    spacing[i] = spacingMsg[i];

  region.SetSize(size);
  region.SetIndex(index);
  output->SetRegions(region);
  output->SetSpacing(spacing);
  output->Allocate();

  TPixel* in = (TPixel*)msg->GetScalarPointer();
  TPixel* out = (TPixel*)output->GetBufferPointer();
  memcpy(out, in, num_pixel * sizeof(TPixel));
  if (big_endian)
  {
    // Even though this method is called "FromSystemToBigEndian", it also swaps
    // "FromBigEndianToSystem".
    // This makes sense, but might be confusing at first glance.
    itk::ByteSwapper<TPixel>::SwapRangeFromSystemToBigEndian(out, num_pixel);
  }
  else
  {
    itk::ByteSwapper<TPixel>::SwapRangeFromSystemToLittleEndian(out, num_pixel);
  }

  img = mitk::Image::New();
  img->InitializeByItk(output.GetPointer());
  img->SetVolume(output->GetBufferPointer());
  //img->GetGeometry()->SetIndexToWorldTransformByVtkMatrix(vtkMatrix);
  m_previousImage = img;

  float iorigin[3];
  msg->GetOrigin(iorigin);
  for (size_t i = 0; i < 3; i++)
  {
    origin[i] = iorigin[i];
  }
  output->SetOrigin(origin);
}

mitk::IGTLMessageToUSImageFilter::IGTLMessageToUSImageFilter()
  : m_upstream(nullptr)
{
  MITK_DEBUG << "Instantiated this (" << this << ") mitkIGTMessageToUSImageFilter\n";
}

void mitk::IGTLMessageToUSImageFilter::SetNumberOfExpectedOutputs(
  unsigned int numOutputs)
{
  if (numOutputs > 1)
  {
    throw("Can only have 1 output for IGTLMessageToUSImageFilter.");
  }
}

void mitk::IGTLMessageToUSImageFilter::ConnectTo(
  mitk::IGTLMessageSource* UpstreamFilter)
{
  MITK_DEBUG << "Connected this (" << this << ") mitkIGTLMessageToUSImageFilter to MessageSource (" << UpstreamFilter << ")\n";
  m_upstream = UpstreamFilter;
}