DwiPhantomGenerationFilter< TOutputScalarType >
::DwiPhantomGenerationFilter()
: m_BValue(1000)
, m_SignalScale(1000)
, m_BaselineImages(0)
, m_MaxBaseline(0)
, m_MeanBaseline(0)
, m_NoiseVariance(0.004)
, m_GreyMatterAdc(0.01)
, m_SimulateBaseline(true)
, m_DefaultBaseline(1000)
{
this->SetNumberOfRequiredOutputs (1);
m_Spacing.Fill(2.5); m_Origin.Fill(0.0);
m_DirectionMatrix.SetIdentity();
m_ImageRegion.SetSize(0, 10);
m_ImageRegion.SetSize(1, 10);
m_ImageRegion.SetSize(2, 10);
typename OutputImageType::Pointer outImage = OutputImageType::New();
outImage->SetSpacing( m_Spacing ); // Set the image spacing
outImage->SetOrigin( m_Origin ); // Set the image origin
outImage->SetDirection( m_DirectionMatrix ); // Set the image direction
outImage->SetLargestPossibleRegion( m_ImageRegion );
outImage->SetBufferedRegion( m_ImageRegion );
outImage->SetRequestedRegion( m_ImageRegion );
outImage->SetVectorLength(QBALL_ODFSIZE);
outImage->Allocate();
outImage->FillBuffer(0);
this->SetNthOutput (0, outImage);
}
void FieldmapGeneratorFilter< OutputImageType >::BeforeThreadedGenerateData()
{
typename OutputImageType::Pointer outImage = OutputImageType::New();
outImage->SetSpacing( m_Spacing );
outImage->SetOrigin( m_Origin );
outImage->SetDirection( m_DirectionMatrix );
outImage->SetLargestPossibleRegion( m_ImageRegion );
outImage->SetBufferedRegion( m_ImageRegion );
outImage->SetRequestedRegion( m_ImageRegion );
outImage->Allocate();
outImage->FillBuffer(0);
this->SetNthOutput(0, outImage);
}
void TractDensityImageFilter< OutputImageType >::GenerateData()
{
// generate upsampled image
mitk::Geometry3D::Pointer geometry = m_FiberBundle->GetGeometry();
typename OutputImageType::Pointer outImage = this->GetOutput();
// calculate new image parameters
mitk::Vector3D newSpacing;
mitk::Point3D newOrigin;
itk::Matrix<double, 3, 3> newDirection;
ImageRegion<3> upsampledRegion;
if (m_UseImageGeometry && !m_InputImage.IsNull())
{
MITK_INFO << "TractDensityImageFilter: using image geometry";
newSpacing = m_InputImage->GetSpacing()/m_UpsamplingFactor;
upsampledRegion = m_InputImage->GetLargestPossibleRegion();
newOrigin = m_InputImage->GetOrigin();
typename OutputImageType::RegionType::SizeType size = upsampledRegion.GetSize();
size[0] *= m_UpsamplingFactor;
size[1] *= m_UpsamplingFactor;
size[2] *= m_UpsamplingFactor;
upsampledRegion.SetSize(size);
newDirection = m_InputImage->GetDirection();
}
else
{
MITK_INFO << "TractDensityImageFilter: using fiber bundle geometry";
newSpacing = geometry->GetSpacing()/m_UpsamplingFactor;
newOrigin = geometry->GetOrigin();
mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
newOrigin[0] += bounds.GetElement(0);
newOrigin[1] += bounds.GetElement(2);
newOrigin[2] += bounds.GetElement(4);
for (int i=0; i<3; i++)
for (int j=0; j<3; j++)
newDirection[j][i] = geometry->GetMatrixColumn(i)[j];
upsampledRegion.SetSize(0, geometry->GetExtent(0)*m_UpsamplingFactor);
upsampledRegion.SetSize(1, geometry->GetExtent(1)*m_UpsamplingFactor);
upsampledRegion.SetSize(2, geometry->GetExtent(2)*m_UpsamplingFactor);
}
typename OutputImageType::RegionType::SizeType upsampledSize = upsampledRegion.GetSize();
// apply new image parameters
outImage->SetSpacing( newSpacing );
outImage->SetOrigin( newOrigin );
outImage->SetDirection( newDirection );
outImage->SetRegions( upsampledRegion );
outImage->Allocate();
outImage->FillBuffer(0.0);
int w = upsampledSize[0];
int h = upsampledSize[1];
int d = upsampledSize[2];
// set/initialize output
OutPixelType* outImageBufferPointer = (OutPixelType*)outImage->GetBufferPointer();
// resample fiber bundle
float minSpacing = 1;
if(newSpacing[0]<newSpacing[1] && newSpacing[0]<newSpacing[2])
minSpacing = newSpacing[0];
else if (newSpacing[1] < newSpacing[2])
minSpacing = newSpacing[1];
else
minSpacing = newSpacing[2];
MITK_INFO << "TractDensityImageFilter: resampling fibers to ensure sufficient voxel coverage";
m_FiberBundle = m_FiberBundle->GetDeepCopy();
m_FiberBundle->ResampleFibers(minSpacing);
MITK_INFO << "TractDensityImageFilter: starting image generation";
vtkSmartPointer<vtkPolyData> fiberPolyData = m_FiberBundle->GetFiberPolyData();
vtkSmartPointer<vtkCellArray> vLines = fiberPolyData->GetLines();
vLines->InitTraversal();
int numFibers = m_FiberBundle->GetNumFibers();
boost::progress_display disp(numFibers);
for( int i=0; i<numFibers; i++ )
{
++disp;
vtkIdType numPoints(0);
vtkIdType* points(NULL);
vLines->GetNextCell ( numPoints, points );
// fill output image
for( int j=0; j<numPoints; j++)
{
itk::Point<float, 3> vertex = GetItkPoint(fiberPolyData->GetPoint(points[j]));
itk::Index<3> index;
itk::ContinuousIndex<float, 3> contIndex;
outImage->TransformPhysicalPointToIndex(vertex, index);
outImage->TransformPhysicalPointToContinuousIndex(vertex, contIndex);
float frac_x = contIndex[0] - index[0];
float frac_y = contIndex[1] - index[1];
float frac_z = contIndex[2] - index[2];
if (frac_x<0)
{
index[0] -= 1;
frac_x += 1;
}
if (frac_y<0)
{
index[1] -= 1;
frac_y += 1;
}
if (frac_z<0)
{
index[2] -= 1;
frac_z += 1;
}
frac_x = 1-frac_x;
frac_y = 1-frac_y;
frac_z = 1-frac_z;
// int coordinates inside image?
if (index[0] < 0 || index[0] >= w-1)
continue;
if (index[1] < 0 || index[1] >= h-1)
continue;
if (index[2] < 0 || index[2] >= d-1)
continue;
if (m_BinaryOutput)
{
outImageBufferPointer[( index[0] + w*(index[1] + h*index[2] ))] = 1;
outImageBufferPointer[( index[0] + w*(index[1]+1+ h*index[2] ))] = 1;
outImageBufferPointer[( index[0] + w*(index[1] + h*index[2]+h))] = 1;
outImageBufferPointer[( index[0] + w*(index[1]+1+ h*index[2]+h))] = 1;
outImageBufferPointer[( index[0]+1 + w*(index[1] + h*index[2] ))] = 1;
outImageBufferPointer[( index[0]+1 + w*(index[1] + h*index[2]+h))] = 1;
outImageBufferPointer[( index[0]+1 + w*(index[1]+1+ h*index[2] ))] = 1;
outImageBufferPointer[( index[0]+1 + w*(index[1]+1+ h*index[2]+h))] = 1;
}
else
{
outImageBufferPointer[( index[0] + w*(index[1] + h*index[2] ))] += ( frac_x)*( frac_y)*( frac_z);
outImageBufferPointer[( index[0] + w*(index[1]+1+ h*index[2] ))] += ( frac_x)*(1-frac_y)*( frac_z);
outImageBufferPointer[( index[0] + w*(index[1] + h*index[2]+h))] += ( frac_x)*( frac_y)*(1-frac_z);
outImageBufferPointer[( index[0] + w*(index[1]+1+ h*index[2]+h))] += ( frac_x)*(1-frac_y)*(1-frac_z);
outImageBufferPointer[( index[0]+1 + w*(index[1] + h*index[2] ))] += (1-frac_x)*( frac_y)*( frac_z);
outImageBufferPointer[( index[0]+1 + w*(index[1] + h*index[2]+h))] += (1-frac_x)*( frac_y)*(1-frac_z);
outImageBufferPointer[( index[0]+1 + w*(index[1]+1+ h*index[2] ))] += (1-frac_x)*(1-frac_y)*( frac_z);
outImageBufferPointer[( index[0]+1 + w*(index[1]+1+ h*index[2]+h))] += (1-frac_x)*(1-frac_y)*(1-frac_z);
}
}
}
if (!m_OutputAbsoluteValues && !m_BinaryOutput)
{
MITK_INFO << "TractDensityImageFilter: max-normalizing output image";
OutPixelType max = 0;
for (int i=0; i<w*h*d; i++)
if (max < outImageBufferPointer[i])
max = outImageBufferPointer[i];
if (max>0)
for (int i=0; i<w*h*d; i++)
outImageBufferPointer[i] /= max;
}
if (m_InvertImage)
{
MITK_INFO << "TractDensityImageFilter: inverting image";
for (int i=0; i<w*h*d; i++)
outImageBufferPointer[i] = 1-outImageBufferPointer[i];
}
MITK_INFO << "TractDensityImageFilter: finished processing";
}
void ExtractChannelFromRgbaImageFilter< ReferenceImageType, OutputImageType >::GenerateData()
{
typename InputImageType::Pointer rgbaImage = static_cast< InputImageType * >( this->ProcessObject::GetInput(0) );
typename OutputImageType::Pointer outputImage =
static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
typename InputImageType::RegionType region = rgbaImage->GetLargestPossibleRegion();
outputImage->SetSpacing( m_ReferenceImage->GetSpacing() ); // Set the image spacing
outputImage->SetOrigin( m_ReferenceImage->GetOrigin() ); // Set the image origin
outputImage->SetDirection( m_ReferenceImage->GetDirection() ); // Set the image direction
outputImage->SetRegions( m_ReferenceImage->GetLargestPossibleRegion());
outputImage->Allocate();
outputImage->FillBuffer(0);
float* outImageBufferPointer = outputImage->GetBufferPointer();
itk::Image< short, 3 >::Pointer counterImage = itk::Image< short, 3 >::New();
counterImage->SetSpacing( m_ReferenceImage->GetSpacing() ); // Set the image spacing
counterImage->SetOrigin( m_ReferenceImage->GetOrigin() ); // Set the image origin
counterImage->SetDirection( m_ReferenceImage->GetDirection() ); // Set the image direction
counterImage->SetRegions( m_ReferenceImage->GetLargestPossibleRegion());
counterImage->Allocate();
counterImage->FillBuffer(0);
short* counterImageBufferPointer = counterImage->GetBufferPointer();
int w = m_ReferenceImage->GetLargestPossibleRegion().GetSize().GetElement(0);
int h = m_ReferenceImage->GetLargestPossibleRegion().GetSize().GetElement(1);
int d = m_ReferenceImage->GetLargestPossibleRegion().GetSize().GetElement(2);
typedef ImageRegionConstIterator< InputImageType > InImageIteratorType;
InImageIteratorType rgbaIt(rgbaImage, region);
rgbaIt.GoToBegin();
while(!rgbaIt.IsAtEnd()){
InPixelType x = rgbaIt.Get();
++rgbaIt;
itk::Point<float, 3> vertex;
itk::Index<3> index = rgbaIt.GetIndex();
rgbaImage->TransformIndexToPhysicalPoint(index, vertex);
outputImage->TransformPhysicalPointToIndex(vertex, index);
itk::ContinuousIndex<float, 3> contIndex;
outputImage->TransformPhysicalPointToContinuousIndex(vertex, contIndex);
float frac_x = contIndex[0] - index[0];
float frac_y = contIndex[1] - index[1];
float frac_z = contIndex[2] - index[2];
int px = index[0];
if (frac_x<0)
{
px -= 1;
frac_x += 1;
}
int py = index[1];
if (frac_y<0)
{
py -= 1;
frac_y += 1;
}
int pz = index[2];
if (frac_z<0)
{
pz -= 1;
frac_z += 1;
}
frac_x = 1-frac_x;
frac_y = 1-frac_y;
frac_z = 1-frac_z;
// int coordinates inside image?
if (px < 0 || px >= w-1)
continue;
if (py < 0 || py >= h-1)
continue;
if (pz < 0 || pz >= d-1)
continue;
OutPixelType out;
switch (m_Channel)
{
case RED:
out = (float)x.GetRed()/255;
break;
case GREEN:
out = (float)x.GetGreen()/255;
break;
case BLUE:
out = (float)x.GetBlue()/255;
break;
case ALPHA:
out = (float)x.GetAlpha()/255;
}
outImageBufferPointer[( px + w*(py + h*pz ))] += out*( frac_x)*( frac_y)*( frac_z);
outImageBufferPointer[( px + w*(py+1+ h*pz ))] += out*( frac_x)*(1-frac_y)*( frac_z);
outImageBufferPointer[( px + w*(py + h*pz+h))] += out*( frac_x)*( frac_y)*(1-frac_z);
outImageBufferPointer[( px + w*(py+1+ h*pz+h))] += out*( frac_x)*(1-frac_y)*(1-frac_z);
outImageBufferPointer[( px+1 + w*(py + h*pz ))] += out*(1-frac_x)*( frac_y)*( frac_z);
outImageBufferPointer[( px+1 + w*(py + h*pz+h))] += out*(1-frac_x)*( frac_y)*(1-frac_z);
outImageBufferPointer[( px+1 + w*(py+1+ h*pz ))] += out*(1-frac_x)*(1-frac_y)*( frac_z);
outImageBufferPointer[( px+1 + w*(py+1+ h*pz+h))] += out*(1-frac_x)*(1-frac_y)*(1-frac_z);
counterImageBufferPointer[( px + w*(py + h*pz ))] += 1;
counterImageBufferPointer[( px + w*(py+1+ h*pz ))] += 1;
counterImageBufferPointer[( px + w*(py + h*pz+h))] += 1;
counterImageBufferPointer[( px + w*(py+1+ h*pz+h))] += 1;
counterImageBufferPointer[( px+1 + w*(py + h*pz ))] += 1;
counterImageBufferPointer[( px+1 + w*(py + h*pz+h))] += 1;
counterImageBufferPointer[( px+1 + w*(py+1+ h*pz ))] += 1;
counterImageBufferPointer[( px+1 + w*(py+1+ h*pz+h))] += 1;
}
typedef ImageRegionIterator< OutputImageType > OutImageIteratorType;
OutImageIteratorType outIt(outputImage, outputImage->GetLargestPossibleRegion());
outIt.GoToBegin();
typedef ImageRegionConstIterator< itk::Image< short, 3 > > CountImageIteratorType;
CountImageIteratorType counterIt(counterImage, counterImage->GetLargestPossibleRegion());
counterIt.GoToBegin();
while(!outIt.IsAtEnd() && !counterIt.IsAtEnd()){
if (counterIt.Value()>0)
outIt.Set(outIt.Value()/counterIt.Value());
++outIt;
++counterIt;
}
}
void DwiPhantomGenerationFilter< TOutputScalarType >
::GenerateData()
{
if (m_NoiseVariance < 0)
m_NoiseVariance = 0.001;
if (!m_SimulateBaseline)
{
MITK_INFO << "Baseline image values are set to default. Noise variance value is treated as SNR!";
if (m_NoiseVariance <= 0)
m_NoiseVariance = 0.0001;
if (m_NoiseVariance>99)
m_NoiseVariance = 0;
else
{
m_NoiseVariance = m_DefaultBaseline/(m_NoiseVariance*m_SignalScale);
m_NoiseVariance *= m_NoiseVariance;
}
}
m_RandGen = Statistics::MersenneTwisterRandomVariateGenerator::New();
m_RandGen->SetSeed();
typename OutputImageType::Pointer outImage = OutputImageType::New();
outImage->SetSpacing( m_Spacing );
outImage->SetOrigin( m_Origin );
outImage->SetDirection( m_DirectionMatrix );
outImage->SetLargestPossibleRegion( m_ImageRegion );
outImage->SetBufferedRegion( m_ImageRegion );
outImage->SetRequestedRegion( m_ImageRegion );
outImage->SetVectorLength(m_GradientList.size());
outImage->Allocate();
typename OutputImageType::PixelType pix;
pix.SetSize(m_GradientList.size());
pix.Fill(0.0);
outImage->FillBuffer(pix);
this->SetNthOutput (0, outImage);
double minSpacing = m_Spacing[0];
if (m_Spacing[1]<minSpacing)
minSpacing = m_Spacing[1];
if (m_Spacing[2]<minSpacing)
minSpacing = m_Spacing[2];
m_DirectionImageContainer = ItkDirectionImageContainer::New();
for (int i=0; i<m_SignalRegions.size(); i++)
{
itk::Vector< float, 3 > nullVec; nullVec.Fill(0.0);
ItkDirectionImage::Pointer img = ItkDirectionImage::New();
img->SetSpacing( m_Spacing );
img->SetOrigin( m_Origin );
img->SetDirection( m_DirectionMatrix );
img->SetRegions( m_ImageRegion );
img->Allocate();
img->FillBuffer(nullVec);
m_DirectionImageContainer->InsertElement(m_DirectionImageContainer->Size(), img);
}
m_NumDirectionsImage = ItkUcharImgType::New();
m_NumDirectionsImage->SetSpacing( m_Spacing );
m_NumDirectionsImage->SetOrigin( m_Origin );
m_NumDirectionsImage->SetDirection( m_DirectionMatrix );
m_NumDirectionsImage->SetRegions( m_ImageRegion );
m_NumDirectionsImage->Allocate();
m_NumDirectionsImage->FillBuffer(0);
m_SNRImage = ItkFloatImgType::New();
m_SNRImage->SetSpacing( m_Spacing );
m_SNRImage->SetOrigin( m_Origin );
m_SNRImage->SetDirection( m_DirectionMatrix );
m_SNRImage->SetRegions( m_ImageRegion );
m_SNRImage->Allocate();
m_SNRImage->FillBuffer(0);
vtkSmartPointer<vtkCellArray> m_VtkCellArray = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> m_VtkPoints = vtkSmartPointer<vtkPoints>::New();
m_BaselineImages = 0;
for( unsigned int i=0; i<m_GradientList.size(); i++)
if (m_GradientList[i].GetNorm()<=0.0001)
m_BaselineImages++;
typedef ImageRegionIterator<OutputImageType> IteratorOutputType;
IteratorOutputType it (outImage, m_ImageRegion);
// isotropic tensor
itk::DiffusionTensor3D<float> isoTensor;
isoTensor.Fill(0);
float e1 = m_GreyMatterAdc;
float e2 = m_GreyMatterAdc;
float e3 = m_GreyMatterAdc;
isoTensor.SetElement(0,e1);
isoTensor.SetElement(3,e2);
isoTensor.SetElement(5,e3);
m_MaxBaseline = GetTensorL2Norm(isoTensor);
GenerateTensors();
// simulate measurement
m_MeanBaseline = 0;
double noiseStdev = sqrt(m_NoiseVariance);
while(!it.IsAtEnd())
{
pix = it.Get();
typename OutputImageType::IndexType index = it.GetIndex();
int numDirs = 0;
for (int i=0; i<m_SignalRegions.size(); i++)
{
ItkUcharImgType::Pointer region = m_SignalRegions.at(i);
if (region->GetPixel(index)!=0)
{
numDirs++;
pix += SimulateMeasurement(m_TensorList[i], m_TensorWeight[i]);
// set direction image pixel
ItkDirectionImage::Pointer img = m_DirectionImageContainer->GetElement(i);
itk::Vector< float, 3 > pixel = img->GetPixel(index);
vnl_vector_fixed<double, 3> dir = m_TensorDirection.at(i);
dir.normalize();
dir *= m_TensorWeight.at(i);
pixel.SetElement(0, dir[0]);
pixel.SetElement(1, dir[1]);
pixel.SetElement(2, dir[2]);
img->SetPixel(index, pixel);
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
itk::ContinuousIndex<double, 3> center;
center[0] = index[0];
center[1] = index[1];
center[2] = index[2];
itk::Point<double> worldCenter;
outImage->TransformContinuousIndexToPhysicalPoint( center, worldCenter );
itk::Point<double> worldStart;
worldStart[0] = worldCenter[0]-dir[0]/2 * minSpacing;
worldStart[1] = worldCenter[1]-dir[1]/2 * minSpacing;
worldStart[2] = worldCenter[2]-dir[2]/2 * minSpacing;
vtkIdType id = m_VtkPoints->InsertNextPoint(worldStart.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
itk::Point<double> worldEnd;
worldEnd[0] = worldCenter[0]+dir[0]/2 * minSpacing;
worldEnd[1] = worldCenter[1]+dir[1]/2 * minSpacing;
worldEnd[2] = worldCenter[2]+dir[2]/2 * minSpacing;
id = m_VtkPoints->InsertNextPoint(worldEnd.GetDataPointer());
container->GetPointIds()->InsertNextId(id);
m_VtkCellArray->InsertNextCell(container);
}
}
if (numDirs>1)
{
for (int i=0; i<m_GradientList.size(); i++)
pix[i] /= numDirs;
}
else if (numDirs==0)
{
if (m_SimulateBaseline)
pix = SimulateMeasurement(isoTensor, 1.0);
else
pix.Fill(0.0);
}
m_MeanBaseline += pix[0];
it.Set(pix);
m_NumDirectionsImage->SetPixel(index, numDirs);
if (m_NoiseVariance>0)
m_SNRImage->SetPixel(index, pix[0]/(noiseStdev*m_SignalScale));
++it;
}
m_MeanBaseline /= m_ImageRegion.GetNumberOfPixels();
if (m_NoiseVariance>0)
MITK_INFO << "Mean SNR: " << m_MeanBaseline/(noiseStdev*m_SignalScale);
else
MITK_INFO << "No noise added";
// add rician noise
it.GoToBegin();
while(!it.IsAtEnd())
{
pix = it.Get();
AddNoise(pix);
it.Set(pix);
++it;
}
// generate fiber bundle
vtkSmartPointer<vtkPolyData> directionsPolyData = vtkSmartPointer<vtkPolyData>::New();
directionsPolyData->SetPoints(m_VtkPoints);
directionsPolyData->SetLines(m_VtkCellArray);
m_OutputFiberBundle = mitk::FiberBundleX::New(directionsPolyData);
}