void FinishVertex(VertexDescriptorType target, VertexDescriptorType sourceNode)
{
//OutputHelpers::WriteImage(MaskImage, Helpers::GetSequentialFileName("mask", this->NumberOfFinishedVertices, "png"));
ITKHelpers::WriteImage(MaskImage, Helpers::GetSequentialFileName("mask",
this->NumberOfFinishedVertices, "mha"));
//OutputHelpers::WriteVectorImageAsRGB(Image, Helpers::GetSequentialFileName("output", this->NumberOfFinishedVertices, "png"));
ITKHelpers::WriteImage(Image, Helpers::GetSequentialFileName("output",
this->NumberOfFinishedVertices, "mha"));
ITKHelpers::WriteRGBImage(Image, Helpers::GetSequentialFileName("output",
this->NumberOfFinishedVertices, "png"));
typename TImage::PixelType holeColor;
holeColor.SetSize(Image->GetNumberOfComponentsPerPixel());
holeColor[0] = 255;
holeColor[1] = 0;
holeColor[2] = 0;
MaskOperations::WriteMaskedRegionPNG(Image, MaskImage, Image->GetLargestPossibleRegion(), Helpers::GetSequentialFileName("maskedOutput", this->NumberOfFinishedVertices, "png"),
holeColor);
typedef itk::Image<unsigned char, 2> IndicatorImageType;
IndicatorImageType::Pointer boundaryStatusMapImage = IndicatorImageType::New();
boundaryStatusMapImage->SetRegions(Image->GetLargestPossibleRegion());
boundaryStatusMapImage->Allocate();
// BoostHelpers::WritePropertyMapAsImage(BoundaryStatusMap, boundaryStatusMapImage.GetPointer(),
// Helpers::GetSequentialFileName("boundaryStatusMap",
// this->NumberOfFinishedVertices, "png"));
IndicatorImageType::Pointer validBoundaryNodeImage = IndicatorImageType::New();
validBoundaryNodeImage->SetRegions(Image->GetLargestPossibleRegion());
validBoundaryNodeImage->Allocate();
// BoostHelpers::WriteValidQueueNodesAsImage(BoundaryNodeQueue, BoundaryStatusMap,
// validBoundaryNodeImage.GetPointer(),
// Helpers::GetSequentialFileName("boundaryQueueValidNodes",
// this->NumberOfFinishedVertices, "png"));
IndicatorImageType::Pointer allBoundaryNodeImage = IndicatorImageType::New();
allBoundaryNodeImage->SetRegions(Image->GetLargestPossibleRegion());
allBoundaryNodeImage->Allocate();
// BoostHelpers::WriteAllQueueNodesAsImage(BoundaryNodeQueue, allBoundaryNodeImage.GetPointer(),
// Helpers::GetSequentialFileName("boundaryQueueAllNodes",
// this->NumberOfFinishedVertices, "png"));
this->NumberOfFinishedVertices++;
// std::cout << "Finished node " << this->NumberOfFinishedVertices << std::endl;
}
void LabelSampler< TImage>
::GenerateData()
{
srand (time(nullptr));
this->AllocateOutputs();
typename TImage::ConstPointer input = this->GetInput();
TImage * output = this->GetOutput();
m_NumberOfSampledVoxels = 0;
ImageRegionConstIterator<TImage> inputIter(input, input->GetLargestPossibleRegion());
ImageRegionIterator<TImage> outputIter(output, output->GetLargestPossibleRegion());
while (!inputIter.IsAtEnd())
{
if (inputIter.Get() > 0)
{
if(m_LabelVoxelCountMap.find(inputIter.Get()) == m_LabelVoxelCountMap.end())
m_LabelVoxelCountMap[inputIter.Get()] = 0;
m_LabelVoxelCountMap[inputIter.Get()]++;
double r;
if(inputIter.Get() == m_Label || m_Label == -1 ){
r = (double)(rand()) / RAND_MAX;
if (r < m_AcceptRate)
{
outputIter.Set(inputIter.Get());
m_NumberOfSampledVoxels++;
}
}else
outputIter.Set(0);
}
else
{
outputIter.Set(0);
}
++inputIter;
++outputIter;
}
}
void PaintPatch(TVertexDescriptor target, TVertexDescriptor source) const
{
TVertexDescriptor target_patch_corner;
target_patch_corner[0] = target[0] - PatchHalfWidth;
target_patch_corner[1] = target[1] - PatchHalfWidth;
TVertexDescriptor source_patch_corner;
source_patch_corner[0] = source[0] - PatchHalfWidth;
source_patch_corner[1] = source[1] - PatchHalfWidth;
TVertexDescriptor target_node;
TVertexDescriptor source_node;
for(std::size_t i = 0; i < PatchHalfWidth * 2 + 1; ++i)
{
for(std::size_t j = 0; j < PatchHalfWidth * 2 + 1; ++j)
{
target_node[0] = target_patch_corner[0] + i;
target_node[1] = target_patch_corner[1] + j;
source_node[0] = source_patch_corner[0] + i;
source_node[1] = source_patch_corner[1] + j;
// Only paint the pixel if it is currently a hole
if( MaskImage->IsHole(ITKHelpers::CreateIndex(target_node)) )
{
//std::cout << "Copying pixel " << source_node << " to pixel " << target_node << std::endl;
itk::Index<2> target_index = ITKHelpers::CreateIndex(target);
itk::Index<2> source_index = ITKHelpers::CreateIndex(source);
assert(Image->GetLargestPossibleRegion().IsInside(source_index));
assert(Image->GetLargestPossibleRegion().IsInside(target_index));
Image->SetPixel(target_index, Image->GetPixel(source_index));
}
}
}
};
void finish_vertex(VertexDescriptorType v, VertexDescriptorType sourceNode, TGraph& g)
{
// Construct the region around the vertex
itk::Index<2> indexToFinish;
indexToFinish[0] = v[0];
indexToFinish[1] = v[1];
itk::ImageRegion<2> region = ITKHelpers::GetRegionInRadiusAroundPixel(indexToFinish, HalfWidth);
region.Crop(Image->GetLargestPossibleRegion()); // Make sure the region is entirely inside the image
// Mark all the pixels in this region as filled.
// It does not matter which image we iterate over, we just want the indices.
itk::ImageRegionConstIteratorWithIndex<TImage> gridIterator(Image, region);
while(!gridIterator.IsAtEnd())
{
VertexDescriptorType v;
v[0] = gridIterator.GetIndex()[0];
v[1] = gridIterator.GetIndex()[1];
put(FillStatusMap, v, true);
MaskImage->SetPixel(gridIterator.GetIndex(), MaskImage->GetValidValue());
++gridIterator;
}
// Additionally, initialize the filled vertices because they may now be valid.
// This must be done in a separate loop like this because the mask image used to check for boundary pixels is incorrect until the above loop updates it.
gridIterator.GoToBegin();
while(!gridIterator.IsAtEnd())
{
VertexDescriptorType v;
v[0] = gridIterator.GetIndex()[0];
v[1] = gridIterator.GetIndex()[1];
initialize_vertex(v, g);
++gridIterator;
}
// Update the priority function.
this->PriorityFunction->Update(sourceNode, v);
// Add pixels that are on the new boundary to the queue, and mark other pixels as not in the queue.
itk::ImageRegionConstIteratorWithIndex<Mask> imageIterator(this->MaskImage, region);
while(!imageIterator.IsAtEnd())
{
VertexDescriptorType v;
v[0] = imageIterator.GetIndex()[0];
v[1] = imageIterator.GetIndex()[1];
// Mark all nodes in the patch around this node as filled (in the FillStatusMap).
// This makes them ignored if they are still in the boundaryNodeQueue.
if(ITKHelpers::HasNeighborWithValue(imageIterator.GetIndex(), this->MaskImage, this->MaskImage->GetHoleValue()))
{
put(BoundaryStatusMap, v, true);
this->BoundaryNodeQueue.push(v);
float priority = this->PriorityFunction->ComputePriority(imageIterator.GetIndex());
//std::cout << "updated priority: " << priority << std::endl;
put(this->PriorityMap, v, priority);
}
else
{
put(this->BoundaryStatusMap, v, false);
}
++imageIterator;
}
{
// Debug only - write the mask to a file
HelpersOutput::WriteImage(this->MaskImage, Helpers::GetSequentialFileName("debugMask", this->NumberOfFinishedVertices, "png"));
HelpersOutput::WriteVectorImageAsRGB(this->Image, Helpers::GetSequentialFileName("output", this->NumberOfFinishedVertices, "png"));
this->NumberOfFinishedVertices++;
}
} // finish_vertex
