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