bool VolumeProcess::RunGaussianSmoothing(float varX, float varY, float varZ, float maxErr)
{ //by xiao liang
typedef itk::DiscreteGaussianImageFilter< ImageType, FloatImageType3D > GaussianFilterType;
GaussianFilterType::Pointer GaussianFilter = GaussianFilterType::New();
GaussianFilter->SetInput(m_outputImage);
//GaussianFilter->SetFilterDimensionality(3);
GaussianFilterType::ArrayType maxErrTypeValue;
maxErrTypeValue.Fill(maxErr);
GaussianFilter->SetMaximumError( maxErrTypeValue );
GaussianFilterType::ArrayType variance;
variance[0] = varX;
variance[1] = varY;
variance[2] = varZ;
GaussianFilter->SetVariance(variance);
//GaussianFilter->SetMaximumKernelWidth(maxKernalWidth);
try
{
GaussianFilter->Update();
}
catch( itk::ExceptionObject & err )
{
std::cerr << "ITK FILTER ERROR: " << err << std::endl ;
return false;
}
m_outputImage = RescaleFloatToImageType(GaussianFilter->GetOutput());
if(debug)
std::cerr << "GaussianFilter Filter Done" << std::endl;
return true;
}
ImageType::Pointer SBFilterUtils::GaussianSmoothImage(ImageType::Pointer image, float variance) {
GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New();
gaussianFilter->SetInput(image);
gaussianFilter->SetVariance(variance);
gaussianFilter->Update();
CastFilterType::Pointer castFilter = CastFilterType::New();
castFilter->SetInput(gaussianFilter->GetOutput());
castFilter->Update();
return castFilter->GetOutput();
}
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setTitle("DmriDenoising");
parser.setCategory("Preprocessing Tools");
parser.setDescription("dMRI denoising tool");
parser.setContributor("MIC");
parser.setArgumentPrefix("--", "-");
parser.beginGroup("1. Mandatory arguments:");
parser.addArgument("", "i", mitkCommandLineParser::String, "Input:", "input image", us::Any(), false, false, false, mitkCommandLineParser::Input);
parser.addArgument("", "o", mitkCommandLineParser::String, "Output:", "output image", us::Any(), false, false, false, mitkCommandLineParser::Output);
parser.addArgument("type", "", mitkCommandLineParser::Int, "Type:", "0 (TotalVariation), 1 (Gauss), 2 (NLM)", 0);
parser.endGroup();
parser.beginGroup("2. Total variation parameters:");
parser.addArgument("tv_iterations", "", mitkCommandLineParser::Int, "Iterations:", "", 1);
parser.addArgument("lambda", "", mitkCommandLineParser::Float, "Lambda:", "", 0.1);
parser.endGroup();
parser.beginGroup("3. Gauss parameters:");
parser.addArgument("variance", "", mitkCommandLineParser::Float, "Variance:", "", 1.0);
parser.endGroup();
parser.beginGroup("4. NLM parameters:");
parser.addArgument("nlm_iterations", "", mitkCommandLineParser::Int, "Iterations:", "", 4);
parser.addArgument("sampling_radius", "", mitkCommandLineParser::Int, "Sampling radius:", "", 4);
parser.addArgument("patch_radius", "", mitkCommandLineParser::Int, "Patch radius:", "", 1);
parser.addArgument("num_patches", "", mitkCommandLineParser::Int, "Num. patches:", "", 10);
parser.endGroup();
std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
// mandatory arguments
std::string imageName = us::any_cast<std::string>(parsedArgs["i"]);
std::string outImage = us::any_cast<std::string>(parsedArgs["o"]);
int type = 0;
if (parsedArgs.count("type"))
type = us::any_cast<int>(parsedArgs["type"]);
int tv_iterations = 1;
if (parsedArgs.count("tv_iterations"))
tv_iterations = us::any_cast<int>(parsedArgs["tv_iterations"]);
float lambda = 0.1;
if (parsedArgs.count("lambda"))
lambda = us::any_cast<float>(parsedArgs["lambda"]);
float variance = 1.0;
if (parsedArgs.count("variance"))
variance = us::any_cast<float>(parsedArgs["variance"]);
int nlm_iterations = 4;
if (parsedArgs.count("nlm_iterations"))
nlm_iterations = us::any_cast<int>(parsedArgs["nlm_iterations"]);
int sampling_radius = 4;
if (parsedArgs.count("sampling_radius"))
sampling_radius = us::any_cast<int>(parsedArgs["sampling_radius"]);
int patch_radius = 1;
if (parsedArgs.count("patch_radius"))
patch_radius = us::any_cast<int>(parsedArgs["patch_radius"]);
int num_patches = 10;
if (parsedArgs.count("num_patches"))
num_patches = us::any_cast<int>(parsedArgs["num_patches"]);
try
{
mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images"}, {});
mitk::Image::Pointer input_image = mitk::IOUtil::Load<mitk::Image>(imageName, &functor);
typedef short DiffusionPixelType;
typedef itk::VectorImage<DiffusionPixelType, 3> DwiImageType;
typedef itk::Image<DiffusionPixelType, 3> DwiVolumeType;
typedef itk::DiscreteGaussianImageFilter < DwiVolumeType, DwiVolumeType > GaussianFilterType;
typedef itk::PatchBasedDenoisingImageFilter < DwiVolumeType, DwiVolumeType > NlmFilterType;
typedef itk::VectorImageToImageFilter < DiffusionPixelType > ExtractFilterType;
typedef itk::ComposeImageFilter < itk::Image<DiffusionPixelType, 3> > ComposeFilterType;
if (!mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(input_image))
mitkThrow() << "Input is not a diffusion-weighted image!";
DwiImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::GetItkVectorImage(input_image);
mitk::Image::Pointer denoised_image = nullptr;
switch (type)
{
case 0:
{
ComposeFilterType::Pointer composer = ComposeFilterType::New();
for (unsigned int i=0; i<itkVectorImagePointer->GetVectorLength(); ++i)
{
ExtractFilterType::Pointer extractor = ExtractFilterType::New();
extractor->SetInput( itkVectorImagePointer );
extractor->SetIndex( i );
extractor->Update();
DwiVolumeType::Pointer gradient_volume = extractor->GetOutput();
itk::TotalVariationDenoisingImageFilter< DwiVolumeType, DwiVolumeType >::Pointer filter = itk::TotalVariationDenoisingImageFilter< DwiVolumeType, DwiVolumeType >::New();
filter->SetInput(gradient_volume);
filter->SetLambda(lambda);
filter->SetNumberIterations(tv_iterations);
filter->Update();
composer->SetInput(i, filter->GetOutput());
}
composer->Update();
denoised_image = mitk::GrabItkImageMemory(composer->GetOutput());
break;
}
case 1:
{
ExtractFilterType::Pointer extractor = ExtractFilterType::New();
extractor->SetInput( itkVectorImagePointer );
ComposeFilterType::Pointer composer = ComposeFilterType::New();
for (unsigned int i = 0; i < itkVectorImagePointer->GetVectorLength(); ++i)
{
extractor->SetIndex(i);
extractor->Update();
GaussianFilterType::Pointer filter = GaussianFilterType::New();
filter->SetVariance(variance);
filter->SetInput(extractor->GetOutput());
filter->Update();
composer->SetInput(i, filter->GetOutput());
}
composer->Update();
denoised_image = mitk::GrabItkImageMemory(composer->GetOutput());
break;
}
case 2:
{
typedef itk::Statistics::GaussianRandomSpatialNeighborSubsampler< NlmFilterType::PatchSampleType, DwiVolumeType::RegionType > SamplerType;
// sampling the image to find similar patches
SamplerType::Pointer sampler = SamplerType::New();
sampler->SetRadius( sampling_radius );
sampler->SetVariance( sampling_radius*sampling_radius );
sampler->SetNumberOfResultsRequested( num_patches );
MITK_INFO << "Starting NLM denoising";
ExtractFilterType::Pointer extractor = ExtractFilterType::New();
extractor->SetInput( itkVectorImagePointer );
ComposeFilterType::Pointer composer = ComposeFilterType::New();
for (unsigned int i = 0; i < itkVectorImagePointer->GetVectorLength(); ++i)
{
extractor->SetIndex(i);
extractor->Update();
NlmFilterType::Pointer filter = NlmFilterType::New();
filter->SetInput(extractor->GetOutput());
filter->SetPatchRadius(patch_radius);
filter->SetNoiseModel(NlmFilterType::RICIAN);
filter->UseSmoothDiscPatchWeightsOn();
filter->UseFastTensorComputationsOn();
filter->SetNumberOfIterations(nlm_iterations);
filter->SetSmoothingWeight( 1 );
filter->SetKernelBandwidthEstimation(true);
filter->SetSampler( sampler );
filter->Update();
composer->SetInput(i, filter->GetOutput());
MITK_INFO << "Gradient " << i << " finished";
}
composer->Update();
denoised_image = mitk::GrabItkImageMemory(composer->GetOutput());
break;
}
}
mitk::DiffusionPropertyHelper::SetGradientContainer(denoised_image, mitk::DiffusionPropertyHelper::GetGradientContainer(input_image));
mitk::DiffusionPropertyHelper::SetReferenceBValue(denoised_image, mitk::DiffusionPropertyHelper::GetReferenceBValue(input_image));
mitk::DiffusionPropertyHelper::InitializeImage( denoised_image );
std::string ext = itksys::SystemTools::GetFilenameExtension(outImage);
if (ext==".nii" || ext==".nii.gz")
mitk::IOUtil::Save(denoised_image, "DWI_NIFTI", outImage);
else
mitk::IOUtil::Save(denoised_image, outImage);
}
catch (itk::ExceptionObject e)
{
std::cout << e;
return EXIT_FAILURE;
}
catch (std::exception e)
{
std::cout << e.what();
return EXIT_FAILURE;
}
catch (...)
{
std::cout << "ERROR!?!";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
void WholeCellSeg::RealBoundaries(){
int size1=cyt_im_inp->GetLargestPossibleRegion().GetSize()[0];
int size2=cyt_im_inp->GetLargestPossibleRegion().GetSize()[1];
typedef itk::SmoothingRecursiveGaussianImageFilter< UShortImageType, UShortImageType > GaussianFilterType;
typedef itk::GradientMagnitudeImageFilter< UShortImageType, UShortImageType > GradientMagnitudeType;
typedef itk::RescaleIntensityImageFilter< UShortImageType, FltImageType > RescaleUSFltType;
typedef itk::CastImageFilter< UShortImageType, IntImageType > CastUSIntType;
typedef itk::CastImageFilter< IntImageType, UShortImageType > CastIntUSType;
typedef itk::ImageRegionIteratorWithIndex< IntImageType > IteratorType1;
typedef itk::ImageRegionConstIterator< FltImageType > ConstIteratorType1;
typedef itk::ImageRegionConstIterator< UShortImageType > ConstIteratorType;
typedef itk::MorphologicalWatershedFromMarkersImageFilter< IntImageType, IntImageType > WatershedFilterType;
//Get gradient image from cytoplasm image
GaussianFilterType::Pointer gaussianfilter = GaussianFilterType::New();
gaussianfilter->SetSigma( 1.25 );
gaussianfilter->SetInput( cyt_im_inp );
gaussianfilter->Update();
GradientMagnitudeType::Pointer gradmagfilter = GradientMagnitudeType::New();
gradmagfilter->SetInput( gaussianfilter->GetOutput() );
gradmagfilter->Update();
//Rescale image
RescaleUSFltType::Pointer rescaleusflt = RescaleUSFltType::New();
rescaleusflt->SetOutputMaximum( scaling );
rescaleusflt->SetOutputMinimum( 1 );
rescaleusflt->SetInput( gradmagfilter->GetOutput() );
rescaleusflt->Update();
//Get the rescaled gradient image from ITK into an array of known size and indexing system
float *INP_IM_2D;
FltImageType::Pointer grad_img = FltImageType::New();
grad_img = rescaleusflt->GetOutput();
INP_IM_2D = (float *) malloc (size1*size2*sizeof(float));
if ( INP_IM_2D == NULL ){
std::cerr << "Unable to allocate memory for 2D Gradient Image";
return;
}
ConstIteratorType1 pix_buf( grad_img, grad_img->GetRequestedRegion() );
itk::IndexValueType ind=0;
for ( pix_buf.GoToBegin(); !pix_buf.IsAtEnd(); ++pix_buf, ++ind )
INP_IM_2D[ind] = ( pix_buf.Get() );
//int testing=0;
if( use_mem_img ){
GaussianFilterType::Pointer gaussianfilter1 = GaussianFilterType::New();
gaussianfilter1->SetSigma( 1.25 );
gaussianfilter1->SetInput( mem_im_inp );
gaussianfilter1->Update();
GradientMagnitudeType::Pointer gradmagfilter1 = GradientMagnitudeType::New();
gradmagfilter1->SetInput( gaussianfilter1->GetOutput() );
gradmagfilter1->Update();
RescaleUSFltType::Pointer rescaleusflt1 = RescaleUSFltType::New();
rescaleusflt1->SetOutputMaximum( scaling );
rescaleusflt1->SetOutputMinimum( 1 );
rescaleusflt1->SetInput( gradmagfilter1->GetOutput() );
rescaleusflt1->Update();
FltImageType::Pointer grad_img1 = FltImageType::New();
grad_img1 = rescaleusflt1->GetOutput();
float *INP_IM_2D1;
INP_IM_2D1 = (float *) malloc (size1*size2*sizeof(float));
if ( INP_IM_2D1 == NULL ){
std::cerr << "Unable to allocate memory for 2D Membrane Image";
return;
}
ConstIteratorType1 pix_buf2( grad_img1, grad_img1->GetRequestedRegion() );
ind=0;
for ( pix_buf2.GoToBegin(); !pix_buf2.IsAtEnd(); ++pix_buf2, ++ind )
INP_IM_2D1[ind]=(pix_buf2.Get());
for(itk::SizeValueType j=0; j<size2; j++)
for(itk::SizeValueType i=0; i<size1; i++)
inp_im_2D(i,j) = (inp_im_2D(i,j)/mem_scaling)*(inp_im_2D1(i,j)*mem_scaling);
free( INP_IM_2D1 );
}
//Get the nucleus label image from ITK into an array of known size and indexing system
unsigned short *NUC_IM;
NUC_IM = (unsigned short *) malloc (size1*size2*sizeof(unsigned short));
if ( NUC_IM == NULL ){
std::cerr << "Unable to allocate memory for Nucleus Label Image";
return;
}
ConstIteratorType pix_buf2( nuclab_inp, nuclab_inp->GetRequestedRegion() );
ind=0;
for ( pix_buf2.GoToBegin(); !pix_buf2.IsAtEnd(); ++pix_buf2, ++ind )
NUC_IM[ind]=(pix_buf2.Get());
//allocate memory for the gradient weighted distance map
float *GRAD_IMW;
GRAD_IMW = (float *) malloc ((size1+2)*(size2+2)*sizeof(float));
if ( GRAD_IMW == NULL ){
std::cerr << "Unable to allocate memory for Gradient Weighted Distance Image";
return;
}
//Create Gradient Weighted Distance Map
float flt_mini = -1*FLT_MAX;
for(itk::SizeValueType i=0; i<size1; i++)
for(itk::SizeValueType j=0; j<size2; j++){
if(!nuc_im(i,j)) grad_imw(i+1,j+1) = FLT_MAX;
else grad_imw(i+1,j+1)=0;
}
for(itk::SizeValueType i=0; i<size1; i++)
for(itk::SizeValueType j=0; j<size2; j++)
if(!BIN_Image(i,j)) grad_imw(i+1,j+1)=flt_mini;
free( NUC_IM );
free( bin_Image );
for(itk::SizeValueType i=0; i<(size1+2); i++){
grad_imw(i,0)=flt_mini;
grad_imw(i,size2+1)=flt_mini;
}
for(itk::SizeValueType i=0; i<(size2+2); i++){
grad_imw(0,i)=flt_mini;
grad_imw(size1+1,i)=flt_mini;
}
int ok;
ok = gradient_enhanced_distance_map( INP_IM_2D, GRAD_IMW, size1, size2);
free( INP_IM_2D );
//Getting gradient weighted distance map into ITK array
IntImageType::Pointer image2;
image2 = IntImageType::New();
IntImageType::PointType origint;
origint[0] = 0;
origint[1] = 0;
image2->SetOrigin( origint );
IntImageType::IndexType startt;
startt[0] = 0; // first index on X
startt[1] = 0; // first index on Y
IntImageType::SizeType sizet;
sizet[0] = size1; // size along X
sizet[1] = size2; // size along Y
IntImageType::RegionType regiont;
regiont.SetSize( sizet );
regiont.SetIndex( startt );
image2->SetRegions( regiont );
image2->Allocate();
image2->FillBuffer(0);
image2->Update();
//copy the output image into the ITK image
IteratorType1 iteratort(image2,image2->GetRequestedRegion());
for(itk::SizeValueType j=0; j<size2; j++){
for(itk::SizeValueType i=0; i<size1; i++){
iteratort.Set(grad_imw(i+1,j+1));
++iteratort;
}
}
free( GRAD_IMW );
CastUSIntType::Pointer castUSIntfilter = CastUSIntType::New();
castUSIntfilter->SetInput( nuclab_inp );
castUSIntfilter->Update();
IntImageType::Pointer nuclab_inp_int = IntImageType::New();
nuclab_inp_int = castUSIntfilter->GetOutput();
//Seeded watershed to get the cytoplasm regions
WatershedFilterType::Pointer watershedfilter = WatershedFilterType::New();
watershedfilter->SetInput1( image2 );
watershedfilter->SetInput2( nuclab_inp_int );
watershedfilter->SetMarkWatershedLine( 1 );
watershedfilter->Update();
CastIntUSType::Pointer castIntUSfilter = CastIntUSType::New();
castIntUSfilter->SetInput( watershedfilter->GetOutput() );
castIntUSfilter->Update();
seg_im_out = castIntUSfilter->GetOutput();
//Write the output for testing
/* IteratorType1 pix_bufed33( image2, image2->GetRequestedRegion() );
pix_bufed33.GoToBegin();
while( !pix_bufed33.IsAtEnd() ){
if( 0 > pix_bufed33.Get() )
pix_bufed33.Set(0);
++pix_bufed33;
}
typedef itk::RescaleIntensityImageFilter< IntImageType, UShortImageType > RescaleIntIOType;
RescaleIntIOType::Pointer RescaleIntIO1 = RescaleIntIOType::New();
RescaleIntIO1->SetOutputMaximum( USHRT_MAX );
RescaleIntIO1->SetOutputMinimum( 0 );
RescaleIntIO1->SetInput( image2 ); //watershedfilter->GetOutput() image1
RescaleIntIO1->Update();
typedef itk::ImageFileWriter< UShortImageType > WriterType;
WriterType::Pointer writer = WriterType::New();
writer->SetFileName( "grad_wts.tif" );
writer->SetInput( RescaleIntIO1->GetOutput() );//RescaleIntIO1--finalO/P
writer->Update();
*/
//Get Array into IDL
/* IntImageType::Pointer image_fin = IntImageType::New();
image_fin = watershedfilter->GetOutput();
ConstIteratorType3 pix_bufed3( image_fin, image_fin->GetRequestedRegion() );
pix_bufed3.GoToBegin();
for(int j=size2-1; j>=0; j--)
for(int i=0; i<size1; i++){
OP(i,j)=(pix_bufed3.Get());
++pix_bufed3;
}
*/
if( !remove_small_objs )
seg_done = 1;
}
unsigned int Initialisation::houghTransformCircles(ImageType2D* im, unsigned int numberOfCircles, double** center_result, double* radius_result, double* accumulator_result, double meanRadius, double valPrint)
{
MinMaxCalculatorType::Pointer minMaxCalculator = MinMaxCalculatorType::New();
minMaxCalculator->SetImage(im);
minMaxCalculator->ComputeMaximum();
minMaxCalculator->ComputeMinimum();
ImageType2D::PixelType maxIm = minMaxCalculator->GetMaximum(), minIm = minMaxCalculator->GetMinimum();
double val_Print = maxIm;
double min_radius = meanRadius-3.0;
if (min_radius < 0) min_radius = 0;
HoughCirclesFilter::Pointer houghfilter = HoughCirclesFilter::New();
houghfilter->SetInput(im);
houghfilter->SetMinimumRadius(min_radius);
houghfilter->SetMaximumRadius(meanRadius+3.0);
houghfilter->SetSigmaGradient(2);
houghfilter->SetGradientFactor(valPrint*typeImageFactor_);
houghfilter->SetSweepAngle(M_PI/180.0*5.0);
houghfilter->SetThreshold((maxIm-minIm)/20.0);
houghfilter->Update();
const double nPI = 4.0 * vcl_atan( 1.0 );
ImageType2D::IndexType index;
ImageType2D::Pointer m_Accumulator= houghfilter->GetOutput();
ImageType2D::Pointer m_RadiusImage= houghfilter->GetRadiusImage();
/** Blur the accumulator in order to find the maximum */
ImageType2D::Pointer m_PostProcessImage = ImageType2D::New();
GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New();
gaussianFilter->SetInput(m_Accumulator);
double variance[2];
variance[0]=10;
variance[1]=10;
gaussianFilter->SetVariance(variance);
gaussianFilter->SetMaximumError(.01f);
gaussianFilter->Update();
m_PostProcessImage = gaussianFilter->GetOutput();
ImageType2D::SizeType bound = m_PostProcessImage->GetLargestPossibleRegion().GetSize();
itk::ImageRegionIterator<ImageType2D> it_output(im,im->GetLargestPossibleRegion());
itk::ImageRegionIterator<ImageType2D> it_input(m_PostProcessImage,m_PostProcessImage->GetLargestPossibleRegion());
/** Set the disc ratio */
double discRatio = 1.1;
/** Search for maxima */
unsigned int circles=0, maxIteration=100, it=0;
do{
it++;
minMaxCalculator->SetImage(m_PostProcessImage);
minMaxCalculator->ComputeMaximum();
ImageType2D::PixelType max = minMaxCalculator->GetMaximum();
it_output.GoToBegin();
for(it_input.GoToBegin();!it_input.IsAtEnd();++it_input)
{
if(it_input.Get() == max)
{
it_output.Set(val_Print);
index = it_output.GetIndex();
double radius2 = m_RadiusImage->GetPixel(index);
if (index[0]!=0 && index[0]!=bound[0]-1 && index[1]!=0 && index[1]!=bound[1]-1)
{
center_result[circles][0] = it_output.GetIndex()[0];
center_result[circles][1] = it_output.GetIndex()[1];
radius_result[circles] = radius2;
accumulator_result[circles] = m_PostProcessImage->GetPixel(index);
// Draw the circle
for(double angle = 0; angle <= 2 * nPI; angle += nPI / 1000)
{
index[0] = (long int)(it_output.GetIndex()[0] + radius2 * cos(angle));
index[1] = (long int)(it_output.GetIndex()[1] + radius2 * sin(angle));
if (index[0]>=0 && index[0]<bound[0] && index[1]>=0 && index[1]<bound[1])
im->SetPixel(index,val_Print);
// Remove the maximum from the accumulator
for(double length = 0; length < discRatio*radius2;length+=1)
{
index[0] = (long int)(it_output.GetIndex()[0] + length * cos(angle));
index[1] = (long int)(it_output.GetIndex()[1] + length* sin(angle));
if (index[0]>=0 && index[0]<bound[0] && index[1]>=0 && index[1]<bound[1])
m_PostProcessImage->SetPixel(index,0);
}
}
circles++;
if(circles == numberOfCircles) break;
}
else
{
// Draw the circle
for(double angle = 0; angle <= 2 * nPI; angle += nPI / 1000)
{
// Remove the maximum from the accumulator
for(double length = 0; length < discRatio*radius2;length+=1)
{
index[0] = (long int)(it_output.GetIndex()[0] + length * cos(angle));
index[1] = (long int)(it_output.GetIndex()[1] + length* sin(angle));
if (index[0]>=0 && index[0]<bound[0] && index[1]>=0 && index[1]<bound[1])
m_PostProcessImage->SetPixel(index,0);
}
}
}
minMaxCalculator->SetImage(m_PostProcessImage);
minMaxCalculator->ComputeMaximum();
max = minMaxCalculator->GetMaximum();
}
++it_output;
}
}
while(circles<numberOfCircles && it<=maxIteration);
return circles;
}
