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