NavigationDataReferenceTransformFilter applies a itk-landmark-transformation defined by 3 (or more) source and target points. If there are less than 3 source/target points available the missing landmark points can be calculated by using the ND of only one input. More...

#include <mitkNavigationDataReferenceTransformFilter.h>

Inheritance diagram for mitk::NavigationDataReferenceTransformFilter:

[legend]

Collaboration diagram for mitk::NavigationDataReferenceTransformFilter:

[legend]

List of all members.

Public Types
typedef itk::VersorRigid3DTransform < double >	LandmarkTransformType
typedef std::vector< int >	ReferenceInputsType
typedef itk::Image< signed short, 3 >	ImageType
typedef itk::QuaternionRigidTransform < double >	QuaternionTransformType
typedef itk::LandmarkBasedTransformInitializer < LandmarkTransformType, ImageType, ImageType >	TransformInitializerType
typedef TransformInitializerType::LandmarkPointContainer	LandmarkPointContainer
typedef NavigationDataReferenceTransformFilter	Self
typedef NavigationDataToNavigationDataFilter	Superclass
typedef itk::SmartPointer< Self >	Pointer
typedef itk::SmartPointer < const Self >	ConstPointer
Public Member Functions
virtual const char *	GetClassName () const
virtual bool	GetOneSourceRegistration ()
virtual bool	GetReferenceRegistration ()
const LandmarkPointContainer	GetSourcePoints ()
const LandmarkPointContainer	GetTargetPoints ()
const LandmarkPointContainer	GetReferencePoints ()
void	SetReferenceInputIndexes (const std::vector< int > *indexes)
	Sets the vector with the reference input indexes.
const std::vector< int >	GetReferenceInputIndexes ()
	Returns a vector with the reference inputs IDs.
virtual void	SetSourceLandmarks (mitk::PointSet::Pointer sourcePointSet)
	Set points used as source points for landmark transform.
virtual void	SetTargetLandmarks (mitk::PointSet::Pointer targetPointSet)
	Set points used as source points for landmark transform.
void	GenerateSourceLandmarks ()
	Assigns at least 3 landmarks to the source landmarks container.
void	GenerateTargetLandmarks ()
virtual bool	IsInitialized () const
	Checks if there are enough source and target points for a transform and if source and target point amount are equal.
bool	InitializeReferenceLandmarks ()
	Fills the reference landmark container which is needed for the quaternion transform.
void	ResetFilter ()
	Resets the filter to it's initial state.
Static Public Member Functions
static Pointer	New ()
Protected Member Functions
	NavigationDataReferenceTransformFilter ()
	Constructor.
virtual	~NavigationDataReferenceTransformFilter ()
	Destructor.
void	UpdateLandmarkTransform (const LandmarkPointContainer &sources, const LandmarkPointContainer &targets)
	Calculates the transform using source and target PointSets.
virtual void	GenerateData ()
	Transforms input NDs according to the calculated LandmarkTransform.
void	PrintSelf (std::ostream &os, itk::Indent indent) const
const LandmarkPointContainer	GenerateReferenceLandmarks ()
	Generates landmarks from the actual reference inputs ND.
Protected Attributes
LandmarkPointContainer	m_SourcePoints
LandmarkPointContainer	m_TargetPoints
	positions of the source points
LandmarkPointContainer	m_ReferencePoints
	positions of the target points
TransformInitializerType::Pointer	m_LandmarkTransformInitializer
	positions of the reference points
LandmarkTransformType::Pointer	m_LandmarkTransform
	landmark based transform initializer
QuaternionTransformType::Pointer	m_QuaternionTransform
	transform calculated from source and target points
QuaternionTransformType::Pointer	m_QuaternionLandmarkTransform
	further transform needed to rotate orientation
QuaternionTransformType::Pointer	m_QuaternionReferenceTransform
	transform needed to rotate orientation
bool	m_OneSourceRegistration
	transform needed to rotate the virtual reference points
bool	m_ReferenceRegistration
	bool needed to show that there are less than 3 reference inputs
ReferenceInputsType	m_ReferenceInputIndexes
	bool needed to show if landmarks are generated (true) or set (false)

Detailed Description

NavigationDataReferenceTransformFilter applies a itk-landmark-transformation defined by 3 (or more) source and target points. If there are less than 3 source/target points available the missing landmark points can be calculated by using the ND of only one input.

