void mitk::MaskImageFilter::InternalComputeMask(itk::Image<TPixel, VImageDimension>* inputItkImage)
{
typedef itk::Image<TPixel, VImageDimension> ItkInputImageType;
typedef itk::Image<unsigned char, VImageDimension> ItkMaskImageType;
typedef itk::Image<TPixel, VImageDimension> ItkOutputImageType;
typedef itk::ImageRegionConstIterator< ItkInputImageType > ItkInputImageIteratorType;
typedef itk::ImageRegionConstIterator< ItkMaskImageType > ItkMaskImageIteratorType;
typedef itk::ImageRegionIteratorWithIndex< ItkOutputImageType > ItkOutputImageIteratorType;
typename mitk::ImageToItk<ItkMaskImageType>::Pointer maskimagetoitk = mitk::ImageToItk<ItkMaskImageType>::New();
maskimagetoitk->SetInput(m_MaskTimeSelector->GetOutput());
maskimagetoitk->Update();
typename ItkMaskImageType::Pointer maskItkImage = maskimagetoitk->GetOutput();
typename mitk::ImageToItk<ItkOutputImageType>::Pointer outputimagetoitk = mitk::ImageToItk<ItkOutputImageType>::New();
outputimagetoitk->SetInput(m_OutputTimeSelector->GetOutput());
outputimagetoitk->Update();
typename ItkOutputImageType::Pointer outputItkImage = outputimagetoitk->GetOutput();
// create the iterators
typename ItkInputImageType::RegionType inputRegionOfInterest = inputItkImage->GetLargestPossibleRegion();
ItkInputImageIteratorType inputIt( inputItkImage, inputRegionOfInterest );
ItkMaskImageIteratorType maskIt ( maskItkImage, inputRegionOfInterest );
ItkOutputImageIteratorType outputIt( outputItkImage, inputRegionOfInterest );
//typename ItkOutputImageType::PixelType outsideValue = itk::NumericTraits<typename ItkOutputImageType::PixelType>::min();
if ( !m_OverrideOutsideValue )
m_OutsideValue = itk::NumericTraits<typename ItkOutputImageType::PixelType>::min();
m_MinValue = (float)(itk::NumericTraits<typename ItkOutputImageType::PixelType>::max());
m_MaxValue = (float)(itk::NumericTraits<typename ItkOutputImageType::PixelType>::min());
for ( inputIt.GoToBegin(), maskIt.GoToBegin(), outputIt.GoToBegin(); !inputIt.IsAtEnd() && !maskIt.IsAtEnd(); ++inputIt, ++maskIt, ++outputIt)
{
if ( maskIt.Get() > itk::NumericTraits<typename ItkMaskImageType::PixelType>::Zero )
{
outputIt.Set(inputIt.Get());
m_MinValue = vnl_math_min((float)inputIt.Get(), (float)m_MinValue);
m_MaxValue = vnl_math_max((float)inputIt.Get(), (float)m_MaxValue);
}
else
{
outputIt.Set(m_OutsideValue);
}
}
}
void mitk::AutoCropImageFilter::ComputeNewImageBounds()
{
mitk::Image::ConstPointer inputMitk = this->GetInput();
if (m_OverrideCroppingRegion)
{
for (unsigned int i=0; i<3; ++i)
{
m_RegionIndex[i] = m_CroppingRegion.GetIndex()[i];
m_RegionSize[i] = m_CroppingRegion.GetSize()[i];
if (m_RegionIndex[i] >= inputMitk->GetDimension(i))
{
itkExceptionMacro("Cropping index is not inside the image. "
<< std::endl << "Index:"
<< std::endl << m_CroppingRegion.GetIndex()
<< std::endl << "Size:"
<< std::endl << m_CroppingRegion.GetSize());
}
if (m_RegionIndex[i] + m_RegionSize[i] >= inputMitk->GetDimension(i))
{
m_RegionSize[i] = inputMitk->GetDimension(i) - m_RegionIndex[i];
}
}
for (unsigned int i=0; i<3; ++i)
{
m_RegionIndex[i] = m_CroppingRegion.GetIndex()[i];
m_RegionSize[i] = m_CroppingRegion.GetSize()[i];
}
}
else
{
// Check if a 3D or 4D image is present
unsigned int timeSteps = 1;
if (inputMitk->GetDimension() == 4 )
timeSteps = inputMitk->GetDimension(3);
ImageType::IndexType minima,maxima;
if (inputMitk->GetDimension() == 4)
{
// initialize with time step 0
m_TimeSelector = mitk::ImageTimeSelector::New();
m_TimeSelector->SetInput( inputMitk );
m_TimeSelector->SetTimeNr( 0 );
m_TimeSelector->UpdateLargestPossibleRegion();
inputMitk = m_TimeSelector->GetOutput();
}
ImagePointer inputItk = ImageType::New();
mitk::CastToItkImage( inputMitk , inputItk );
// it is assumed that all volumes in a time series have the same 3D dimensions
ImageType::RegionType origRegion = inputItk->GetLargestPossibleRegion();
// Initialize min and max on the first (or only) time step
maxima = inputItk->GetLargestPossibleRegion().GetIndex();
minima[0] = inputItk->GetLargestPossibleRegion().GetSize()[0];
minima[1] = inputItk->GetLargestPossibleRegion().GetSize()[1];
minima[2] = inputItk->GetLargestPossibleRegion().GetSize()[2];
typedef itk::ImageRegionConstIterator< ImageType > ConstIteratorType;
for(unsigned int idx = 0; idx < timeSteps; ++idx)
{
// if 4D image, update time step and itk image
if( idx > 0)
{
m_TimeSelector->SetTimeNr( idx );
m_TimeSelector->UpdateLargestPossibleRegion();
inputMitk = m_TimeSelector->GetOutput();
mitk::CastToItkImage( inputMitk , inputItk );
}
ConstIteratorType inIt( inputItk, origRegion );
for ( inIt.GoToBegin(); !inIt.IsAtEnd(); ++inIt)
{
float pix_val = inIt.Get();
if ( fabs(pix_val - m_BackgroundValue) > mitk::eps )
{
for (int i=0; i < 3; i++)
{
minima[i] = vnl_math_min((int)minima[i],(int)(inIt.GetIndex()[i]));
maxima[i] = vnl_math_max((int)maxima[i],(int)(inIt.GetIndex()[i]));
}
}
}
}
typedef ImageType::RegionType::SizeType::SizeValueType SizeValueType;
m_RegionSize[0] = (SizeValueType)(m_MarginFactor * (maxima[0] - minima[0] + 1 ));
m_RegionSize[1] = (SizeValueType)(m_MarginFactor * (maxima[1] - minima[1] + 1 ));
m_RegionSize[2] = (SizeValueType)(m_MarginFactor * (maxima[2] - minima[2] + 1 ));
m_RegionIndex = minima;
m_RegionIndex[0] -= (m_RegionSize[0] - maxima[0] + minima[0] - 1 )/2;
m_RegionIndex[1] -= (m_RegionSize[1] - maxima[1] + minima[1] - 1 )/2;
m_RegionIndex[2] -= (m_RegionSize[2] - maxima[2] + minima[2] - 1 )/2;
ImageType::RegionType cropRegion(m_RegionIndex,m_RegionSize);
origRegion.Crop(cropRegion);
m_RegionSize[0] = origRegion.GetSize()[0];
m_RegionSize[1] = origRegion.GetSize()[1];
m_RegionSize[2] = origRegion.GetSize()[2];
m_RegionIndex[0] = origRegion.GetIndex()[0];
m_RegionIndex[1] = origRegion.GetIndex()[1];
m_RegionIndex[2] = origRegion.GetIndex()[2];
m_CroppingRegion = origRegion;
}
}
float
rich_cell::
compute_average_intensity( ImageType::Pointer intensity_image, LabelImageType::ConstPointer label_image, int dist_interior, int dist_exterior)
{
float sum_interior = 0;
float sum_exterior = 0;
int count_interior = 0;
int count_exterior = 0;
if (dist_exterior < dist_interior) { // the entire segmented area is taken
for (unsigned int b = 0; b<all_points_.size(); b++) {
vnl_vector_fixed< float, 3 > const & pt = all_points_[b];
ImageType::IndexType pos;
pos[0] = pt[0];
pos[1] = pt[1];
pos[2] = pt[2];
sum_interior += intensity_image->GetPixel(pos);
}
return sum_interior/all_points_.size();
}
RegionType region = bounding_box_;
if (dist_interior < 0) { //erode the mask
// Generate a mask image of the cell region. Erode the region by
// r_interior
RegionType::SizeType size = region.GetSize();
RegionType::IndexType start={{0,0,0}};
ImageType::Pointer cropped_mask = ImageType::New();
RegionType mask_region;
mask_region.SetIndex( start );
mask_region.SetSize( size );
cropped_mask->SetRegions( mask_region );
cropped_mask->Allocate();
cropped_mask->FillBuffer(0);
LabelConstRegionIteratorType it1( label_image, region);
RegionIteratorType it2( cropped_mask, mask_region );
for (it1.GoToBegin(), it2.GoToBegin(); !it1.IsAtEnd(); ++it1, ++it2) {
if (it1.Get() == label_)
it2.Set( 255 );
}
ImageType::Pointer eroded_mask;
ErodeFilterType::Pointer f_erode = ErodeFilterType::New();
SubFilterType::Pointer f_sub = SubFilterType::New();
StructuringElementType structuringElement;
structuringElement.SetRadius( -dist_interior );
structuringElement.CreateStructuringElement();
f_erode->SetKernel( structuringElement );
f_erode->SetInput(cropped_mask);
f_sub->SetInput1( cropped_mask );
f_sub->SetInput2( f_erode->GetOutput() );
try {
f_sub->Update();
}
catch (itk::ExceptionObject & e) {
std::cerr << "Exception in SubFilter: " << e << std::endl;
exit(0);
}
eroded_mask = f_sub->GetOutput();
// Sum the signal in the eroded region only
ConstRegionIteratorType it3( eroded_mask, mask_region );
ConstRegionIteratorType it4( intensity_image, region);
for (it3.GoToBegin(), it4.GoToBegin(); !it3.IsAtEnd(); ++it1, ++it3, ++it4) {
if (it3.Get() > 0) {
sum_interior += it4.Get();
count_interior ++;
}
}
}
if (dist_exterior > 0) { //dilate the mask
// enlarge the bounding box by r on each side.
RegionType::SizeType image_size = intensity_image->GetLargestPossibleRegion().GetSize();
RegionType::SizeType size = region.GetSize();
RegionType::IndexType start = region.GetIndex();
RegionType::IndexType end;
end[0] = vnl_math_min(start[0]+size[0]+dist_exterior, image_size[0]);
end[1] = vnl_math_min(start[1]+size[1]+dist_exterior, image_size[1]);
end[2] = vnl_math_min(start[2]+size[2]+dist_exterior, image_size[2]);
start[0] = vnl_math_max(int(start[0]-dist_exterior), 0);
start[1] = vnl_math_max(int(start[1]-dist_exterior), 0);
start[2] = vnl_math_max(int(start[2]-dist_exterior), 0);
size[0] = end[0] - start[0];
size[1] = end[1] - start[1];
size[2] = end[2] - start[2];
region.SetSize( size );
region.SetIndex( start );
// Generate a mask image of the region just found. Dilate the
// region defined by the segmentation by r.
ImageType::Pointer cropped_mask = ImageType::New();
RegionType mask_region;
start[0] = start[1] = start[2] = 0;
mask_region.SetIndex( start );
mask_region.SetSize( size );
cropped_mask->SetRegions( mask_region );
cropped_mask->Allocate();
cropped_mask->FillBuffer(0);
LabelConstRegionIteratorType it1( label_image, region);
RegionIteratorType it2( cropped_mask, mask_region );
for (it1.GoToBegin(), it2.GoToBegin(); !it1.IsAtEnd(); ++it1, ++it2) {
if (it1.Get() == label_)
it2.Set( 255 );
}
ImageType::Pointer dilated_mask;
DilateFilterType::Pointer f_dilate = DilateFilterType::New();
SubFilterType::Pointer f_sub = SubFilterType::New();
StructuringElementType structuringElement;
structuringElement.SetRadius( dist_exterior );
structuringElement.CreateStructuringElement();
f_dilate->SetKernel( structuringElement );
f_dilate->SetInput(cropped_mask);
f_sub->SetInput1( f_dilate->GetOutput() );
f_sub->SetInput2( cropped_mask );
try {
f_sub->Update();
}
catch (itk::ExceptionObject & e) {
std::cerr << "Exception in SubFilter: " << e << std::endl;
exit(0);
}
dilated_mask = f_sub->GetOutput();
// Sum the signal in the dilated region only
ConstRegionIteratorType it3( dilated_mask, mask_region );
ConstRegionIteratorType it4( intensity_image, region);
for (it3.GoToBegin(), it4.GoToBegin(); !it3.IsAtEnd(); ++it1, ++it3, ++it4) {
if (it3.Get() > 0) {
sum_exterior += it4.Get();
count_exterior ++;
}
}
}
// average the interior and exterior signals
return (sum_interior+sum_exterior)/float(count_interior+count_exterior);
}