void D3D11Texture2D::Unmap2D( uint32_t arrayIndex, uint32_t level )
{
ID3D11DeviceContext* deviceContextD3D11 = gD3D11Device->DeviceContextD3D11;
uint32_t subResource = D3D11CalcSubresource(level, arrayIndex, mMipLevels);
if (mTextureMapAccess == RMA_Read_Only || mTextureMapAccess == RMA_Read_Write)
{
deviceContextD3D11->Unmap(mStagingTextureD3D11, subResource);
CD3D11_BOX sourceRegion(0, 0, 0, CalculateLevelSize(mWidth, level), CalculateLevelSize(mHeight, level), 1);
if (PixelFormatUtils::IsDepth(mFormat))
{
deviceContextD3D11->CopySubresourceRegion(TextureD3D11, subResource, 0, 0, 0, mStagingTextureD3D11, subResource, nullptr);
}
else
{
CD3D11_BOX sourceRegion(0, 0, 0, CalculateLevelSize(mWidth, level), CalculateLevelSize(mHeight, level), 1);
deviceContextD3D11->CopySubresourceRegion(TextureD3D11, subResource, 0, 0, 0, mStagingTextureD3D11, subResource, &sourceRegion);
}
}
else
{
deviceContextD3D11->Unmap(TextureD3D11, subResource);
}
}
void* D3D11Texture2D::Map2D( uint32_t arrayIndex, uint32_t level, ResourceMapAccess mapType, uint32_t& rowPitch )
{
ID3D11DeviceContext* deviceContextD3D11 = gD3D11Device->DeviceContextD3D11;
ID3D11Resource* resourceMapD3D11;
uint32_t subResource = D3D11CalcSubresource(level, arrayIndex, mMipLevels);
if (mapType == RMA_Read_Only || mapType == RMA_Read_Write)
{
if (!mStagingTextureD3D11)
{
// Create staging texture if not created.
D3D11_TEXTURE2D_DESC texDesc;
TextureD3D11->GetDesc(&texDesc);
texDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
if (mapType == RMA_Read_Write)
texDesc.CPUAccessFlags |= D3D11_CPU_ACCESS_WRITE;
texDesc.BindFlags = 0;
texDesc.Usage = D3D11_USAGE_STAGING;
texDesc.MiscFlags = 0;
ID3D11Device* deviceD3D11 = gD3D11Device->DeviceD3D11;
D3D11_VERRY( deviceD3D11->CreateTexture2D( &texDesc, NULL, (ID3D11Texture2D**)&mStagingTextureD3D11) );
}
if (PixelFormatUtils::IsDepth(mFormat))
{
/**
* Note If you use CopySubresourceRegion with a depth-stencil buffer
* or a multisampled resource, you must copy the whole subresource.
* In this situation, you must pass 0 to the DstX, DstY, and DstZ parameters
* and NULL to the pSrcBox parameter.
*/
deviceContextD3D11->CopySubresourceRegion(mStagingTextureD3D11, subResource, 0, 0, 0, TextureD3D11, subResource, nullptr);
}
else
{
CD3D11_BOX sourceRegion(0, 0, 0, CalculateLevelSize(mWidth, level), CalculateLevelSize(mHeight, level), 1);
deviceContextD3D11->CopySubresourceRegion(mStagingTextureD3D11, subResource, 0, 0, 0, TextureD3D11, subResource, &sourceRegion);
}
resourceMapD3D11 = mStagingTextureD3D11;
}
else
{
resourceMapD3D11 = TextureD3D11;
}
D3D11_MAPPED_SUBRESOURCE mapped;
D3D11_VERRY( deviceContextD3D11->Map(resourceMapD3D11, subResource, D3D11Mapping::Mapping(mapType), 0, &mapped) );
// Keep map type
mTextureMapAccess = mapType;
rowPitch = mapped.RowPitch;
return mapped.pData;
}
void Vector()
{
typedef itk::Image<unsigned char, 2 > ChannelType;
const unsigned int NumberOfChannels = 3;
typedef itk::Image<itk::CovariantVector<unsigned char, NumberOfChannels>, 2 > ImageType;
ImageType::Pointer image = ImageType::New();
itk::Index<2> corner = {{0,0}};
itk::Size<2> imageSize = {{500,500}};
itk::ImageRegion<2> fullRegion(corner, imageSize);
image->SetRegions(fullRegion);
image->Allocate();
for(unsigned int i = 0; i < NumberOfChannels; ++i)
{
itk::RandomImageSource<ChannelType>::Pointer randomImageSource =
itk::RandomImageSource<ChannelType>::New();
randomImageSource->SetNumberOfThreads(1); // to produce non-random results
randomImageSource->SetSize(imageSize);
randomImageSource->Update();
ITKHelpers::SetChannel(image.GetPointer(), i, randomImageSource->GetOutput());
}
itk::Size<2> patchSize = {{21,21}};
// There is nothing magic about these particular patches
itk::Index<2> targetCorner = {{319, 302}};
itk::ImageRegion<2> targetRegion(targetCorner, patchSize);
itk::Index<2> sourceCorner = {{341, 300}};
itk::ImageRegion<2> sourceRegion(sourceCorner, patchSize);
Mask::Pointer mask = Mask::New();
mask->SetRegions(fullRegion);
mask->Allocate();
ITKHelpers::SetImageToConstant(mask.GetPointer(), mask->GetValidValue());
typedef SumSquaredPixelDifference<ImageType::PixelType> PixelDifferenceType;
typedef ImagePatchPixelDescriptor<ImageType> PatchType;
ImagePatchDifference<PatchType, PixelDifferenceType> imagePatchDifference;
PatchType targetPatch(image, mask, targetRegion);
PatchType sourcePatch(image, mask, sourceRegion);
float difference = imagePatchDifference(targetPatch, sourcePatch);
std::cout << "GMHDifference: " << difference << std::endl;
}
int main(int argc, char *argv[])
{
if(argc != 3)
{
std::cerr << "Only gave " << argc << " arguments!" << std::endl;
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> VectorImageReaderType;
VectorImageReaderType::Pointer imageReader = VectorImageReaderType::New();
imageReader->SetFileName(imageFilename.c_str());
imageReader->Update();
typedef itk::ImageFileReader<Mask> MaskReaderType;
MaskReaderType::Pointer maskReader = MaskReaderType::New();
maskReader->SetFileName(maskFilename.c_str());
maskReader->Update();
itk::Size<2> size;
size.Fill(21);
itk::Index<2> sourceCorner;
sourceCorner[0] = 319;
sourceCorner[1] = 292;
itk::ImageRegion<2> sourceRegion(sourceCorner, size);
itk::Index<2> targetCorner;
targetCorner[0] = 193;
targetCorner[1] = 218;
itk::ImageRegion<2> targetRegion(targetCorner, size);
SelfPatchCompare patchCompare(imageReader->GetOutput()->GetNumberOfComponentsPerPixel());
patchCompare.SetTargetRegion(targetRegion);
patchCompare.SetImage(imageReader->GetOutput());
patchCompare.SetMask(maskReader->GetOutput());
float totalAbsoluteDifference = patchCompare.SlowTotalAbsoluteDifference(sourceRegion);
float totalSquaredDifference = patchCompare.SlowTotalSquaredDifference(sourceRegion);
std::cerr << "Total Absolute Difference: " << totalAbsoluteDifference << std::endl;
std::cerr << "Total Squared Difference: " << totalSquaredDifference << std::endl;
return EXIT_SUCCESS;
}
void Scalar()
{
typedef itk::Image< unsigned char, 2 > ImageType;
itk::Size<2> imageSize = {{500,500}};
itk::RandomImageSource<ImageType>::Pointer randomImageSource =
itk::RandomImageSource<ImageType>::New();
randomImageSource->SetNumberOfThreads(1); // to produce non-random results
randomImageSource->SetSize(imageSize);
randomImageSource->Update();
ImageType* image = randomImageSource->GetOutput();
itk::Size<2> patchSize = {{21,21}};
// There is nothing magic about these particular patches
itk::Index<2> targetCorner = {{319, 302}};
itk::ImageRegion<2> targetRegion(targetCorner, patchSize);
itk::Index<2> sourceCorner = {{341, 300}};
itk::ImageRegion<2> sourceRegion(sourceCorner, patchSize);
Mask::Pointer mask = Mask::New();
mask->SetRegions(randomImageSource->GetOutput()->GetLargestPossibleRegion());
mask->Allocate();
ITKHelpers::SetImageToConstant(mask.GetPointer(), mask->GetValidValue());
typedef SumSquaredPixelDifference<ImageType::PixelType> PixelDifferenceType;
typedef ImagePatchPixelDescriptor<ImageType> PatchType;
ImagePatchDifference<PatchType, PixelDifferenceType> imagePatchDifference;
PatchType targetPatch(image, mask, targetRegion);
PatchType sourcePatch(image, mask, sourceRegion);
float difference = imagePatchDifference(targetPatch, sourcePatch);
std::cout << "Difference: " << difference << std::endl;
}
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;
}
std::vector<PairReader::PairType> PairReader::Read(const std::string& fileName, const itk::Size<2>& patchSize)
{
// Parse matches list
std::ifstream fin(fileName.c_str());
if(fin == NULL)
{
std::stringstream ss;
ss << "Cannot open file " << fileName;
throw std::runtime_error(ss.str());
}
std::string line;
std::vector<PairReader::PairType> pairs;
while(getline(fin, line))
{
//std::cout << "Current line: " << line << std::endl;
// Setup the expression for a [x,y]
// The real regex is \[\s*[0-9]*\s*,\s*[0-9]*\s*\] which means match a [,
// then any number of whitespace, then any number of digits, then any number of white space,
// then a comma, then any number of whitespace, then any number of digits, then a ]
// The following has extra escape characters (\) for c++
// Additionally, the things we want to extract (the digits) are in subexpressions (parenthesis)
std::string myRegExString = "\\[\\s*([0-9]*)\\s*,\\s*([0-9]*)\\s*\\]";
const boost::regex myRegEx(myRegExString);
boost::match_results<std::string::const_iterator> matches;
std::string::const_iterator beginSearch = line.begin();
// Cannot just put this in the regex_search() call, aparently .end() does not return
// a const_iterator unless it is explicitly assigned to one?
std::string::const_iterator endSearch = line.end();
// Find the first match (target)
boost::regex_search(beginSearch, endSearch, matches, myRegEx);
std::string matchStringTargetX(matches[1].first, matches[1].second);
std::string matchStringTargetY(matches[2].first, matches[2].second);
std::stringstream matchSSTargetX(matchStringTargetX);
std::stringstream matchSSTargetY(matchStringTargetY);
itk::Index<2> targetIndex;
matchSSTargetX >> targetIndex[0];
matchSSTargetY >> targetIndex[1];
itk::ImageRegion<2> targetRegion(targetIndex, patchSize);
// Find the second match (source)
beginSearch = matches[0].second;
boost::regex_search(beginSearch, endSearch, matches, myRegEx);
std::string matchStringSourceX(matches[1].first, matches[1].second);
std::string matchStringSourceY(matches[2].first, matches[2].second);
std::stringstream matchSSSourceX(matchStringSourceX);
std::stringstream matchSSSourceY(matchStringSourceY);
itk::Index<2> sourceIndex;
matchSSSourceX >> sourceIndex[0];
matchSSSourceY >> sourceIndex[1];
itk::ImageRegion<2> sourceRegion(sourceIndex, patchSize);
PairType p(targetRegion, sourceRegion);
pairs.push_back(p);
} // end while
return pairs;
}
int main(int, char*[])
{
// typedef itk::Image<itk::CovariantVector<int, 3>, 2> ImageType;
typedef itk::Image<itk::CovariantVector<unsigned char, 3>, 2> ImageType;
ImageType::PixelType red;
red.Fill(0);
red[0] = 255;
ImageType::PixelType black;
black.Fill(0);
ImageType::PixelType white;
white.Fill(255);
ImageType::PixelType green; // Note this is not 255 because then the magnitude of red and green would be the same,
// which makes debugging hard since the gradient of the magnitude image is used internally (in IntroducedEnergy).
green.Fill(0);
green[1] = 122;
ImageType::PixelType blue;
blue.Fill(0);
blue[2] = 255;
ImageType::Pointer image = ImageType::New();
itk::Index<2> imageCorner = {{0,0}};
itk::Size<2> imageSize = {{100,100}};
itk::ImageRegion<2> region(imageCorner,imageSize);
image->SetRegions(region);
image->Allocate();
Mask::Pointer mask = Mask::New();
mask->SetRegions(region);
mask->Allocate();
itk::ImageRegionIteratorWithIndex<Mask> initializeMaskIterator(mask, mask->GetLargestPossibleRegion());
while(!initializeMaskIterator.IsAtEnd())
{
if(initializeMaskIterator.GetIndex()[0] < 55)
{
initializeMaskIterator.Set(mask->GetHoleValue());
}
else
{
initializeMaskIterator.Set(mask->GetValidValue());
}
++initializeMaskIterator;
}
ITKHelpers::WriteImage(mask.GetPointer(), "mask.png");
// Create a red image
itk::ImageRegionIterator<ImageType> initializeIterator(image, image->GetLargestPossibleRegion());
while(!initializeIterator.IsAtEnd())
{
initializeIterator.Set(red);
++initializeIterator;
}
// Setup source and target patch
itk::Size<2> patchSize = {{10,10}};
itk::Index<2> sourceCorner = {{10,10}};
itk::ImageRegion<2> sourceRegion(sourceCorner, patchSize);
itk::Index<2> targetCorner = {{50,50}};
itk::ImageRegion<2> targetRegion(targetCorner, patchSize);
itk::Index<2> perfectSourceCorner = {{75,75}};
itk::ImageRegion<2> perfectSourceRegion(perfectSourceCorner, patchSize);
// Make the source patch green
itk::ImageRegionIterator<ImageType> sourceRegionIterator(image, sourceRegion);
while(!sourceRegionIterator.IsAtEnd())
{
sourceRegionIterator.Set(green);
++sourceRegionIterator;
}
ITKHelpers::WriteImage(image.GetPointer(), "image.png");
{
ImageType::Pointer regionHighlightImage = ImageType::New();
ITKHelpers::DeepCopy(image.GetPointer(), regionHighlightImage.GetPointer());
ITKHelpers::OutlineRegion(regionHighlightImage.GetPointer(), sourceRegion, white);
ITKHelpers::OutlineRegion(regionHighlightImage.GetPointer(), targetRegion, black);
ITKHelpers::OutlineRegion(regionHighlightImage.GetPointer(), perfectSourceRegion, blue);
ITKHelpers::WriteImage(regionHighlightImage.GetPointer(), "regions.png");
}
IntroducedEnergy<ImageType> introducedEnergy;
introducedEnergy.SetDebugImages(true);
// Bad match
{
std::cout << "Bad match:" << std::endl;
float patchBoundaryEnergy = introducedEnergy.ComputeIntroducedEnergyPatchBoundary(image, mask, sourceRegion, targetRegion);
std::cout << "patchBoundaryEnergy: " << patchBoundaryEnergy << std::endl;
float maskBoundaryEnergy = introducedEnergy.ComputeIntroducedEnergyMaskBoundary(image, mask, sourceRegion, targetRegion);
std::cout << "maskBoundaryEnergy: " << maskBoundaryEnergy << std::endl;
float totalEnergy = introducedEnergy.ComputeIntroducedEnergy(image, mask, sourceRegion, targetRegion);
std::cout << "totalEnergy: " << totalEnergy << std::endl;
}
// Perfect match
{
std::cout << "Perfect match:" << std::endl;
// IntroducedEnergy<ImageType> introducedEnergy;
typedef IntroducedEnergy<ImageType> IntroducedEnergyType;
float patchBoundaryEnergy = introducedEnergy.ComputeIntroducedEnergyPatchBoundary(image, mask, perfectSourceRegion, targetRegion);
std::cout << "patchBoundaryEnergy: " << patchBoundaryEnergy << std::endl;
float maskBoundaryEnergy = introducedEnergy.ComputeIntroducedEnergyMaskBoundary(image, mask, perfectSourceRegion, targetRegion);
std::cout << "maskBoundaryEnergy: " << maskBoundaryEnergy << std::endl;
float totalEnergy = introducedEnergy.ComputeIntroducedEnergy(image, mask, perfectSourceRegion, targetRegion);
std::cout << "totalEnergy: " << totalEnergy << std::endl;
}
return EXIT_SUCCESS;
}
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());
}
}
}
void PartialPatchVectorComparison()
{
std::cout << "PartialPatchVectorComparison()" << std::endl;
const unsigned int dimension = 3;
FloatVectorImageType::Pointer vectorImage = FloatVectorImageType::New();
Testing::GetBlankImage<FloatVectorImageType>(vectorImage, dimension);
// Make the left half of the image (0,0,0) and the right half (5,6,7)
itk::ImageRegionIterator<FloatVectorImageType> imageIterator(vectorImage, vectorImage->GetLargestPossibleRegion());
itk::VariableLengthVector<float> leftHalfPixel;
leftHalfPixel.SetSize(dimension);
leftHalfPixel.Fill(0);
itk::VariableLengthVector<float> rightHalfPixel;
rightHalfPixel.SetSize(dimension);
rightHalfPixel[0] = 5;
rightHalfPixel[1] = 6;
rightHalfPixel[2] = 7;
while(!imageIterator.IsAtEnd())
{
if(imageIterator.GetIndex()[0] < static_cast<int>(vectorImage->GetLargestPossibleRegion().GetSize()[0]/2))
{
imageIterator.Set(leftHalfPixel);
}
else
{
imageIterator.Set(rightHalfPixel);
}
++imageIterator;
}
itk::Size<2> patchSize;
patchSize.Fill(10);
// Full patches differ
std::cout << "Full patch different test." << std::endl;
{
itk::Index<2> sourceCorner;
sourceCorner.Fill(0);
itk::ImageRegion<2> sourceRegion(sourceCorner, patchSize);
ImagePatchPixelDescriptor<FloatVectorImageType> sourcePatch(vectorImage, sourceRegion, true);
itk::Index<2> targetCorner;
targetCorner.Fill(vectorImage->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<FloatVectorImageType> targetPatch(vectorImage, targetRegion, true);
PatchPair<FloatVectorImageType> patchPair(&sourcePatch, targetPatch);
PatchDifferencePixelWiseSum<FloatVectorImageType, PixelDifference> vector_patchDifferencePixelWiseSum;
vector_patchDifferencePixelWiseSum.SetImage(vectorImage);
float difference = vector_patchDifferencePixelWiseSum.Difference(patchPair);
float correctDifference = targetRegion.GetNumberOfPixels() * 18; // 18 = 5+6+7, the sum of the elements of 'rightHalfPixel'
if(difference != correctDifference)
{
std::stringstream ss;
ss << "Difference " << difference << " does not match correctDifference " << correctDifference;
throw std::runtime_error(ss.str());
}
}
// Full patches identical
std::cout << "Identical patch test." << std::endl;
{
itk::Index<2> sourceCorner;
sourceCorner.Fill(5);
itk::ImageRegion<2> sourceRegion(sourceCorner, patchSize);
ImagePatchPixelDescriptor<FloatVectorImageType> sourcePatch(vectorImage, sourceRegion, true);
itk::Index<2> targetCorner;
targetCorner.Fill(5);
itk::ImageRegion<2> targetRegion(targetCorner, patchSize);
ImagePatchPixelDescriptor<FloatVectorImageType> targetPatch(vectorImage, targetRegion, true);
PatchPair<FloatVectorImageType> patchPair(&sourcePatch, targetPatch);
PatchDifferencePixelWiseSum<FloatVectorImageType, PixelDifference> vector_patchDifferencePixelWiseSum;
vector_patchDifferencePixelWiseSum.SetImage(vectorImage);
float difference = vector_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());
}
}
}