Documentation Before executing the filter the ReferenceSourceIndexes vector with the reference input IDs must be set and GenerateReferenceSourceLandmarks and GenerateReferenceTargetLandmarks have to be called. The filter can also be executed if SetSourceLandmarks and SetTargetLandmarks are called and there are at least 3 source and 3 target landmark points set. If source or target points are changed after calling GenerateReferenceXXXLandmarks or SetXXXPoints the corresponding method has to be called again to apply the changes. By using the landmark point generator methods moving points are updated on every Update() of this filter.

Definition at line 40 of file mitkNavigationDataReferenceTransformFilter.h.

Member Typedef Documentation

typedef itk::SmartPointer<const Self> mitk::NavigationDataReferenceTransformFilter::ConstPointer

Reimplemented from mitk::NavigationDataToNavigationDataFilter.

Definition at line 51 of file mitkNavigationDataReferenceTransformFilter.h.

typedef itk::Image< signed short, 3> mitk::NavigationDataReferenceTransformFilter::ImageType

Definition at line 46 of file mitkNavigationDataReferenceTransformFilter.h.

typedef TransformInitializerType::LandmarkPointContainer mitk::NavigationDataReferenceTransformFilter::LandmarkPointContainer

Definition at line 49 of file mitkNavigationDataReferenceTransformFilter.h.

typedef itk::VersorRigid3DTransform< double > mitk::NavigationDataReferenceTransformFilter::LandmarkTransformType

Definition at line 44 of file mitkNavigationDataReferenceTransformFilter.h.

typedef itk::SmartPointer<Self> mitk::NavigationDataReferenceTransformFilter::Pointer

Reimplemented from mitk::NavigationDataToNavigationDataFilter.

Definition at line 51 of file mitkNavigationDataReferenceTransformFilter.h.

typedef itk::QuaternionRigidTransform<double> mitk::NavigationDataReferenceTransformFilter::QuaternionTransformType

Definition at line 47 of file mitkNavigationDataReferenceTransformFilter.h.

typedef std::vector<int> mitk::NavigationDataReferenceTransformFilter::ReferenceInputsType

Definition at line 45 of file mitkNavigationDataReferenceTransformFilter.h.

typedef NavigationDataReferenceTransformFilter mitk::NavigationDataReferenceTransformFilter::Self

Reimplemented from mitk::NavigationDataToNavigationDataFilter.

Definition at line 51 of file mitkNavigationDataReferenceTransformFilter.h.

typedef NavigationDataToNavigationDataFilter mitk::NavigationDataReferenceTransformFilter::Superclass

Reimplemented from mitk::NavigationDataToNavigationDataFilter.

Definition at line 51 of file mitkNavigationDataReferenceTransformFilter.h.

typedef itk::LandmarkBasedTransformInitializer< LandmarkTransformType, ImageType, ImageType > mitk::NavigationDataReferenceTransformFilter::TransformInitializerType

Definition at line 48 of file mitkNavigationDataReferenceTransformFilter.h.

Constructor & Destructor Documentation

mitk::NavigationDataReferenceTransformFilter::NavigationDataReferenceTransformFilter ( ) [protected]

Constructor.

Definition at line 21 of file mitkNavigationDataReferenceTransformFilter.cpp.

References m_LandmarkTransform, m_LandmarkTransformInitializer, m_QuaternionLandmarkTransform, m_QuaternionReferenceTransform, m_QuaternionTransform, and New().

                                                                                   : mitk::NavigationDataToNavigationDataFilter(),
m_SourcePoints (NULL),
m_TargetPoints (NULL),
m_ReferencePoints (NULL),
m_LandmarkTransformInitializer (NULL),
m_LandmarkTransform (NULL),
m_OneSourceRegistration (false),
m_ReferenceRegistration (false)
{

  m_LandmarkTransform = LandmarkTransformType::New();
  m_LandmarkTransformInitializer = TransformInitializerType::New();
  m_LandmarkTransformInitializer->SetTransform(m_LandmarkTransform);

  m_QuaternionTransform = QuaternionTransformType::New();
  m_QuaternionLandmarkTransform = QuaternionTransformType::New();
  m_QuaternionReferenceTransform = QuaternionTransformType::New();
}

