ImageCalculatorFilterType::Pointer SBFilterUtils::GetMaxMinGrayValue(ImageType::Pointer image)
{
ImageCalculatorFilterType::Pointer imageCalculatorFilter = ImageCalculatorFilterType::New ();
imageCalculatorFilter->SetImage(image);
imageCalculatorFilter->Compute();
return imageCalculatorFilter;
}
void Difference::ComputeMinAndMaxInAllChannels()
{
std::cout << "ComputeMinAndMaxInAllChannels()" << std::endl;
this->MinimumOfChannels.SetSize(this->Image->GetNumberOfComponentsPerPixel());
this->MaximumOfChannels.SetSize(this->Image->GetNumberOfComponentsPerPixel());
for(unsigned int i = 0; i < this->Image->GetNumberOfComponentsPerPixel(); ++i)
{
typedef itk::VectorIndexSelectionCastImageFilter<ImageType, FloatScalarImageType> IndexSelectionType;
IndexSelectionType::Pointer indexSelectionFilter = IndexSelectionType::New();
indexSelectionFilter->SetIndex(i);
indexSelectionFilter->SetInput(this->Image);
indexSelectionFilter->Update();
typedef itk::MinimumMaximumImageCalculator <FloatScalarImageType> ImageCalculatorFilterType;
ImageCalculatorFilterType::Pointer imageCalculatorFilter = ImageCalculatorFilterType::New();
imageCalculatorFilter->SetImage(indexSelectionFilter->GetOutput());
imageCalculatorFilter->Compute();
this->MinimumOfChannels[i] = imageCalculatorFilter->GetMinimum();
this->MaximumOfChannels[i] = imageCalculatorFilter->GetMaximum();
}
}
bool AppITKImage::LoadAndValidate(const std::string& imagePath)
{
typedef itk::ImageFileReader<AppImageITKType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(imagePath);
reader->Update();
if(!m_image)
{
m_image = AppImageITKType::New();
}
// Deep copy
m_image->SetRegions(reader->GetOutput()->GetLargestPossibleRegion());
m_image->SetNumberOfComponentsPerPixel(LfnIc::Image::Pixel::NUM_CHANNELS);
m_image->Allocate();
itk::ImageRegionConstIterator<AppImageITKType> inputIterator(reader->GetOutput(), reader->GetOutput()->GetLargestPossibleRegion());
itk::ImageRegionIterator<AppImageITKType> outputIterator(m_image, m_image->GetLargestPossibleRegion());
while(!inputIterator.IsAtEnd())
{
outputIterator.Set(inputIterator.Get());
++inputIterator;
++outputIterator;
}
#if USE_CHANNEL_WEIGHTING
// Setup channel weights - Uniform weighting - set the weight of each channel so it has the perceived range of 255
// If a channel already has the range 255, the weight is set to 1. If a channel has a range smaller
// than 255, its weight will be > 1. If a channel has a weight larger than 255, its weight will be set to < 1.
// A weight should never be negative. There is no magic to scaling to 255, it is just that usually there will be some
// RGB type channels so 255 should make several of the weights close to 1.
std::cout << "Weights: ";
for (int c = 0; c < LfnIc::Image::Pixel::NUM_CHANNELS; c++)
{
typedef itk::Image<LfnIc::Image::Pixel::ChannelType, 2> ScalarImageType;
typedef itk::VectorIndexSelectionCastImageFilter<AppImageITKType, ScalarImageType> IndexSelectionType;
IndexSelectionType::Pointer indexSelectionFilter = IndexSelectionType::New();
indexSelectionFilter->SetIndex(c);
indexSelectionFilter->SetInput(m_image);
indexSelectionFilter->Update();
typedef itk::MinimumMaximumImageCalculator <ScalarImageType> ImageCalculatorFilterType;
ImageCalculatorFilterType::Pointer imageCalculatorFilter = ImageCalculatorFilterType::New();
imageCalculatorFilter->SetImage(indexSelectionFilter->GetOutput());
imageCalculatorFilter->Compute();
// If there is no variation in a channel (take an image with only red (255,0,0) and blue (0,0,255) pixels for example),
// then computing the weight doesn't make sense (and causes a divide by zero).
if( (imageCalculatorFilter->GetMaximum() - imageCalculatorFilter->GetMinimum()) <= 0)
{
m_channelWeights[c] = 1.0f;
}
else
{
m_channelWeights[c] = 255.0f / (imageCalculatorFilter->GetMaximum() - imageCalculatorFilter->GetMinimum());
}
std::cout << m_channelWeights[c] << " ";
}
std::cout << std::endl;
// Now that the weights have been calculated, apply them directly to the image data.
LfnIc::Image::Pixel* pixelPtr = AppITKImage::GetData();
for (int i = 0, n = GetWidth() * GetHeight(); i < n; ++i, ++pixelPtr)
{
LfnIc::Image::Pixel& pixel = *pixelPtr;
for (int c = 0; c < LfnIc::Image::Pixel::NUM_CHANNELS; ++c)
{
pixel.channel[c] *= m_channelWeights[c];
}
}
#endif // USE_CHANNEL_WEIGHTING
return true;
}
std::vector<cleaver::AbstractScalarField*>
NRRDTools::segmentationToIndicatorFunctions(std::string filename, double sigma) {
// read file using ITK
if (filename.find(".nrrd") != std::string::npos) {
itk::NrrdImageIOFactory::RegisterOneFactory();
} else if (filename.find(".mha") != std::string::npos) {
itk::MetaImageIOFactory::RegisterOneFactory();
}
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(filename);
reader->Update();
ImageType::Pointer image = reader->GetOutput();
//determine the number of labels in the segmentations
ImageCalculatorFilterType::Pointer imageCalculatorFilter
= ImageCalculatorFilterType::New();
imageCalculatorFilter->SetImage(reader->GetOutput());
imageCalculatorFilter->Compute();
auto maxLabel = static_cast<size_t>(imageCalculatorFilter->GetMaximum());
auto minLabel = static_cast<size_t>(imageCalculatorFilter->GetMinimum());
std::vector<cleaver::AbstractScalarField*> fields;
//extract images from each label for an indicator function
for (size_t i = minLabel, num = 0; i <= maxLabel; i++, num++) {
//pull out this label
ThreshType::Pointer thresh = ThreshType::New();
thresh->SetInput(image);
thresh->SetOutsideValue(0);
thresh->ThresholdOutside(static_cast<double>(i) - 0.001,
static_cast<double>(i) + 0.001);
thresh->Update();
//change the values to be from 0 to 1
MultiplyImageFilterType::Pointer multiplyImageFilter =
MultiplyImageFilterType::New();
multiplyImageFilter->SetInput(thresh->GetOutput());
multiplyImageFilter->SetConstant(1. / static_cast<double>(i));
multiplyImageFilter->Update();
//do some blurring
GaussianBlurType::Pointer blur = GaussianBlurType::New();
blur->SetInput(multiplyImageFilter->GetOutput());
blur->SetVariance(sigma * sigma);
blur->Update();
//find the average value between
ImageCalculatorFilterType::Pointer calc =
ImageCalculatorFilterType::New();
calc->SetImage(blur->GetOutput());
calc->Compute();
float mx = calc->GetMaximum();
float mn = calc->GetMinimum();
auto md = (mx + mn) / 2.f;
//create a distance map with that minimum value as the levelset
DMapType::Pointer dm = DMapType::New();
dm->SetInput(blur->GetOutput());
dm->SetInsideValue(md + 0.1f);
dm->SetOutsideValue(md -0.1f);
dm->Update();
//MultiplyImageFilterType::Pointer mult =
// MultiplyImageFilterType::New();
//mult->SetInput(blur->GetOutput());
//mult->SetConstant(-20. / (mx - mn));
//mult->Update();
/*SubtractImageFilterType::Pointer subtractFilter
= SubtractImageFilterType::New();
subtractFilter->SetInput1(mult->GetOutput());
subtractFilter->SetConstant2(1.);
subtractFilter->Update();*/
//convert the image to a cleaver "abstract field"
auto img = dm->GetOutput();
auto region = img->GetLargestPossibleRegion();
auto numPixel = region.GetNumberOfPixels();
float *data = new float[numPixel];
auto x = region.GetSize()[0], y = region.GetSize()[1], z = region.GetSize()[2];
fields.push_back(new cleaver::FloatField(data, x, y, z));
auto beg = filename.find_last_of("/") + 1;
auto name = filename.substr(beg, filename.size() - beg);
auto fin = name.find_last_of(".");
name = name.substr(0, fin);
std::stringstream ss;
ss << name << i;
fields[num]->setName(ss.str());
itk::ImageRegionConstIterator<ImageType> imageIterator(img, region);
size_t pixel = 0;
while (!imageIterator.IsAtEnd()) {
// Get the value of the current pixel
float val = static_cast<float>(imageIterator.Get());
((cleaver::FloatField*)fields[num])->data()[pixel++] = -val;
++imageIterator;
}
auto spacing = img->GetSpacing();
((cleaver::FloatField*)fields[num])->setScale(
cleaver::vec3(spacing[0], spacing[1], spacing[2]));
//NRRDTools::saveNRRDFile(fields[num], "a" + std::to_string(num));
}
return fields;
}
