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; }