mitk::NavigationDataReferenceTransformFilter::~NavigationDataReferenceTransformFilter ( ) [protected, virtual]

Destructor.

Definition at line 40 of file mitkNavigationDataReferenceTransformFilter.cpp.

{
  m_LandmarkTransform = NULL;
  m_LandmarkTransformInitializer = NULL;
  m_QuaternionTransform = NULL;
  m_QuaternionLandmarkTransform = NULL;
  m_QuaternionReferenceTransform =  NULL;
}

Member Function Documentation

void mitk::NavigationDataReferenceTransformFilter::GenerateData ( ) [protected, virtual]

Transforms input NDs according to the calculated LandmarkTransform.

Definition at line 65 of file mitkNavigationDataReferenceTransformFilter.cpp.

{
  LandmarkPointContainer newSourcePoints;  // for the quaternion transformed reference landmarks

  if(m_OneSourceRegistration) // check if less than 3 reference inputs
  {
    NavigationData::ConstPointer nd = this->GetInput(m_ReferenceInputIndexes.at(0));

    if (nd->IsDataValid() == false)
    {
      for (unsigned int i = 0; i < this->GetNumberOfOutputs() ; ++i)
      {
        mitk::NavigationData::Pointer output = this->GetOutput(i);
        assert(output);
        output->SetDataValid(false);
      }
      return;
    }

    QuaternionTransformType::Pointer referenceTransform = QuaternionTransformType::New();
    QuaternionTransformType::VnlQuaternionType doubleOrientation(nd->GetOrientation().x(), nd->GetOrientation().y(), nd->GetOrientation().z(), nd->GetOrientation().r()); // convert to double quaternion as workaround for ITK 3.10 bug
    
    referenceTransform->SetRotation(doubleOrientation);
    referenceTransform->SetOffset(nd->GetPosition().GetVectorFromOrigin());
    referenceTransform->Modified();

    for (NavigationDataReferenceTransformFilter::LandmarkPointContainer::const_iterator it = m_ReferencePoints.begin(); it != m_ReferencePoints.end(); ++it)
    {
      TransformInitializerType::LandmarkPointType rLPoint;  // reference landmark point
      rLPoint = referenceTransform->TransformPoint(*it);   
      newSourcePoints.push_back(rLPoint);   
    }
      
      this->UpdateLandmarkTransform(newSourcePoints, m_TargetPoints);
      m_SourcePoints = newSourcePoints;
  }
 

  if(this->IsInitialized() && !m_OneSourceRegistration && m_ReferenceRegistration)
    this->GenerateSourceLandmarks(); // generates landmarks from the moving points


  this->CreateOutputsForAllInputs();

  TransformInitializerType::LandmarkPointType lPointIn, lPointOut;

  for(unsigned int i = 0; i < this->GetNumberOfOutputs(); i++)
  {
    mitk::NavigationData::Pointer output = this->GetOutput(i);
    assert(output);
    mitk::NavigationData::ConstPointer input = this->GetInput(i);
    assert(input);

    if(input->IsDataValid() == false)
    {
      output->SetDataValid(false);
      continue;
    }
    output->Graft(input); // First, copy all information from input to output


    if(this->IsInitialized() == false)
      continue;

    mitk::NavigationData::PositionType tempCoordinate;
    tempCoordinate = input->GetPosition();

    lPointIn[0] = tempCoordinate[0];
    lPointIn[1] = tempCoordinate[1];
    lPointIn[2] = tempCoordinate[2];

    /* transform position */
    lPointOut = m_LandmarkTransform->TransformPoint(lPointIn);

    tempCoordinate[0] = lPointOut[0];
    tempCoordinate[1] = lPointOut[1];
    tempCoordinate[2] = lPointOut[2];

    output->SetPosition(tempCoordinate);  // update output navigation data with new position

    /* transform orientation */
    NavigationData::OrientationType quatIn = input->GetOrientation();
    vnl_quaternion<double> const vnlQuatIn(quatIn.x(), quatIn.y(), quatIn.z(), quatIn.r());
    m_QuaternionTransform->SetRotation(vnlQuatIn);


    m_QuaternionLandmarkTransform->SetMatrix(m_LandmarkTransform->GetRotationMatrix());
    m_QuaternionLandmarkTransform->Compose(m_QuaternionTransform, true);


    vnl_quaternion<double> vnlQuatOut = m_QuaternionLandmarkTransform->GetRotation();
    NavigationData::OrientationType quatOut( vnlQuatOut[0], vnlQuatOut[1], vnlQuatOut[2], vnlQuatOut[3]);

    output->SetOrientation(quatOut);
    output->SetDataValid(true);

  }
}

