void QmitkDeformableRegistrationView::ApplyDeformationField()
{
ImageReaderType::Pointer reader = ImageReaderType::New();
reader->SetFileName( m_Controls.m_QmitkBSplineRegistrationViewControls->m_Controls.m_DeformationField->text().toStdString() );
reader->Update();
DeformationFieldType::Pointer deformationField = reader->GetOutput();
mitk::Image * mimage = dynamic_cast<mitk::Image*> (m_MovingNode->GetData());
mitk::Image * fimage = dynamic_cast<mitk::Image*> (m_FixedNode->GetData());
typedef itk::Image<float, 3> FloatImageType;
FloatImageType::Pointer itkMovingImage = FloatImageType::New();
FloatImageType::Pointer itkFixedImage = FloatImageType::New();
mitk::CastToItkImage(mimage, itkMovingImage);
mitk::CastToItkImage(fimage, itkFixedImage);
typedef itk::WarpImageFilter<
FloatImageType,
FloatImageType,
DeformationFieldType > WarperType;
typedef itk::LinearInterpolateImageFunction<
FloatImageType,
double > InterpolatorType;
WarperType::Pointer warper = WarperType::New();
InterpolatorType::Pointer interpolator = InterpolatorType::New();
warper->SetInput( itkMovingImage );
warper->SetInterpolator( interpolator );
warper->SetOutputSpacing( itkFixedImage->GetSpacing() );
warper->SetOutputOrigin( itkFixedImage->GetOrigin() );
warper->SetOutputDirection (itkFixedImage->GetDirection() );
warper->SetDisplacementField( deformationField );
warper->Update();
FloatImageType::Pointer outputImage = warper->GetOutput();
mitk::Image::Pointer result = mitk::Image::New();
mitk::CastToMitkImage(outputImage, result);
// Create new DataNode
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
newNode->SetData( result );
newNode->SetProperty( "name", mitk::StringProperty::New("warped image") );
// add the new datatree node to the datatree
this->GetDefaultDataStorage()->Add(newNode);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
//Image::Pointer outputImage = this->GetOutput();
//mitk::CastToMitkImage( warper->GetOutput(), outputImage );
}
void TractAnalyzer::MakeRoi()
{
m_CostSum = 0.0;
int n = 0;
if(m_PointSetNode.IsNotNull())
{
n = m_PointSetNode->GetSize();
if(n==0)
{
QMessageBox msgBox;
msgBox.setText("No points have been set yet.");
msgBox.exec();
}
}
else{
QMessageBox msgBox;
msgBox.setText("No points have been set yet.");
msgBox.exec();
}
std::string pathDescription = "";
std::vector< itk::Index<3> > totalPath;
if(n>0)
{
for(int i=0; i<n-1; ++i)
{
mitk::ProgressBar::GetInstance()->Progress();
mitk::Point3D p = m_PointSetNode->GetPoint(i);
mitk::Point3D p2 = m_PointSetNode->GetPoint(i+1);
itk::Index<3> startPoint;
itk::Index<3> endPoint;
m_InputImage->GetGeometry()->WorldToIndex(p,startPoint);
m_InputImage->GetGeometry()->WorldToIndex(p2,endPoint);
MITK_INFO << "create roi";
std::vector< itk::Index<3> > path = CreateSegment(startPoint, endPoint);
for(std::vector< itk::Index<3> >::iterator it = path.begin();
it != path.end(); it++)
{
itk::Index<3> ix = *it;
if (!(ix==endPoint))
{
mitk::ProgressBar::GetInstance()->Progress();
totalPath.push_back(ix);
std::stringstream ss;
ss << ix[0] << " " << ix[1] << " " << ix[2] << "\n";
pathDescription += ss.str();
}
else
{
// Only when dealing with the last segment the last point should be added. This one will not occur
// as the first point of the next roi segment.
if(i == (n-2))
{
totalPath.push_back(endPoint);
std::stringstream ss;
ss << endPoint[0] << " " << endPoint[1] << " " << endPoint[2] << "\n";
pathDescription += ss.str();
}
}
}
}
// save pathDescription to m_PathDescription
m_PathDescription = pathDescription;
FloatImageType::Pointer itkImg = FloatImageType::New();
mitk::CastToItkImage(m_InputImage, itkImg);
CharImageType::Pointer roiImg = CharImageType::New();
roiImg->SetRegions(itkImg->GetLargestPossibleRegion().GetSize());
roiImg->SetOrigin(itkImg->GetOrigin());
roiImg->SetSpacing(itkImg->GetSpacing());
roiImg->SetDirection(itkImg->GetDirection());
roiImg->Allocate();
roiImg->FillBuffer(0);
std::vector< itk::Index<3> > roi;
std::vector< itk::Index<3> >::iterator it;
for(it = totalPath.begin();
it != totalPath.end();
it++)
{
itk::Index<3> ix = *it;
roiImg->SetPixel(ix, 1);
roi.push_back(ix);
}
m_TbssRoi = mitk::TbssRoiImage::New();
m_TbssRoi->SetRoi(roi);
m_TbssRoi->SetImage(roiImg);
m_TbssRoi->InitializeFromImage();
}
}
static void
ExtractSlicesFromImages(mitk::Image::Pointer image, mitk::Image::Pointer mask,
mitk::Image::Pointer maskNoNaN, mitk::Image::Pointer morphMask,
int direction,
std::vector<mitk::Image::Pointer> &imageVector,
std::vector<mitk::Image::Pointer> &maskVector,
std::vector<mitk::Image::Pointer> &maskNoNaNVector,
std::vector<mitk::Image::Pointer> &morphMaskVector)
{
typedef itk::Image< double, 2 > FloatImage2DType;
typedef itk::Image< unsigned short, 2 > MaskImage2DType;
FloatImageType::Pointer itkFloat = FloatImageType::New();
MaskImageType::Pointer itkMask = MaskImageType::New();
MaskImageType::Pointer itkMaskNoNaN = MaskImageType::New();
MaskImageType::Pointer itkMorphMask = MaskImageType::New();
mitk::CastToItkImage(mask, itkMask);
mitk::CastToItkImage(maskNoNaN, itkMaskNoNaN);
mitk::CastToItkImage(image, itkFloat);
mitk::CastToItkImage(morphMask, itkMorphMask);
int idxA, idxB, idxC;
switch (direction)
{
case 0:
idxA = 1; idxB = 2; idxC = 0;
break;
case 1:
idxA = 0; idxB = 2; idxC = 1;
break;
case 2:
idxA = 0; idxB = 1; idxC = 2;
break;
default:
idxA = 1; idxB = 2; idxC = 0;
break;
}
auto imageSize = image->GetLargestPossibleRegion().GetSize();
FloatImageType::IndexType index3D;
FloatImage2DType::IndexType index2D;
FloatImage2DType::SpacingType spacing2D;
spacing2D[0] = itkFloat->GetSpacing()[idxA];
spacing2D[1] = itkFloat->GetSpacing()[idxB];
for (unsigned int i = 0; i < imageSize[idxC]; ++i)
{
FloatImage2DType::RegionType region;
FloatImage2DType::IndexType start;
FloatImage2DType::SizeType size;
start[0] = 0; start[1] = 0;
size[0] = imageSize[idxA];
size[1] = imageSize[idxB];
region.SetIndex(start);
region.SetSize(size);
FloatImage2DType::Pointer image2D = FloatImage2DType::New();
image2D->SetRegions(region);
image2D->Allocate();
MaskImage2DType::Pointer mask2D = MaskImage2DType::New();
mask2D->SetRegions(region);
mask2D->Allocate();
MaskImage2DType::Pointer masnNoNaN2D = MaskImage2DType::New();
masnNoNaN2D->SetRegions(region);
masnNoNaN2D->Allocate();
MaskImage2DType::Pointer morph2D = MaskImage2DType::New();
morph2D->SetRegions(region);
morph2D->Allocate();
unsigned long voxelsInMask = 0;
for (unsigned int a = 0; a < imageSize[idxA]; ++a)
{
for (unsigned int b = 0; b < imageSize[idxB]; ++b)
{
index3D[idxA] = a;
index3D[idxB] = b;
index3D[idxC] = i;
index2D[0] = a;
index2D[1] = b;
image2D->SetPixel(index2D, itkFloat->GetPixel(index3D));
mask2D->SetPixel(index2D, itkMask->GetPixel(index3D));
masnNoNaN2D->SetPixel(index2D, itkMaskNoNaN->GetPixel(index3D));
morph2D->SetPixel(index2D, itkMorphMask->GetPixel(index3D));
voxelsInMask += (itkMask->GetPixel(index3D) > 0) ? 1 : 0;
}
}
image2D->SetSpacing(spacing2D);
mask2D->SetSpacing(spacing2D);
masnNoNaN2D->SetSpacing(spacing2D);
morph2D->SetSpacing(spacing2D);
mitk::Image::Pointer tmpFloatImage = mitk::Image::New();
tmpFloatImage->InitializeByItk(image2D.GetPointer());
mitk::GrabItkImageMemory(image2D, tmpFloatImage);
mitk::Image::Pointer tmpMaskImage = mitk::Image::New();
tmpMaskImage->InitializeByItk(mask2D.GetPointer());
mitk::GrabItkImageMemory(mask2D, tmpMaskImage);
mitk::Image::Pointer tmpMaskNoNaNImage = mitk::Image::New();
tmpMaskNoNaNImage->InitializeByItk(masnNoNaN2D.GetPointer());
mitk::GrabItkImageMemory(masnNoNaN2D, tmpMaskNoNaNImage);
mitk::Image::Pointer tmpMorphMaskImage = mitk::Image::New();
tmpMorphMaskImage->InitializeByItk(morph2D.GetPointer());
mitk::GrabItkImageMemory(morph2D, tmpMorphMaskImage);
if (voxelsInMask > 0)
{
imageVector.push_back(tmpFloatImage);
maskVector.push_back(tmpMaskImage);
maskNoNaNVector.push_back(tmpMaskNoNaNImage);
morphMaskVector.push_back(tmpMorphMaskImage);
}
}
}