void mitk::DCUtilities::MatrixToDC3d(const Eigen::MatrixXi &matrix, mitk::DataCollection::Pointer dc, const std::vector<std::string> &names, std::string mask)
{
typedef mitk::DataCollectionImageIterator<unsigned char, 3> DataIterType;
int numberOfNames = names.size();
mitk::DataCollectionImageIterator<unsigned char, 3> maskIter(dc, mask);
std::vector<DataIterType> dataIter;
for (int i = 0; i < numberOfNames; ++i)
{
EnsureUCharImageInDC(dc,names[i],mask);
DataIterType iter(dc, names[i]);
dataIter.push_back(iter);
}
int row = 0;
while ( ! maskIter.IsAtEnd() )
{
if (maskIter.GetVoxel() > 0)
{
for (int col = 0; col < numberOfNames; ++col)
{
(dataIter[col]).SetVoxel(matrix(row,col));
}
++row;
}
for (int col = 0; col < numberOfNames; ++col)
{
++(dataIter[col]);
}
++maskIter;
}
}
int mitk::DCUtilities::VoxelInMask(mitk::DataCollection::Pointer dc, std::string mask)
{
mitk::DataCollectionImageIterator<unsigned char, 3> maskIter(dc, mask);
int count = 0;
while ( ! maskIter.IsAtEnd() )
{
if (maskIter.GetVoxel() > 0)
++count;
++maskIter;
}
return count;
}
Eigen::MatrixXi mitk::DCUtilities::DC3dDToMatrixXi(mitk::DataCollection::Pointer dc, const std::vector<std::string> &names, std::string mask)
{
typedef mitk::DataCollectionImageIterator<unsigned char, 3> DataIterType;
int numberOfVoxels = DCUtilities::VoxelInMask(dc,mask);
int numberOfNames = names.size();
mitk::DataCollectionImageIterator<unsigned char, 3> maskIter(dc, mask);
std::vector<DataIterType> dataIter;
for (int i = 0; i < numberOfNames; ++i)
{
DataIterType iter(dc, names[i]);
dataIter.push_back(iter);
}
Eigen::MatrixXi result(numberOfVoxels, names.size());
result.setZero();
int row = 0;
while ( ! maskIter.IsAtEnd() )
{
if (maskIter.GetVoxel() > 0)
{
for (int col = 0; col < numberOfNames; ++col)
{
result(row,col) = dataIter[col].GetVoxel();
}
++row;
}
for (int col = 0; col < numberOfNames; ++col)
{
++(dataIter[col]);
}
++maskIter;
}
return result;
}
int main(int argc, char* argv[])
{
typedef itk::Image<double, 3> ImageType;
typedef itk::Image<unsigned char, 3> MaskImageType;
typedef ImageType::Pointer ImagePointerType;
typedef MaskImageType::Pointer MaskImagePointerType;
typedef itk::ImageRegionConstIterator<ImageType> ConstIteratorType;
typedef itk::ImageRegionConstIterator<MaskImageType> ConstMaskIteratorType;
typedef itk::ImageRegionIterator<ImageType> IteratorType;
typedef itk::ImageRegionIterator<MaskImageType> MaskIteratorType;
mitkCommandLineParser parser;
parser.setTitle("Remove empty voxels Sampling");
parser.setCategory("Classification Command Tools");
parser.setDescription("");
parser.setContributor("MBI");
parser.setArgumentPrefix("--", "-");
// Add command line argument names
parser.addArgument("help", "h", mitkCommandLineParser::Bool, "Help:", "Show this help text");
parser.addArgument("mask-input", "mi", mitkCommandLineParser::InputDirectory, "Input file:", "Input file", us::Any(), false);
parser.addArgument("mask-output", "mo", mitkCommandLineParser::OutputFile, "Output file:", "Output file", us::Any(), false);
for (int i = 0; i < 100; ++i)
{
std::stringstream s1; s1 << i; std::string number = s1.str();
parser.addArgument("input"+number, "i"+number, mitkCommandLineParser::OutputFile, "Input file", "input file", us::Any(), true);
parser.addArgument("output" + number, "o" + number, mitkCommandLineParser::OutputFile, "Output File", "Output file", us::Any(), true);
}
std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size() == 0)
return EXIT_FAILURE;
// Show a help message
if (parsedArgs.count("help") || parsedArgs.count("h"))
{
std::cout << parser.helpText();
return EXIT_SUCCESS;
}
// Load Mask Image and count number of non-zero voxels
mitk::Image::Pointer mask = mitk::IOUtil::Load<mitk::Image>(parsedArgs["mask-input"].ToString());
MaskImagePointerType itkMask = MaskImageType::New();
mitk::CastToItkImage(mask, itkMask);
ConstMaskIteratorType maskIter(itkMask, itkMask->GetLargestPossibleRegion());
std::size_t nonZero = 0;
while (!maskIter.IsAtEnd())
{
if (maskIter.Value() > 0)
{
++nonZero;
}
++maskIter;
}
maskIter.GoToBegin();
// Create new mask image
auto mitkNewMask = mitk::ImageGenerator::GenerateGradientImage<unsigned char>(nonZero, 1, 1, 1, 1, 1);
MaskImagePointerType itkNewMask = MaskImageType::New();
mitk::CastToItkImage(mitkNewMask, itkNewMask);
MaskIteratorType newMaskIter(itkNewMask, itkNewMask->GetLargestPossibleRegion());
// Read additional image
std::vector<mitk::Image::Pointer> mitkImagesVector;
std::vector<ImagePointerType> itkImageVector;
std::vector<ImagePointerType> itkOutputImageVector;
std::vector<ConstIteratorType> inputIteratorVector;
std::vector<IteratorType> outputIteratorVector;
for (int i = 0; i < 100; ++i)
{
std::stringstream s1; s1 << i; std::string number = s1.str();
if (parsedArgs.count("input" + number) < 1)
break;
if (parsedArgs.count("output" + number) < 1)
break;
mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(parsedArgs["input"+number].ToString());
mitkImagesVector.push_back(image);
ImagePointerType itkImage = ImageType::New();
mitk::CastToItkImage(image, itkImage);
itkImageVector.push_back(itkImage);
ConstIteratorType iter(itkImage, itkImage->GetLargestPossibleRegion());
inputIteratorVector.push_back(iter);
auto mitkNewImage = mitk::ImageGenerator::GenerateGradientImage<double>(nonZero, 1, 1, 1, 1, 1);
ImagePointerType itkNewOutput = ImageType::New();
mitk::CastToItkImage(mitkNewImage, itkNewOutput);
IteratorType outputIter(itkNewOutput, itkNewOutput->GetLargestPossibleRegion());
itkOutputImageVector.push_back(itkNewOutput);
outputIteratorVector.push_back(outputIter);
}
// Convert non-zero voxels to the new images
while (!maskIter.IsAtEnd())
{
if (maskIter.Value() > 0)
{
newMaskIter.Set(maskIter.Value());
++newMaskIter;
for (std::size_t i = 0; i < outputIteratorVector.size(); ++i)
{
outputIteratorVector[i].Set(inputIteratorVector[i].Value());
++(outputIteratorVector[i]);
}
}
++maskIter;
for (std::size_t i = 0; i < inputIteratorVector.size(); ++i)
{
++(inputIteratorVector[i]);
}
}
// Save the new images
for (std::size_t i = 0; i < outputIteratorVector.size(); ++i)
{
std::stringstream s1; s1 << i; std::string number = s1.str();
mitk::Image::Pointer mitkImage = mitk::Image::New();
mitk::CastToMitkImage(itkOutputImageVector[i], mitkImage);
mitk::IOUtil::Save(mitkImage, parsedArgs["output" + number].ToString());
}
// Save the new mask
{
mitk::Image::Pointer mitkImage = mitk::Image::New();
mitk::CastToMitkImage(itkNewMask, mitkImage);
mitk::IOUtil::Save(mitkImage, parsedArgs["mask-output"].ToString());
}
return EXIT_SUCCESS;
}
static int
CalculateGlSZMatrix(itk::Image<TPixel, VImageDimension>* itkImage,
itk::Image<unsigned short, VImageDimension>* mask,
std::vector<itk::Offset<VImageDimension> > offsets,
bool estimateLargestRegion,
mitk::GreyLevelSizeZoneMatrixHolder &holder)
{
typedef itk::Image<TPixel, VImageDimension> ImageType;
typedef itk::Image<unsigned short, VImageDimension> MaskImageType;
typedef typename ImageType::IndexType IndexType;
typedef itk::ImageRegionIteratorWithIndex<ImageType> ConstIterType;
typedef itk::ImageRegionIteratorWithIndex<MaskImageType> ConstMaskIterType;
auto region = mask->GetLargestPossibleRegion();
typename MaskImageType::RegionType newRegion;
newRegion.SetSize(region.GetSize());
newRegion.SetIndex(region.GetIndex());
ConstIterType imageIter(itkImage, itkImage->GetLargestPossibleRegion());
ConstMaskIterType maskIter(mask, mask->GetLargestPossibleRegion());
typename MaskImageType::Pointer visitedImage = MaskImageType::New();
visitedImage->SetRegions(newRegion);
visitedImage->Allocate();
visitedImage->FillBuffer(0);
int largestRegion = 0;
while (!maskIter.IsAtEnd())
{
if (maskIter.Value() > 0 )
{
auto startIntensityIndex = holder.IntensityToIndex(imageIter.Value());
std::vector<IndexType> indices;
indices.push_back(maskIter.GetIndex());
unsigned int steps = 0;
while (indices.size() > 0)
{
auto currentIndex = indices.back();
indices.pop_back();
if (!region.IsInside(currentIndex))
{
continue;
}
auto wasVisited = visitedImage->GetPixel(currentIndex);
auto newIntensityIndex = holder.IntensityToIndex(itkImage->GetPixel(currentIndex));
auto isInMask = mask->GetPixel(currentIndex);
if ((isInMask > 0) &&
(newIntensityIndex == startIntensityIndex) &&
(wasVisited < 1))
{
++steps;
visitedImage->SetPixel(currentIndex, 1);
for (auto offset : offsets)
{
auto newIndex = currentIndex + offset;
indices.push_back(newIndex);
newIndex = currentIndex - offset;
indices.push_back(newIndex);
}
}
}
if (steps > 0)
{
largestRegion = std::max<int>(steps, largestRegion);
steps = std::min<unsigned int>(steps, holder.m_MaximumSize);
if (!estimateLargestRegion)
{
holder.m_Matrix(startIntensityIndex, steps - 1) += 1;
}
}
}
++imageIter;
++maskIter;
}
return largestRegion;
}