const mitk::NavigationDataReferenceTransformFilter::LandmarkPointContainer mitk::NavigationDataReferenceTransformFilter::GenerateReferenceLandmarks ( ) [protected]

Generates landmarks from the actual reference inputs ND.

Generates as many landmarks as there are reference inputs. If there are less than 3 reference inputs 2 virtual landmarks are calculated by using the ND of the first reference input.

Definition at line 165 of file mitkNavigationDataReferenceTransformFilter.cpp.

{
  LandmarkPointContainer lPoints;

  if(!m_ReferenceInputIndexes.empty())
  {
    TransformInitializerType::LandmarkPointType lPoint;

    if(m_ReferenceInputIndexes.size() < 3)
    {
      NavigationData::ConstPointer nD = this->GetInput(m_ReferenceInputIndexes.at(0));
      NavigationData::PositionType pos = nD->GetPosition();

      // fill position of reference source into sourcepoints container
      mitk::FillVector3D(lPoint, pos.GetElement(0), pos.GetElement(1), pos.GetElement(2));
      lPoints.push_back(lPoint);

      // generate additional virtual landmark point
      mitk::FillVector3D(lPoint, pos.GetElement(0), pos.GetElement(1)+100, pos.GetElement(2)); // reference source position + (0|100|0)
      lPoints.push_back(lPoint);

      // generate additional virtual landmark point
      mitk::FillVector3D(lPoint, pos.GetElement(0), pos.GetElement(1), pos.GetElement(2)+100); // reference source position + (0|0|100)
      lPoints.push_back(lPoint);
    }
   
    
    else if(m_ReferenceInputIndexes.size()>2)  // if there are at least 3 reference inputs
    {
      for(unsigned int i=0; i<m_ReferenceInputIndexes.size(); ++i)
      {
        NavigationData::ConstPointer nD = this->GetInput(m_ReferenceInputIndexes.at(i));
        NavigationData::PositionType pos = nD->GetPosition();
        mitk::FillVector3D(lPoint, pos.GetElement(0), pos.GetElement(1), pos.GetElement(2));
        lPoints.push_back(lPoint);
      }
    }

  }

  return lPoints;
}

void mitk::NavigationDataReferenceTransformFilter::GenerateSourceLandmarks ( )

Assigns at least 3 landmarks to the source landmarks container.

Therefor the positions of the reference inputs are used. If there are less than 3 reference inputs 2 landmarks will be calculated in dependency of the first reference input.

Definition at line 208 of file mitkNavigationDataReferenceTransformFilter.cpp.

{
  m_ReferenceRegistration = true;

  m_SourcePoints.clear();
  m_SourcePoints = this->GenerateReferenceLandmarks();  // fill source points with landmarks generated from reference inputs

  if(this->IsInitialized())
    this->UpdateLandmarkTransform(m_SourcePoints, m_TargetPoints);
}

void mitk::NavigationDataReferenceTransformFilter::GenerateTargetLandmarks ( )

Definition at line 220 of file mitkNavigationDataReferenceTransformFilter.cpp.

{
  m_ReferenceRegistration = true;

  m_TargetPoints.clear();
  m_TargetPoints = this->GenerateReferenceLandmarks(); // fill target points with landmarks generated from reference inputs

  if(this->IsInitialized())
    this->UpdateLandmarkTransform(m_SourcePoints, m_TargetPoints);
}

virtual const char* mitk::NavigationDataReferenceTransformFilter::GetClassName ( ) const [virtual]

Reimplemented from mitk::NavigationDataToNavigationDataFilter.

virtual bool mitk::NavigationDataReferenceTransformFilter::GetOneSourceRegistration ( ) [virtual]

const std::vector< int > mitk::NavigationDataReferenceTransformFilter::GetReferenceInputIndexes ( )

Returns a vector with the reference inputs IDs.

Definition at line 384 of file mitkNavigationDataReferenceTransformFilter.cpp.

{
  return m_ReferenceInputIndexes;
}

