void TestExtractChannels()
{
typedef itk::VectorImage<float, 2> VectorImageType;
VectorImageType::Pointer image = VectorImageType::New();
itk::Index<2> corner = {{0,0}};
itk::Size<2> size = {{100,100}};
itk::ImageRegion<2> region(corner, size);
image->SetRegions(region);
image->SetNumberOfComponentsPerPixel(3);
image->Allocate();
// Extract the first two channels
std::vector<unsigned int> channels;
channels.push_back(0);
channels.push_back(1);
typedef itk::VectorImage<float, 2> FloatScalarImageType;
FloatScalarImageType::Pointer floatScalarImage = FloatScalarImageType::New();
ITKHelpers::ExtractChannels(image.GetPointer(), channels, floatScalarImage.GetPointer());
typedef itk::VectorImage<unsigned char, 2> UnsignedCharScalarImageType;
UnsignedCharScalarImageType::Pointer unsignedCharScalarImage = UnsignedCharScalarImageType::New();
ITKHelpers::ExtractChannels(image.GetPointer(), channels, unsignedCharScalarImage.GetPointer());
}
int main(int argc, char*argv[])
{
Mask::Pointer mask = Mask::New();
CreateMask(mask);
OutputHelpers::WriteImage(mask.GetPointer(), "mask.png");
UnsignedCharScalarImageType::Pointer image = UnsignedCharScalarImageType::New();
CreateImage(image);
OutputHelpers::WriteImage(image.GetPointer(), "image.png");
FloatScalarImageType::Pointer output = FloatScalarImageType::New();
MaskOperations::MaskedLaplacian(image.GetPointer(), mask.GetPointer(), output.GetPointer());
OutputHelpers::WriteImage(output.GetPointer(), "laplacian.mha");
return EXIT_SUCCESS;
}
void Difference::CreateDepthImage(FloatScalarImageType::Pointer image)
{
image->SetRegions(this->Image->GetLargestPossibleRegion());
image->Allocate();
image->FillBuffer(0);
itk::ImageRegionIterator<ImageType> fullImageIterator(this->Image, this->Image->GetLargestPossibleRegion());
itk::ImageRegionIterator<FloatScalarImageType> rgbImageIterator(image, image->GetLargestPossibleRegion());
while(!fullImageIterator.IsAtEnd())
{
ImageType::PixelType fullPixel = fullImageIterator.Get();
float depthPixel = fullPixel[3];
rgbImageIterator.Set(depthPixel);
++fullImageIterator;
++rgbImageIterator;
}
}
void TestExtractChannel()
{
typedef itk::VectorImage<float, 2> VectorImageType;
VectorImageType::Pointer image = VectorImageType::New();
itk::Index<2> corner = {{0,0}};
itk::Size<2> size = {{100,100}};
itk::ImageRegion<2> region(corner, size);
image->SetRegions(region);
image->SetNumberOfComponentsPerPixel(2);
image->Allocate();
typedef itk::Image<float, 2> FloatScalarImageType;
FloatScalarImageType::Pointer floatScalarImage = FloatScalarImageType::New();
ITKHelpers::ExtractChannel(image.GetPointer(), 0, floatScalarImage.GetPointer());
typedef itk::Image<unsigned char, 2> UnsignedCharScalarImageType;
UnsignedCharScalarImageType::Pointer unsignedCharScalarImage = UnsignedCharScalarImageType::New();
ITKHelpers::ExtractChannel(image.GetPointer(), 0, unsignedCharScalarImage.GetPointer());
}
void ComputeColorIsophotesInRegion(const TVectorImageType* const image, const Mask* const mask,
const itk::ImageRegion<2>& region , TIsophoteImageType* const isophotes)
{
/*
* 'isophotes' must already be initialized to the right size and allocated.
*/
//EnterFunction("ComputeIsophotes()");
RGBImageType::Pointer rgbImage = RGBImageType::New();
ITKHelpers::VectorImageToRGBImage(image, rgbImage);
//HelpersOutput::WriteImageConditional<RGBImageType>(rgbImage, "Debug/Initialize.rgb.mha", this->DebugImages);
typedef itk::RGBToLuminanceImageFilter< RGBImageType, FloatScalarImageType > LuminanceFilterType;
LuminanceFilterType::Pointer luminanceFilter = LuminanceFilterType::New();
luminanceFilter->SetInput(rgbImage);
luminanceFilter->Update();
FloatScalarImageType::Pointer luminanceImage = FloatScalarImageType::New();
ITKHelpers::DeepCopy(luminanceFilter->GetOutput(), luminanceImage.GetPointer());
FloatScalarImageType::Pointer blurredLuminance = FloatScalarImageType::New();
// Blur with a Gaussian kernel. From TestIsophotes.cpp, it actually seems like not blurring,
// but using a masked sobel operator produces the most reliable isophotes.
unsigned int kernelRadius = 0;
MaskOperations::MaskedBlur(luminanceFilter->GetOutput(), mask,
kernelRadius, blurredLuminance.GetPointer());
//HelpersOutput::WriteImageConditional(blurredLuminance,
// "Debug/Initialize.blurredLuminance.mha", true);
//ITKHelpers::InitializeImage(isophotes, image->GetLargestPossibleRegion());
Isophotes::ComputeMaskedIsophotesInRegion(blurredLuminance.GetPointer(), mask, region, isophotes);
// if(this->DebugImages)
// {
// HelpersOutput::Write2DVectorImage(this->IsophoteImage, "Debug/Initialize.IsophoteImage.mha");
// }
//LeaveFunction("ComputeIsophotes()");
}
void FullPatchScalarComparison()
{
std::cout << "FullPatchScalarComparison()" << std::endl;
FloatScalarImageType::Pointer scalarImage = FloatScalarImageType::New();
Testing::GetBlankImage<FloatScalarImageType>(scalarImage);
// Make the left half of the image 0, and the right half 5
itk::ImageRegionIterator<FloatScalarImageType> imageIterator(scalarImage, scalarImage->GetLargestPossibleRegion());
while(!imageIterator.IsAtEnd())
{
if(imageIterator.GetIndex()[0] < static_cast<int>(scalarImage->GetLargestPossibleRegion().GetSize()[0]/2))
{
imageIterator.Set(0);
}
else
{
imageIterator.Set(5);
}
++imageIterator;
}
itk::Size<2> patchSize;
patchSize.Fill(10);
std::cout << "Full patch different test." << std::endl;
// Full patch is different
{
itk::Index<2> sourceCorner;
sourceCorner.Fill(0);
itk::ImageRegion<2> sourceRegion(sourceCorner, patchSize);
ImagePatchPixelDescriptor<FloatScalarImageType> sourcePatch(scalarImage, sourceRegion, true);
itk::Index<2> targetCorner;
targetCorner.Fill(scalarImage->GetLargestPossibleRegion().GetSize()[0]/2 + 4); // No magic about 4, just want a patch on the right side of the image
itk::ImageRegion<2> targetRegion(targetCorner, patchSize);
ImagePatchPixelDescriptor<FloatScalarImageType> targetPatch(scalarImage, targetRegion, true);
std::cout << "targetPatch: " << targetPatch << std::endl;
PatchPair<FloatScalarImageType> patchPair(&sourcePatch, targetPatch);
PatchDifferencePixelWiseSum<FloatScalarImageType, PixelDifference> scalar_patchDifferencePixelWiseSum;
scalar_patchDifferencePixelWiseSum.SetImage(scalarImage);
float difference = scalar_patchDifferencePixelWiseSum.Difference(patchPair);
std::cout << "Number of pixels: " << targetPatch.GetRegion().GetNumberOfPixels() << std::endl;
float correctDifference = targetPatch.GetRegion().GetNumberOfPixels() * 5;
if(difference != correctDifference)
{
std::stringstream ss;
ss << "Difference " << difference << " does not match correctDifference " << correctDifference;
throw std::runtime_error(ss.str());
}
}
std::cout << "Identical patch test." << std::endl;
// Patches are identical
{
itk::Index<2> sourceCorner;
sourceCorner.Fill(0);
itk::ImageRegion<2> sourceRegion(sourceCorner, patchSize);
ImagePatchPixelDescriptor<FloatScalarImageType> sourcePatch(scalarImage, sourceRegion, true);
itk::Index<2> targetCorner;
targetCorner.Fill(10); // No magic about 10, just want a patch not at (0,0) but still fully on the left side of the image
itk::ImageRegion<2> targetRegion(targetCorner, patchSize);
ImagePatchPixelDescriptor<FloatScalarImageType> targetPatch(scalarImage, targetRegion, true);
PatchPair<FloatScalarImageType> patchPair(&sourcePatch, targetPatch);
PatchDifferencePixelWiseSum<FloatScalarImageType, PixelDifference> scalar_patchDifferencePixelWiseSum;
scalar_patchDifferencePixelWiseSum.SetImage(scalarImage);
float difference = scalar_patchDifferencePixelWiseSum.Difference(patchPair);
float correctDifference = 0;
if(difference != correctDifference)
{
std::stringstream ss;
ss << "Difference " << difference << " does not match correctDifference " << correctDifference;
throw std::runtime_error(ss.str());
}
}
}
int main(int argc, char *argv[])
{
if(argc != 3)
{
std::cerr << "Required arguments: image mask" << std::endl;
return EXIT_FAILURE;
}
std::string imageFilename = argv[1];
std::string maskFilename = argv[2];
std::cout << "Reading image: " << imageFilename << std::endl;
std::cout << "Reading mask: " << maskFilename << std::endl;
typedef itk::ImageFileReader<FloatVectorImageType> ImageReaderType;
ImageReaderType::Pointer imageReader = ImageReaderType::New();
imageReader->SetFileName(imageFilename.c_str());
imageReader->Update();
std::cout << "Read image " << imageReader->GetOutput()->GetLargestPossibleRegion() << std::endl;
typedef itk::ImageFileReader<Mask> MaskReaderType;
MaskReaderType::Pointer maskReader = MaskReaderType::New();
maskReader->SetFileName(maskFilename.c_str());
maskReader->Update();
std::cout << "Read mask " << maskReader->GetOutput()->GetLargestPossibleRegion() << std::endl;
// Prepare image
RGBImageType::Pointer rgbImage = RGBImageType::New();
// Helpers::VectorImageToRGBImage(imageReader->GetOutput(), rgbImage);
// TODO: Update this call to new API
//maskReader->GetOutput()->ApplyToImage(rgbImage.GetPointer(), Qt::black);
OutputHelpers::WriteImage<RGBImageType>(rgbImage, "Test/TestIsophotes.rgb.mha");
typedef itk::RGBToLuminanceImageFilter< RGBImageType, FloatScalarImageType > LuminanceFilterType;
LuminanceFilterType::Pointer luminanceFilter = LuminanceFilterType::New();
luminanceFilter->SetInput(rgbImage);
luminanceFilter->Update();
OutputHelpers::WriteImage<FloatScalarImageType>(luminanceFilter->GetOutput(), "Test/Luminance.mha");
// PatchBasedInpainting inpainting;
// inpainting.SetDebugImages(true);
// inpainting.SetMask(maskReader->GetOutput());
// inpainting.SetImage(imageReader->GetOutput());
//Helpers::Write2DVectorImage(inpainting.GetIsophoteImage(), "Test/TestIsophotes.isophotes.mha");
//inpainting.FindBoundary();
// After blurVariance == 4, you cannot tell the difference in the output.
for(unsigned int blurVariance = 0; blurVariance < 5; ++blurVariance)
{
std::string fileNumber = Helpers::ZeroPad(blurVariance, 2);
FloatScalarImageType::Pointer blurredLuminance = FloatScalarImageType::New();
// Blur with a Gaussian kernel
MaskOperations::MaskedBlur(luminanceFilter->GetOutput(), maskReader->GetOutput(),
blurVariance, blurredLuminance.GetPointer());
std::stringstream ssBlurredLuminance;
ssBlurredLuminance << "Test/BlurredLuminance_" << fileNumber << ".mha";
OutputHelpers::WriteImage(blurredLuminance.GetPointer(), ssBlurredLuminance.str());
//Helpers::WriteImage<FloatScalarImageType>(blurredLuminance, "Test/TestIsophotes.blurred.mha");
FloatVector2ImageType::Pointer gradient = FloatVector2ImageType::New();
Derivatives::MaskedGradient(blurredLuminance.GetPointer(), maskReader->GetOutput(), gradient.GetPointer());
// Boundary gradient
typedef itk::MaskImageFilter< FloatVector2ImageType, UnsignedCharScalarImageType, FloatVector2ImageType > MaskFilterType;
MaskFilterType::Pointer maskFilter = MaskFilterType::New();
maskFilter->SetInput(gradient);
//maskFilter->SetMaskImage(inpainting.GetBoundaryImage());
maskFilter->Update();
vtkSmartPointer<vtkPolyData> boundaryGradient = vtkSmartPointer<vtkPolyData>::New();
// TODO: Convert this call to new API
//Helpers::ConvertNonZeroPixelsToVectors(maskFilter->GetOutput(), boundaryGradient);
std::stringstream ssPolyData;
ssPolyData << "Test/BoundaryGradient_" << fileNumber << ".vtp";
OutputHelpers::WritePolyData(boundaryGradient, ssPolyData.str());
}
return EXIT_SUCCESS;
}
void LidarSegmentationWidget::GenerateNeighborSinks()
{
Mask::Pointer sourcesImage = Mask::New();
sourcesImage->SetRegions(this->ImageRegion);
ITKHelpers::IndicesToBinaryImage(this->Sources, sourcesImage);
ITKHelpers::WriteImage(sourcesImage.GetPointer(), "sourcesImage.png");
// Dilate the mask
std::cout << "Dilating mask..." << std::endl;
typedef itk::BinaryBallStructuringElement<Mask::PixelType, 2> StructuringElementType;
StructuringElementType structuringElement;
structuringElement.SetRadius(1);
structuringElement.CreateStructuringElement();
typedef itk::BinaryDilateImageFilter<Mask, Mask, StructuringElementType> BinaryDilateImageFilterType;
BinaryDilateImageFilterType::Pointer dilateFilter = BinaryDilateImageFilterType::New();
dilateFilter->SetInput(sourcesImage);
dilateFilter->SetKernel(structuringElement);
dilateFilter->Update();
// Binary XOR the images to get the difference image
//std::cout << "XORing masks..." << std::endl;
typedef itk::XorImageFilter<Mask> XorImageFilterType;
XorImageFilterType::Pointer xorFilter = XorImageFilterType::New();
xorFilter->SetInput1(dilateFilter->GetOutput());
xorFilter->SetInput2(sourcesImage);
xorFilter->Update();
ITKHelpers::WriteImage(xorFilter->GetOutput(), "boundaryOfSegmentation.png");
// Iterate over the border pixels. If the closest pixel in the original segmentation has
// a depth greater than a threshold, mark it as a new sink. Else, do not.
std::cout << "Determining which boundary pixels should be declared background..." << std::endl;
//std::cout << "There should be " << Helpers::CountNonZeroPixels(xorFilter->GetOutput())
// << " considered." << std::endl;
typedef std::vector<itk::Index<2> > VectorOfPixelsType;
VectorOfPixelsType newSinks;
typedef itk::VectorIndexSelectionCastImageFilter<ImageType, FloatScalarImageType> IndexSelectionType;
IndexSelectionType::Pointer indexSelectionFilter = IndexSelectionType::New();
indexSelectionFilter->SetIndex(3);
indexSelectionFilter->SetInput(this->Image);
indexSelectionFilter->Update();
FloatScalarImageType::Pointer depthImage = indexSelectionFilter->GetOutput();
//float sameObjectThreshold = 0.1f;
VectorOfPixelsType consideredPixels;
itk::ImageRegionIterator<Mask> imageIterator(xorFilter->GetOutput(),
xorFilter->GetOutput()->GetLargestPossibleRegion());
while(!imageIterator.IsAtEnd())
{
if(imageIterator.Get()) // If the current pixel is in question
{
consideredPixels.push_back(imageIterator.GetIndex());
}
++imageIterator;
}
std::cout << "There are " << consideredPixels.size() << " potential new sink pixels." << std::endl;
for(VectorOfPixelsType::const_iterator iter = consideredPixels.begin(); iter != consideredPixels.end(); ++iter)
{
//std::cout << "Considering pixel " << consideredCounter << " (index "
// << imageIterator.GetIndex() << ")" << std::endl;
ImageType::PixelType currentPixel = this->Image->GetPixel(*iter);
unsigned int radius = this->txtBackgroundCheckRadius->text().toUInt();
ImageType::RegionType desiredRegion = ITKHelpers::GetRegionInRadiusAroundPixel(*iter, radius);
//std::cout << "desiredRegion: " << desiredRegion << std::endl;
itk::ImageRegionIterator<Mask> sourcesImageIterator(sourcesImage, desiredRegion);
std::vector<float> nonForegroundDepths;
std::vector<float> foregroundDepths;
while(!sourcesImageIterator.IsAtEnd())
{
if(sourcesImageIterator.Get())
{
foregroundDepths.push_back(depthImage->GetPixel(sourcesImageIterator.GetIndex()));
}
else
{
nonForegroundDepths.push_back(depthImage->GetPixel(sourcesImageIterator.GetIndex()));
}
++sourcesImageIterator;
}
if(nonForegroundDepths.size() < 1)
{
}
float nonForegroundMedian = Helpers::VectorMedian(nonForegroundDepths);
float foregroundMedian = Helpers::VectorMedian(foregroundDepths);
float difference = fabs(foregroundMedian - nonForegroundMedian);
if(difference > this->txtBackgroundThreshold->text().toFloat())
{
//std::cout << "Difference was " << difference << " so this is a sink pixel." << std::endl;
newSinks.push_back(*iter);
}
else
{
//std::cout << "Difference was " << difference << " so this is NOT a sink pixel." << std::endl;
}
} // end loop over considered pixels
unsigned char blue[3] = {0, 0, 255};
// ImageType::PixelType blue(3);
// blue[0] = 0;
// blue[1] = 0;
// blue[2] = 255;
ITKVTKHelpers::SetPixels(this->SourceSinkImageData.GetPointer(), consideredPixels, blue);
this->SourceSinkImageData->Modified();
this->Refresh();
// Save the new sink pixels for inspection
UnsignedCharScalarImageType::Pointer newSinksImage = UnsignedCharScalarImageType::New();
newSinksImage->SetRegions(this->Image->GetLargestPossibleRegion());
newSinksImage->Allocate();
ITKHelpers::IndicesToBinaryImage(newSinks, newSinksImage);
ITKHelpers::WriteImage(newSinksImage.GetPointer(), "newSinks.png");
//std::cout << "Out of " << consideredCounter << " pixels considered, "
// << backgroundCounter << " were declared background." << std::endl;
// Set the new sinks
std::cout << "Setting " << newSinks.size() << " new sinks." << std::endl;
// Modify the list of sinks so it can be retrieved by the MainWindow after the segmentation is finished
this->Sinks.insert(this->Sinks.end(), newSinks.begin(), newSinks.end());
UpdateSelections();
}
bool TestExtractChannel()
{
// VectorImage
{
typedef itk::VectorImage<float, 2> VectorImageType;
VectorImageType::Pointer image = VectorImageType::New();
itk::Index<2> corner = {{0,0}};
itk::Size<2> size = {{100,100}};
itk::ImageRegion<2> region(corner, size);
image->SetRegions(region);
image->SetNumberOfComponentsPerPixel(2);
image->Allocate();
typedef itk::Image<float, 2> FloatScalarImageType;
FloatScalarImageType::Pointer floatScalarImage = FloatScalarImageType::New();
ITKHelpers::ExtractChannel(image.GetPointer(), 0, floatScalarImage.GetPointer());
typedef itk::Image<unsigned char, 2> UnsignedCharScalarImageType;
UnsignedCharScalarImageType::Pointer unsignedCharScalarImage = UnsignedCharScalarImageType::New();
ITKHelpers::ExtractChannel(image.GetPointer(), 0, unsignedCharScalarImage.GetPointer());
}
// VectorImage different output type
{
typedef itk::VectorImage<float, 2> VectorImageType;
VectorImageType::Pointer image = VectorImageType::New();
itk::Index<2> corner = {{0,0}};
itk::Size<2> size = {{100,100}};
itk::ImageRegion<2> region(corner, size);
image->SetRegions(region);
image->SetNumberOfComponentsPerPixel(2);
image->Allocate();
typedef itk::Image<unsigned char, 2> UnsignedCharScalarImageType;
UnsignedCharScalarImageType::Pointer unsignedCharScalarImage = UnsignedCharScalarImageType::New();
ITKHelpers::ExtractChannel(image.GetPointer(), 0, unsignedCharScalarImage.GetPointer());
}
// Scalar Image
{
typedef itk::Image<float, 2> VectorImageType;
VectorImageType::Pointer image = VectorImageType::New();
itk::Index<2> corner = {{0,0}};
itk::Size<2> size = {{100,100}};
itk::ImageRegion<2> region(corner, size);
image->SetRegions(region);
image->Allocate();
typedef itk::Image<float, 2> FloatScalarImageType;
FloatScalarImageType::Pointer floatScalarImage = FloatScalarImageType::New();
ITKHelpers::ExtractChannel(image.GetPointer(), 0, floatScalarImage.GetPointer());
typedef itk::Image<unsigned char, 2> UnsignedCharScalarImageType;
UnsignedCharScalarImageType::Pointer unsignedCharScalarImage = UnsignedCharScalarImageType::New();
ITKHelpers::ExtractChannel(image.GetPointer(), 0, unsignedCharScalarImage.GetPointer());
}
// Image<CovariantVector>
{
typedef itk::Image<itk::CovariantVector<float, 3>, 2> VectorImageType;
VectorImageType::Pointer image = VectorImageType::New();
itk::Index<2> corner = {{0,0}};
itk::Size<2> size = {{100,100}};
itk::ImageRegion<2> region(corner, size);
image->SetRegions(region);
image->Allocate();
typedef itk::Image<float, 2> FloatScalarImageType;
FloatScalarImageType::Pointer floatScalarImage = FloatScalarImageType::New();
ITKHelpers::ExtractChannel(image.GetPointer(), 0, floatScalarImage.GetPointer());
}
// Image<Vector>
{
typedef itk::Image<itk::Vector<float, 3>, 2> VectorImageType;
VectorImageType::Pointer image = VectorImageType::New();
itk::Index<2> corner = {{0,0}};
itk::Size<2> size = {{100,100}};
itk::ImageRegion<2> region(corner, size);
image->SetRegions(region);
image->Allocate();
typedef itk::Image<float, 2> FloatScalarImageType;
FloatScalarImageType::Pointer floatScalarImage = FloatScalarImageType::New();
ITKHelpers::ExtractChannel(image.GetPointer(), 0, floatScalarImage.GetPointer());
}
return true;
}