void ComputeColorIsophotesInRegion(const FloatVectorImageType* const image, const Mask* const mask,
const itk::ImageRegion<2>& region , FloatVector2ImageType* const isophotes)
{
//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<FloatScalarImageType>(luminanceFilter->GetOutput(), luminanceImage);
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<FloatScalarImageType>(luminanceFilter->GetOutput(), mask, kernelRadius, blurredLuminance);
//HelpersOutput::WriteImageConditional<FloatScalarImageType>(blurredLuminance, "Debug/Initialize.blurredLuminance.mha", true);
ITKHelpers::InitializeImage<FloatVector2ImageType>(isophotes, image->GetLargestPossibleRegion());
Isophotes::ComputeMaskedIsophotesInRegion(blurredLuminance, mask, region, isophotes);
// if(this->DebugImages)
// {
// HelpersOutput::Write2DVectorImage(this->IsophoteImage, "Debug/Initialize.IsophoteImage.mha");
// }
//LeaveFunction("ComputeIsophotes()");
}
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();
// TODO: update this to the new API
//Helpers::VectorImageToRGBImage(imageReader->GetOutput(), rgbImage);
OutputHelpers::WriteImage(rgbImage.GetPointer(), "Test/TestIsophotes.rgb.mha");
typedef itk::RGBToLuminanceImageFilter< RGBImageType, FloatScalarImageType > LuminanceFilterType;
LuminanceFilterType::Pointer luminanceFilter = LuminanceFilterType::New();
luminanceFilter->SetInput(rgbImage);
luminanceFilter->Update();
FloatScalarImageType::Pointer blurredLuminance = FloatScalarImageType::New();
// Blur with a Gaussian kernel
unsigned int kernelRadius = 5;
MaskOperations::MaskedBlur<FloatScalarImageType>(luminanceFilter->GetOutput(), maskReader->GetOutput(), kernelRadius,
blurredLuminance);
OutputHelpers::WriteImage<FloatScalarImageType>(blurredLuminance, "Test/TestIsophotes.blurred.mha");
//inpainting.ComputeMaskedIsophotes(blurredLuminance, maskReader->GetOutput());
//Helpers::WriteImage<FloatVector2ImageType>(inpainting.GetIsophoteImage(), );
//HelpersOutput::Write2DVectorImage(inpainting.GetIsophoteImage(), "Test/TestIsophotes.isophotes.mha");
itk::Size<2> size;
size.Fill(21);
// Target
itk::Index<2> targetIndex;
targetIndex[0] = 187;
targetIndex[1] = 118;
itk::ImageRegion<2> targetRegion(targetIndex, size);
// Source
itk::Index<2> sourceIndex;
sourceIndex[0] = 176;
sourceIndex[1] = 118;
itk::ImageRegion<2> sourceRegion(sourceIndex, size);
//PatchPair patchPair(Patch(sourceRegion), Patch(targetRegion));
//PatchPair patchPair;
// Patch sourcePatch(sourceRegion);
// Patch targetPatch(targetRegion);
// PatchPair patchPair(sourcePatch, targetPatch);
//inpainting.FindBoundary();
// std::vector<itk::Index<2> > borderPixels =
// ITKHelpers::GetNonZeroPixels(inpainting.GetBoundaryImage(), targetRegion);
itk::RGBPixel<unsigned char> black;
black.SetRed(0);
black.SetGreen(0);
black.SetBlue(0);
itk::RGBPixel<unsigned char> red;
red.SetRed(255);
red.SetGreen(0);
red.SetBlue(0);
itk::RGBPixel<unsigned char> darkRed;
darkRed.SetRed(100);
darkRed.SetGreen(0);
darkRed.SetBlue(0);
itk::RGBPixel<unsigned char> yellow;
yellow.SetRed(255);
yellow.SetGreen(255);
yellow.SetBlue(0);
itk::RGBPixel<unsigned char> green;
green.SetRed(0);
green.SetGreen(255);
green.SetBlue(0);
itk::RGBPixel<unsigned char> darkGreen;
darkGreen.SetRed(0);
darkGreen.SetGreen(100);
darkGreen.SetBlue(0);
itk::RGBPixel<unsigned char> blue;
blue.SetRed(0);
blue.SetGreen(0);
blue.SetBlue(255);
RGBImageType::Pointer output = RGBImageType::New();
output->SetRegions(imageReader->GetOutput()->GetLargestPossibleRegion());
output->Allocate();
output->FillBuffer(black);
ITKHelpers::BlankAndOutlineRegion(output.GetPointer(), targetRegion, black, red);
ITKHelpers::BlankAndOutlineRegion(output.GetPointer(), sourceRegion, black, green);
RGBImageType::Pointer target = RGBImageType::New();
target->SetRegions(imageReader->GetOutput()->GetLargestPossibleRegion());
target->Allocate();
ITKHelpers::BlankAndOutlineRegion(target.GetPointer(), targetRegion, black, red);
RGBImageType::Pointer source = RGBImageType::New();
source->SetRegions(imageReader->GetOutput()->GetLargestPossibleRegion());
source->Allocate();
ITKHelpers::BlankAndOutlineRegion(source.GetPointer(), sourceRegion, black, green);
// itk::Offset<2> offset = targetIndex - sourceIndex;
/*
for(unsigned int pixelId = 0; pixelId < borderPixels.size(); ++pixelId)
{
itk::Index<2> targetPatchSourceSideBoundaryPixel = borderPixels[pixelId];
itk::Index<2> sourcePatchTargetSideBoundaryPixel;
//bool valid = GetAdjacentBoundaryPixel(currentPixel, candidatePairs[sourcePatchId], adjacentBoundaryPixel);
bool valid = inpainting.GetAdjacentBoundaryPixel(targetPatchSourceSideBoundaryPixel, patchPair, sourcePatchTargetSideBoundaryPixel);
target->SetPixel(targetPatchSourceSideBoundaryPixel, darkRed);
source->SetPixel(sourcePatchTargetSideBoundaryPixel, darkGreen);
if(!valid)
{
continue;
}
// Bring the adjacent pixel back to the target region.
itk::Index<2> targetPatchTargetSideBoundaryPixel = sourcePatchTargetSideBoundaryPixel + offset;
output->SetPixel(targetPatchSourceSideBoundaryPixel, darkRed);
output->SetPixel(targetPatchTargetSideBoundaryPixel, blue);
output->SetPixel(sourcePatchTargetSideBoundaryPixel, darkGreen);
}
*/
// OutputHelpers::WriteImage(output.GetPointer(), "Test/FollowIsophotes.Output.mha");
// OutputHelpers::WriteImage(target.GetPointer(), "Test/FollowIsophotes.Target.mha");
// OutputHelpers::WriteImage(source.GetPointer(), "Test/FollowIsophotes.Source.mha");
return EXIT_SUCCESS;
}
void CriminisiInpainting::ComputeIsophotes()
{
try
{
Helpers::DebugWriteImageConditional<FloatVectorImageType>(this->CurrentImage, "Debug/ComputeIsophotes.input.mha", this->DebugImages);
/*
// This only works when the image is RGB
typedef itk::VectorMagnitudeImageFilter<FloatVectorImageType, UnsignedCharScalarImageType> VectorMagnitudeFilterType;
VectorMagnitudeFilterType::Pointer magnitudeFilter = VectorMagnitudeFilterType::New();
magnitudeFilter->SetInput(this->OriginalImage); // We use the original image here because the image that has been painted green inside the hole has a strong gradient around the hole.
magnitudeFilter->Update();
*/
RGBImageType::Pointer rgbImage = RGBImageType::New();
Helpers::VectorImageToRGBImage(this->OriginalImage, rgbImage);
Helpers::DebugWriteImageConditional<RGBImageType>(rgbImage, "Debug/ComputeIsophotes.rgb.mha", this->DebugImages);
typedef itk::RGBToLuminanceImageFilter< RGBImageType, FloatScalarImageType > LuminanceFilterType;
LuminanceFilterType::Pointer luminanceFilter = LuminanceFilterType::New();
luminanceFilter->SetInput(rgbImage);
luminanceFilter->Update();
Helpers::DebugWriteImageConditional<FloatScalarImageType>(luminanceFilter->GetOutput(), "Debug/ComputeIsophotes.luminance.mha", this->DebugImages);
// Blur the image to compute better gradient estimates
typedef itk::DiscreteGaussianImageFilter<FloatScalarImageType, FloatScalarImageType > BlurFilterType;
BlurFilterType::Pointer blurFilter = BlurFilterType::New();
blurFilter->SetInput(luminanceFilter->GetOutput());
blurFilter->SetVariance(2);
blurFilter->Update();
Helpers::DebugWriteImageConditional<FloatScalarImageType>(blurFilter->GetOutput(), "Debug/ComputeIsophotes.blurred.mha", true);
// Compute the gradient
// Template parameters are <TInputImage, TOperatorValueType, TOutputValueType>
typedef itk::GradientImageFilter<FloatScalarImageType, float, float> GradientFilterType;
GradientFilterType::Pointer gradientFilter = GradientFilterType::New();
gradientFilter->SetInput(blurFilter->GetOutput());
gradientFilter->Update();
Helpers::DebugWriteImageConditional<FloatVector2ImageType>(gradientFilter->GetOutput(), "Debug/ComputeIsophotes.gradient.mha", this->DebugImages);
// Rotate the gradient 90 degrees to obtain isophotes from gradient
typedef itk::UnaryFunctorImageFilter<FloatVector2ImageType, FloatVector2ImageType,
RotateVectors<
FloatVector2ImageType::PixelType,
FloatVector2ImageType::PixelType> > FilterType;
FilterType::Pointer rotateFilter = FilterType::New();
rotateFilter->SetInput(gradientFilter->GetOutput());
rotateFilter->Update();
Helpers::DebugWriteImageConditional<FloatVector2ImageType>(rotateFilter->GetOutput(), "Debug/ComputeIsophotes.rotatedGradient.mha", this->DebugImages);
// Mask the isophote image with the expanded version of the inpainting mask.
// That is, keep only the values outside of the expanded mask. To do this, we have to first invert the mask.
// Invert the mask
typedef itk::InvertIntensityImageFilter <Mask> InvertIntensityImageFilterType;
InvertIntensityImageFilterType::Pointer invertMaskFilter = InvertIntensityImageFilterType::New();
invertMaskFilter->SetInput(this->CurrentMask);
invertMaskFilter->Update();
if(this->DebugImages)
{
Helpers::WriteImage<Mask>(invertMaskFilter->GetOutput(), "Debug/ComputeIsophotes.invertedMask.mha");
}
//std::cout << "rotateFilter: " << rotateFilter->GetOutput()->GetLargestPossibleRegion() << std::endl;
//std::cout << "invertMaskFilter: " << invertMaskFilter->GetOutput()->GetLargestPossibleRegion() << std::endl;
// Keep only values outside the masked region
typedef itk::MaskImageFilter< FloatVector2ImageType, Mask, FloatVector2ImageType > MaskFilterType;
MaskFilterType::Pointer maskFilter = MaskFilterType::New();
maskFilter->SetInput1(rotateFilter->GetOutput());
maskFilter->SetInput2(invertMaskFilter->GetOutput());
maskFilter->Update();
if(this->DebugImages)
{
Helpers::WriteImage<FloatVector2ImageType>(maskFilter->GetOutput(), "Debug/ComputeIsophotes.maskedIsophotes.mha");
}
Helpers::DeepCopy<FloatVector2ImageType>(maskFilter->GetOutput(), this->IsophoteImage);
}
catch( itk::ExceptionObject & err )
{
std::cerr << "ExceptionObject caught in ComputeIsophotes!" << std::endl;
std::cerr << err << std::endl;
exit(-1);
}
}
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;
}
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);
HelpersOutput::WriteImage<RGBImageType>(rgbImage, "Test/TestIsophotes.rgb.mha");
typedef itk::RGBToLuminanceImageFilter< RGBImageType, FloatScalarImageType > LuminanceFilterType;
LuminanceFilterType::Pointer luminanceFilter = LuminanceFilterType::New();
luminanceFilter->SetInput(rgbImage);
luminanceFilter->Update();
FloatScalarImageType::Pointer blurredLuminance = FloatScalarImageType::New();
// Blur with a Gaussian kernel
unsigned int kernelRadius = 5;
Helpers::MaskedBlur<FloatScalarImageType>(luminanceFilter->GetOutput(), maskReader->GetOutput(), kernelRadius, blurredLuminance);
HelpersOutput::WriteImage<FloatScalarImageType>(blurredLuminance, "Test/TestIsophotes.blurred.mha");
PatchBasedInpainting inpainting(NULL, maskReader->GetOutput());
//inpainting.SetMask(maskReader->GetOutput());
//inpainting.SetImage(imageReader->GetOutput());
//inpainting.FindBoundary();
for(unsigned int blurVariance = 0; blurVariance < 10; ++blurVariance)
{
//inpainting.ComputeBoundaryNormals(blurVariance);
std::stringstream ss;
ss << "Test/BoundaryNormals_" << blurVariance << ".mha";
//HelpersOutput::Write2DVectorImage(inpainting.GetBoundaryNormalsImage(), ss.str());
typedef itk::MaskImageFilter< FloatVector2ImageType, UnsignedCharScalarImageType, FloatVector2ImageType > MaskFilterType;
MaskFilterType::Pointer maskFilter = MaskFilterType::New();
//maskFilter->SetInput(inpainting.GetBoundaryNormalsImage());
//maskFilter->SetMaskImage(inpainting.GetBoundaryImage());
maskFilter->Update();
vtkSmartPointer<vtkPolyData> boundaryNormals = vtkSmartPointer<vtkPolyData>::New();
Helpers::ConvertNonZeroPixelsToVectors(maskFilter->GetOutput(), boundaryNormals);
std::stringstream ssPolyData;
ssPolyData << "Test/BoundaryNormals_" << blurVariance << ".vtp";
HelpersOutput::WritePolyData(boundaryNormals, ssPolyData.str());
}
return EXIT_SUCCESS;
}