const mitk::NavigationDataReferenceTransformFilter::LandmarkPointContainer mitk::NavigationDataReferenceTransformFilter::GetReferencePoints ( )

Definition at line 401 of file mitkNavigationDataReferenceTransformFilter.cpp.

{
  return m_ReferencePoints;
}

virtual bool mitk::NavigationDataReferenceTransformFilter::GetReferenceRegistration ( ) [virtual]

const mitk::NavigationDataReferenceTransformFilter::LandmarkPointContainer mitk::NavigationDataReferenceTransformFilter::GetSourcePoints ( )

Definition at line 391 of file mitkNavigationDataReferenceTransformFilter.cpp.

{
  return m_SourcePoints;
}

const mitk::NavigationDataReferenceTransformFilter::LandmarkPointContainer mitk::NavigationDataReferenceTransformFilter::GetTargetPoints ( )

Definition at line 396 of file mitkNavigationDataReferenceTransformFilter.cpp.

{
  return m_TargetPoints;
}

bool mitk::NavigationDataReferenceTransformFilter::InitializeReferenceLandmarks ( )

Fills the reference landmark container which is needed for the quaternion transform.

This method is called if there are less than 3 reference inputs.

Definition at line 234 of file mitkNavigationDataReferenceTransformFilter.cpp.

{

  if (m_ReferenceInputIndexes.size() != 1 || (m_SourcePoints.size() < 3) || (m_ReferenceInputIndexes.size() <= 0) || m_ReferenceInputIndexes.size() > this->GetNumberOfInputs())
    return false;

  mitk::NavigationData::ConstPointer referenceND = this->GetInput(m_ReferenceInputIndexes.at(0));

  if(!referenceND->IsDataValid())
    return false;

  QuaternionTransformType::Pointer referenceTransform = QuaternionTransformType::New();
  QuaternionTransformType::VnlQuaternionType doubleOrientation(referenceND->GetOrientation().x(), referenceND->GetOrientation().y(),referenceND->GetOrientation().z(),referenceND->GetOrientation().r());

  referenceTransform->SetRotation(doubleOrientation);
  referenceTransform->SetOffset(referenceND->GetPosition().GetVectorFromOrigin());
  referenceTransform->Modified();

  try
  {
    bool okay = referenceTransform->GetInverse(m_QuaternionReferenceTransform);  // inverse transform to compensate rotation
    if(!okay)
      return false;
  }
  catch( ... )
  {
    return false;
  }

  m_ReferencePoints.clear();

  for(NavigationDataReferenceTransformFilter::LandmarkPointContainer::const_iterator it = m_SourcePoints.begin(); it != m_SourcePoints.end(); ++it)
  {
    QuaternionTransformType::InputPointType doublePoint;
    mitk::itk2vtk(*it,doublePoint); // workaround for itk bug
    TransformInitializerType::LandmarkPointType rLPoint;
    rLPoint = m_QuaternionReferenceTransform->TransformPoint(doublePoint);
    m_ReferencePoints.push_back(rLPoint);
  }
  return true;
}

bool mitk::NavigationDataReferenceTransformFilter::IsInitialized ( ) const [virtual]

Checks if there are enough source and target points for a transform and if source and target point amount are equal.

Definition at line 337 of file mitkNavigationDataReferenceTransformFilter.cpp.

{
  return ( m_SourcePoints.size() >= 3 && (m_SourcePoints.size() == (m_TargetPoints.size())) ); // min. 3 landmarks and same size of source and targets
}

static Pointer mitk::NavigationDataReferenceTransformFilter::New ( ) [static]

Referenced by mitkNavigationDataReferenceTransformFilterTest(), and NavigationDataReferenceTransformFilter().

void mitk::NavigationDataReferenceTransformFilter::PrintSelf	(	std::ostream &	os,
		itk::Indent	indent
	)		const `[protected]`

Definition at line 277 of file mitkNavigationDataReferenceTransformFilter.cpp.

{

}

void mitk::NavigationDataReferenceTransformFilter::ResetFilter ( )

Resets the filter to it's initial state.

Clears all landmarks and resets the outputs by calling CreateOutputsForAllInputs() from superclass

Definition at line 50 of file mitkNavigationDataReferenceTransformFilter.cpp.

