// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void Watershed::execute()
{
//int err = 0;
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getSelectedCellArrayPath().getDataContainerName());
QString attrMatName = getSelectedCellArrayPath().getAttributeMatrixName();
//wrap m_RawImageData as itk::image
ImageProcessing::DefaultImageType::Pointer inputImage = ITKUtilitiesType::CreateItkWrapperForDataPointer(m, attrMatName, m_SelectedCellArray);
//create gradient magnitude filter
notifyStatusMessage(getHumanLabel(), "Calculating Gradient Magnitude");
typedef itk::GradientMagnitudeImageFilter<ImageProcessing::DefaultImageType, ImageProcessing::DefaultImageType > GradientMagnitudeImageFilterType;
GradientMagnitudeImageFilterType::Pointer gradientMagnitudeImageFilter = GradientMagnitudeImageFilterType::New();
gradientMagnitudeImageFilter->SetInput(inputImage);
gradientMagnitudeImageFilter->Update();
//watershed image
notifyStatusMessage(getHumanLabel(), "Watershedding");
typedef itk::WatershedImageFilter<ImageProcessing::DefaultImageType> WatershedFilterType;
WatershedFilterType::Pointer watershed = WatershedFilterType::New();
watershed->SetThreshold(m_Threshold);
watershed->SetLevel(m_Level);
watershed->SetInput(gradientMagnitudeImageFilter->GetOutput());
//execute filter
try
{
watershed->Update();
}
catch( itk::ExceptionObject& err )
{
setErrorCondition(-5);
QString ss = QObject::tr("Failed to execute itk::GradientMagnitudeImageFilter filter. Error Message returned from ITK:\n %1").arg(err.GetDescription());
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
//get output and copy to grainids
typedef itk::Image<unsigned long, ImageProcessing::ImageDimension> WatershedImageType;
WatershedImageType::Pointer output = watershed->GetOutput();
WatershedImageType::RegionType filterRegion = output->GetLargestPossibleRegion();
typedef itk::ImageRegionConstIterator<itk::Image<unsigned long, ImageProcessing::ImageDimension> > WatershedIteratorType;
WatershedIteratorType it(output, filterRegion);
it.GoToBegin();
int index = 0;
while(!it.IsAtEnd())
{
m_FeatureIds[index] = it.Get();
++it;
++index;
}
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
int
main(int argc, char* argv[])
{
boost::filesystem::path inputFile;
boost::filesystem::path outputFile;
Algorithm algorithm;
std::string algorithmName;
po::options_description desc("Allowed options");
desc.add_options()
("help", "produce help message")
("input,i", po::value<boost::filesystem::path>(&inputFile), "input file")
("algorithm,a", po::value<std::string>(&algorithmName)->default_value("itk-implementation"), "itk-implementation")
("output,o", po::value<boost::filesystem::path>(&outputFile), "output mask file")
;
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);
algorithm = getAlgorithmFromString(algorithmName);
if (vm.count("help")) {
std::cout << desc << "\n";
return 1;
}
if (vm.count("input") == 0) {
std::cout << "Missing input filename\n" << desc << "\n";
return 1;
}
if (vm.count("output") == 0) {
std::cout << "Missing output filename\n" << desc << "\n";
return 1;
}
typedef itk::ImageFileReader<ImageType> ImageReaderType;
BOOST_LOG_TRIVIAL(info) << "Loading inputs ...";
ImageReaderType::Pointer imageReader = ImageReaderType::New();
imageReader->SetFileName(inputFile.string());
imageReader->Update();
ImageType::Pointer image = imageReader->GetOutput();
LabeledImageType::Pointer outputImage;
switch (algorithm) {
case Algorithm::ItkImplementation: {
BOOST_LOG_TRIVIAL(info) << "Running ITK version of watershed transformation ...";
WatershedFilterType::Pointer filter = WatershedFilterType::New();
filter->SetInput(image);
filter->MarkWatershedLineOff();
boost::timer::cpu_timer computationTimer;
computationTimer.start();
filter->Update();
BOOST_LOG_TRIVIAL(info) << "Computation time: " << computationTimer.format(9, "%w");
outputImage = filter->GetOutput();
}
break;
default:
BOOST_LOG_TRIVIAL(info) << "Allocating output ...";
outputImage = LabeledImageType::New();
outputImage->SetRegions(image->GetLargestPossibleRegion());
outputImage->Allocate();
outputImage->SetSpacing(image->GetSpacing());
BOOST_LOG_TRIVIAL(info) << "Running CUDA version of watershed transformation (topographical distance)...";
boost::timer::cpu_timer computationTimer;
computationTimer.start();
watershedTransformation2(
cugip::const_view(*(image.GetPointer())),
cugip::view(*(outputImage.GetPointer())),
Options()
);
BOOST_LOG_TRIVIAL(info) << "Computation time: " << computationTimer.format(9, "%w");
//BOOST_LOG_TRIVIAL(error) << "Unknown algorithm";
}
BOOST_LOG_TRIVIAL(info) << "Saving output `" << outputFile << "` ...";
WriterType::Pointer writer = WriterType::New();
writer->SetFileName(outputFile.string());
writer->SetInput(outputImage);
try {
writer->Update();
} catch (itk::ExceptionObject & error) {
std::cerr << "Error: " << error << std::endl;
return EXIT_FAILURE;
}
return 0;
}
