// Calculate patch addressing
void tetPointFieldDecomposer::
tetPolyPatchFieldDecomposer::calcPatchAddressing() const
{
if (directPatchAddressingPtr_)
{
FatalErrorIn
(
"void tetPointFieldDecomposer::"
"tetPolyPatchFieldDecomposer::calcPatchAddressing() const"
) << "addressing already calculated"
<< abort(FatalError);
}
// Allocate the addressing
directPatchAddressingPtr_ = new labelList(targetPatch().size(), -1);
labelList& addr = *directPatchAddressingPtr_;
// Algorithm:
// Go to the source patch, create a lookup list the size of all
// points in the mesh and then gather the points for the current
// patch.
labelList pointLookup
(sourcePatch().boundaryMesh().mesh().nPoints(), -1);
const labelList& sourcePatchPoints = sourcePatch().meshPoints();
forAll (sourcePatchPoints, pointI)
{
pointLookup[sourcePatchPoints[pointI]] = pointI;
}
// Gather the information
const labelList& targetPatchPoints = targetPatch().meshPoints();
forAll (targetPatchPoints, pointI)
{
addr[pointI] =
pointLookup[directAddressing_[targetPatchPoints[pointI]]];
}
if (addr.size() && min(addr) < 0)
{
FatalErrorIn
(
"void tetPointFieldDecomposer::"
"tetPolyPatchFieldDecomposer::calcPatchAddressing() const"
) << "error in addressing"
<< abort(FatalError);
}
}
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;
}
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[])
{
unsigned int t = time(NULL);
srand(t);
itk::Size<2> size;
size.Fill(100);
itk::Index<2> index;
index.Fill(0);
itk::ImageRegion<2> region(index, size);
/*
// Generate a random image (this method doesn't work with VectorImage)
itk::RandomImageSource<FloatVectorImageType>::Pointer imageSource =
itk::RandomImageSource<FloatVectorImageType>::New();
imageSource->SetNumberOfThreads(1); // to produce non-random results
imageSource->SetSize(size);
imageSource->SetMin(0);
imageSource->SetMax(100);
imageSource->Update();
FloatVectorImageType::Pointer image = imageSource->GetOutput();
*/
// Generate a random image
FloatVectorImageType::Pointer image = FloatVectorImageType::New();
image->SetRegions(region);
image->SetNumberOfComponentsPerPixel(3);
image->Allocate();
{
itk::ImageRegionIterator<FloatVectorImageType> imageIterator(image, image->GetLargestPossibleRegion());
while(!imageIterator.IsAtEnd())
{
FloatVectorImageType::PixelType pixel;
pixel.SetSize(3);
pixel[0] = drand48();
pixel[1] = drand48();
pixel[2] = drand48();
imageIterator.Set(pixel);
++imageIterator;
}
}
// Generate a random membership image
IntImageType::Pointer membershipImage = IntImageType::New();
membershipImage->SetRegions(region);
membershipImage->Allocate();
membershipImage->FillBuffer(0);
{
itk::ImageRegionIterator<IntImageType> membershipImageIterator(membershipImage, membershipImage->GetLargestPossibleRegion());
while(!membershipImageIterator.IsAtEnd())
{
IntImageType::PixelType pixel;
pixel = rand() / 1000;
membershipImageIterator.Set(pixel);
++membershipImageIterator;
}
}
// Write the image
itk::ImageFileWriter<FloatVectorImageType>::Pointer imageWriter =
itk::ImageFileWriter<FloatVectorImageType>::New();
imageWriter->SetFileName("image.mha");
imageWriter->SetInput(image);
imageWriter->Update();
// // Generate a random mask
// itk::RandomImageSource<Mask>::Pointer maskSource = itk::RandomImageSource<Mask>::New();
// maskSource->SetNumberOfThreads(1); // to produce non-random results
// maskSource->SetSize(size);
// maskSource->SetMin(0);
// maskSource->SetMax(255);
// maskSource->Update();
//
// // Threshold the mask
// //typedef itk::ThresholdImageFilter <UnsignedCharImageType> ThresholdImageFilterType;
// typedef itk::BinaryThresholdImageFilter <Mask, Mask> ThresholdImageFilterType;
// ThresholdImageFilterType::Pointer thresholdFilter = ThresholdImageFilterType::New();
// thresholdFilter->SetInput(maskSource->GetOutput());
// thresholdFilter->SetLowerThreshold(0);
// thresholdFilter->SetUpperThreshold(122);
// thresholdFilter->SetOutsideValue(1);
// thresholdFilter->SetInsideValue(0);
// thresholdFilter->Update();
// Mask::Pointer mask = thresholdFilter->GetOutput();
std::cout << "Creating mask..." << std::endl;
Mask::Pointer mask = Mask::New();
mask->SetRegions(region);
mask->Allocate();
{
itk::ImageRegionIterator<Mask> maskIterator(mask, mask->GetLargestPossibleRegion());
while(!maskIterator.IsAtEnd())
{
int randomNumber = rand()%10;
//std::cout << "randomNumber: " << randomNumber << std::endl;
if(randomNumber > 5)
{
maskIterator.Set(mask->GetHoleValue());
}
else
{
maskIterator.Set(mask->GetValidValue());
}
++maskIterator;
}
}
std::cout << "Writing mask..." << std::endl;
// Write the mask
itk::ImageFileWriter<Mask>::Pointer maskWriter = itk::ImageFileWriter<Mask>::New();
maskWriter->SetFileName("mask.png");
maskWriter->SetInput(mask);
maskWriter->Update();
std::cout << "Creating source patches..." << std::endl;
unsigned int patchRadius = 10;
// Create source patches
itk::ImageRegionConstIterator<FloatVectorImageType> imageIterator(image, image->GetLargestPossibleRegion());
std::vector<Patch> sourcePatches;
while(!imageIterator.IsAtEnd())
{
itk::Index<2> currentPixel = imageIterator.GetIndex();
itk::ImageRegion<2> region = Helpers::GetRegionInRadiusAroundPixel(currentPixel, patchRadius);
if(image->GetLargestPossibleRegion().IsInside(region))
{
sourcePatches.push_back(Patch(region));
}
++imageIterator;
}
std::cout << "Source patches: " << sourcePatches.size() << std::endl;
itk::Size<2> targetSize;
targetSize.Fill(patchRadius * 2 + 1);
itk::Index<2> targetIndex;
targetIndex.Fill(3);
itk::ImageRegion<2> targetRegion(targetIndex, targetSize);
Patch targetPatch(targetRegion);
CandidatePairs pairs(targetPatch);
pairs.AddPairFromPatch(targetPatch);
itk::ImageRegion<2> adjacentRegion = targetRegion;
itk::Index<2> adjacentIndex;
adjacentIndex[0] = targetIndex[0] + 1;
adjacentIndex[1] = targetIndex[1] + 1;
adjacentRegion.SetIndex(adjacentIndex);
Patch adjacentPatch(adjacentRegion);
pairs.AddPairFromPatch(adjacentPatch);
//pairs.AddPairFromPatch(sourcePatches[0]);
SelfPatchCompare patchCompare;
patchCompare.SetPairs(&pairs);
patchCompare.SetImage(image);
patchCompare.SetMask(mask);
patchCompare.SetNumberOfComponentsPerPixel(3);
patchCompare.SetMembershipImage(membershipImage);
patchCompare.FunctionsToCompute.push_back(boost::bind(&SelfPatchCompare::SetPatchMembershipDifference,&patchCompare,_1));
patchCompare.ComputeAllSourceDifferences();
std::cout << "pairs: " << pairs.size() << std::endl;
for(unsigned int i = 0; i < pairs.size(); ++i)
{
std::cout << "MembershipDifference: " << pairs[i].DifferenceMap[PatchPair::MembershipDifference] << std::endl;
}
//unsigned int bestMatchSourcePatchId = patchCompare.FindBestPatch();
//std::cout << "bestMatchSourcePatchId: " << bestMatchSourcePatchId << std::endl;
/*
unsigned int patchId = 1;
float slowPatchDifference = patchCompare.SlowDifference(sourcePatches[patchId]);
std::cout << "slowPatchDifference: " << slowPatchDifference << std::endl;
float fastPatchDifference = patchCompare.PatchDifference(sourcePatches[patchId]);
std::cout << "fastPatchDifference: " << fastPatchDifference << std::endl;
unsigned int iterations = 1e6;
itk::TimeProbe slowTimer;
slowTimer.Start();
for(unsigned int i = 0; i < iterations; ++i)
{
float slowPatchDifference = patchCompare.SlowDifference(sourcePatches[patchId]);
}
slowTimer.Stop();
std::cout << "Slow Total: " << slowTimer.GetTotal() << std::endl;
itk::TimeProbe fastTimer;
fastTimer.Start();
for(unsigned int i = 0; i < iterations; ++i)
{
float fastPatchDifference = patchCompare.PatchDifference(sourcePatches[patchId]);
}
fastTimer.Stop();
std::cout << "Fast Total: " << fastTimer.GetTotal() << 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());
}
}
}