{
   m_OneSourceRegistration = false;
   m_ReferenceRegistration = false;

   m_SourcePoints.clear();
   m_TargetPoints.clear();
   m_ReferencePoints.clear();

   this->CreateOutputsForAllInputs();   

  
}

void mitk::NavigationDataReferenceTransformFilter::SetReferenceInputIndexes ( const std::vector< int > * indexes )

Sets the vector with the reference input indexes.

If there are less than 3 reference inputs indexes m_OneSourceRegistration is set true and InitializeReferenceLandmarks() is called.

Definition at line 361 of file mitkNavigationDataReferenceTransformFilter.cpp.

{
   if(indexes == NULL)
    return;

   m_ReferenceInputIndexes = *indexes;

  if(m_ReferenceInputIndexes.size()<3) 
  {
    m_OneSourceRegistration = true;
  }
  else
  {
    m_OneSourceRegistration = false;
  }

  // clearing landmark point containers so that switching between 1 and 3+ landmark registration modes is possible
  m_SourcePoints.clear();
  m_TargetPoints.clear();
  m_ReferencePoints.clear();
}

void mitk::NavigationDataReferenceTransformFilter::SetSourceLandmarks ( mitk::PointSet::Pointer sourcePointSet ) [virtual]

Set points used as source points for landmark transform.

Definition at line 282 of file mitkNavigationDataReferenceTransformFilter.cpp.

{
  m_OneSourceRegistration = false;
  m_ReferenceRegistration = false;

  m_SourcePoints.clear();
  mitk::PointSet::PointType mitkSourcePoint;
  TransformInitializerType::LandmarkPointType lPoint;

  for (mitk::PointSet::PointsContainer::ConstIterator it = sourcePointSet->GetPointSet()->GetPoints()->Begin(); 
    it != sourcePointSet->GetPointSet()->GetPoints()->End(); it++)
  {
    mitk::FillVector3D(lPoint, it->Value().GetElement(0), it->Value().GetElement(1), it->Value().GetElement(2));
    m_SourcePoints.push_back(lPoint);
  }

  if(m_SourcePoints.size() < 1)
  {
    itkExceptionMacro("SourcePointSet must contain at least 1 point");
  }

  if(this->IsInitialized())
    this->UpdateLandmarkTransform(m_SourcePoints, m_TargetPoints);

}

void mitk::NavigationDataReferenceTransformFilter::SetTargetLandmarks ( mitk::PointSet::Pointer targetPointSet ) [virtual]

Set points used as source points for landmark transform.

Definition at line 309 of file mitkNavigationDataReferenceTransformFilter.cpp.

{
  m_OneSourceRegistration = false;
  m_ReferenceRegistration = false;


  m_TargetPoints.clear();
  TransformInitializerType::LandmarkPointType lPoint;


  for (mitk::PointSet::PointsContainer::ConstIterator it = targetPointSet->GetPointSet()->GetPoints()->Begin(); 
    it != targetPointSet->GetPointSet()->GetPoints()->End(); it++)
  {
    mitk::FillVector3D(lPoint, it->Value().GetElement(0), it->Value().GetElement(1), it->Value().GetElement(2));
    m_TargetPoints.push_back(lPoint);
  }

  if(m_TargetPoints.size() < 1)
  {
    itkExceptionMacro("TargetPointSet must contain at least 1 point");
  }

  if(this->IsInitialized())
    this->UpdateLandmarkTransform(m_SourcePoints, m_TargetPoints);

}

void mitk::NavigationDataReferenceTransformFilter::UpdateLandmarkTransform	(	const LandmarkPointContainer &	sources,
		const LandmarkPointContainer &	targets
	)		`[protected]`

Calculates the transform using source and target PointSets.

If there are at least 3 corresponding source and target points a transform will be performed.

Definition at line 343 of file mitkNavigationDataReferenceTransformFilter.cpp.

{
  try 
  {
    m_LandmarkTransformInitializer->SetMovingLandmarks(targets);
    m_LandmarkTransformInitializer->SetFixedLandmarks(sources);
    m_LandmarkTransform->SetIdentity();
    m_LandmarkTransformInitializer->InitializeTransform();

    this->Modified();
  }
  catch (std::exception& e)
  {
    m_LandmarkTransform->SetIdentity();
    itkExceptionMacro("Initializing landmark-transform failed\n. " << e.what());
  }
}