本文整理汇总了C++中typenameimagetype::Pointer::GetLargestPossibleRegion方法的典型用法代码示例。如果您正苦于以下问题:C++ Pointer::GetLargestPossibleRegion方法的具体用法?C++ Pointer::GetLargestPossibleRegion怎么用?C++ Pointer::GetLargestPossibleRegion使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类typenameimagetype::Pointer
的用法示例。
在下文中一共展示了Pointer::GetLargestPossibleRegion方法的9个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: operator
void operator()(Parameters& params)
{
typedef typename ::itk::Image< PIXELTYPE, 3 > ImageType;
const typename ImageType::Pointer itkImage = ::fwItkIO::itkImageFactory< ImageType >(params.i_image);
typename ::itk::ResampleImageFilter<ImageType, ImageType>::Pointer resampler =
::itk::ResampleImageFilter<ImageType, ImageType>::New();
typename ::itk::MinimumMaximumImageCalculator< ImageType >::Pointer minCalculator =
::itk::MinimumMaximumImageCalculator< ImageType >::New();
minCalculator->SetImage(itkImage);
minCalculator->ComputeMinimum();
resampler->SetDefaultPixelValue(minCalculator->GetMinimum());
resampler->SetTransform(params.i_trf.GetPointer());
resampler->SetInput(itkImage);
typename ImageType::SizeType size = itkImage->GetLargestPossibleRegion().GetSize();
typename ImageType::PointType origin = itkImage->GetOrigin();
typename ImageType::SpacingType spacing = itkImage->GetSpacing();
typename ImageType::DirectionType direction = itkImage->GetDirection();
SLM_ASSERT("Input spacing can't be null along any axis", spacing[0] > 0 && spacing[1] > 0 && spacing[2] > 0);
if(params.i_targetImage)
{
for(std::uint8_t i = 0; i < 3; ++i)
{
// ITK uses unsigned long to store sizes.
size[i] = static_cast<typename ImageType::SizeType::SizeValueType>(params.i_targetImage->getSize()[i]);
origin[i] = params.i_targetImage->getOrigin()[i];
spacing[i] = params.i_targetImage->getSpacing()[i];
SLM_ASSERT("Output spacing can't be null along any axis.", spacing[i] > 0);
}
}
resampler->SetSize(size);
resampler->SetOutputOrigin(origin);
resampler->SetOutputDirection(direction);
resampler->SetOutputSpacing(spacing);
resampler->Update();
typename ImageType::Pointer outputImage = resampler->GetOutput();
::fwItkIO::itkImageToFwDataImage(outputImage, params.o_image);
}
示例2: addPaddingItk
void WorkbenchUtils::addPaddingItk(itk::Image <PixelType, ImageDimension> *itkImage, Axis axis, bool append,
int numberOfSlices, float pixelValue, Image::Pointer outImage) {
// pixel type is templated. The input field for the value is set to float, so the user might enter some invalid values for the image type at hand.
// since all primitive built-in types have well defined casting behaviour between each other, we'll just do a typecast. we will clip the entered
// value at PixelTypes min/max to prevent an overflow. The possible loss of precision is ignored.
float lower = itk::NumericTraits<PixelType>::min();
float upper = itk::NumericTraits<PixelType>::max();
float clippedPixelValue = std::max(lower, std::min(pixelValue, upper));
PixelType paddingPixelValue = (PixelType) clippedPixelValue;
typedef itk::Image <PixelType, ImageDimension> ImageType;
// gather all data
typename ImageType::SizeType lowerBound;
typename ImageType::SizeType upperBound;
lowerBound.Fill(0);
upperBound.Fill(0);
unsigned int itkAxis = convertToItkAxis(axis);
if (append) {
upperBound[itkAxis] = numberOfSlices;
} else {
lowerBound[itkAxis] = numberOfSlices;
}
// setup the filter
typedef itk::ConstantPadImageFilter <ImageType, ImageType> PadFilterType;
typename PadFilterType::Pointer padFilter = PadFilterType::New();
padFilter->SetInput(itkImage);
padFilter->SetConstant(paddingPixelValue);
padFilter->SetPadLowerBound(lowerBound);
padFilter->SetPadUpperBound(upperBound);
padFilter->UpdateLargestPossibleRegion();
// Update the origin, since padding creates negative index that is lost when returned to MITK
typename ImageType::Pointer paddedImage = padFilter->GetOutput();
typename ImageType::RegionType paddedImageRegion = paddedImage->GetLargestPossibleRegion();
typename ImageType::PointType origin;
paddedImage->TransformIndexToPhysicalPoint(paddedImageRegion.GetIndex(), origin);
paddedImage->SetOrigin(origin);
// get the results and cast them back to mitk. return via out parameter.
outImage->InitializeByItk(paddedImage.GetPointer());
CastToMitkImage(paddedImage, outImage);
}
示例3: addNeighborhoodToImageHelper
SEXP addNeighborhoodToImageHelper(
SEXP r_antsimage,
SEXP r_center,
SEXP r_rad,
SEXP r_vec)
{
typedef typename ImageType::Pointer ImagePointerType;
const unsigned int ImageDimension = ImageType::ImageDimension;
typedef float PixelType;
typename ImageType::Pointer image =
Rcpp::as< ImagePointerType >( r_antsimage );
Rcpp::NumericVector center( r_center );
Rcpp::NumericVector rad( r_rad );
Rcpp::NumericVector intvec( r_vec );
if ( center.size() != ImageDimension )
Rcpp::stop("addNeighborhoodToImageHelper dim error.");
typename itk::NeighborhoodIterator<ImageType>::SizeType nSize;
typename ImageType::IndexType ind;
ind.Fill( 0 );
for ( unsigned int i=0; i<ImageDimension; i++ )
{
nSize[i] = rad[i];
ind[i] = center[i]; // R coords to ITK
}
itk::NeighborhoodIterator<ImageType> nit( nSize, image,
image->GetLargestPossibleRegion() ) ;
// for each location in nitSearch, compute the correlation
// of the intvec with the nit neighborhood
nit.SetLocation( ind );
for( unsigned int i = 0; i < nit.Size(); i++ )
{
typename ImageType::IndexType ind2 = nit.GetIndex(i);
PixelType lval = image->GetPixel( ind2 );
image->SetPixel( ind2, lval + intvec[i] );
}
return 0;
}
示例4: eigenanatomyCppHelper
SEXP eigenanatomyCppHelper(
NumericMatrix X,
SEXP r_mask,
RealType sparseness,
IntType nvecs,
IntType its,
IntType cthresh,
RealType z,
RealType smooth,
// NumericMatrix initializationMatrix,
Rcpp::List initializationList,
IntType covering,
RealType ell1,
IntType verbose,
IntType powerit,
RealType priorWeight )
{
enum { Dimension = ImageType::ImageDimension };
typename ImageType::RegionType region;
typedef typename ImageType::PixelType PixelType;
typedef typename ImageType::Pointer ImagePointerType;
typedef double Scalar;
typedef itk::ants::antsSCCANObject<ImageType, Scalar> SCCANType;
typedef typename SCCANType::MatrixType vMatrix;
typename SCCANType::Pointer sccanobj = SCCANType::New();
typename ImageType::Pointer mask = Rcpp::as<ImagePointerType>( r_mask );
bool maskisnull = mask.IsNull();
// deal with the initializationList, if any
unsigned int nImages = initializationList.size();
if ( ( nImages > 0 ) && ( !maskisnull ) )
{
itk::ImageRegionIteratorWithIndex<ImageType> it( mask,
mask->GetLargestPossibleRegion() );
vMatrix priorROIMat( nImages , X.cols() );
priorROIMat.fill( 0 );
for ( unsigned int i = 0; i < nImages; i++ )
{
typename ImageType::Pointer init =
Rcpp::as<ImagePointerType>( initializationList[i] );
unsigned long ct = 0;
it.GoToBegin();
while ( !it.IsAtEnd() )
{
PixelType pix = it.Get();
if ( pix >= 0.5 )
{
pix = init->GetPixel( it.GetIndex() );
priorROIMat( i, ct ) = pix;
ct++;
}
++it;
}
}
sccanobj->SetMatrixPriorROI( priorROIMat );
nvecs = nImages;
}
sccanobj->SetPriorWeight( priorWeight );
sccanobj->SetLambda( priorWeight );
// cast hack from Rcpp type to sccan type
std::vector<double> xdat =
Rcpp::as< std::vector<double> >( X );
const double* _xdata = &xdat[0];
vMatrix vnlX( _xdata , X.cols(), X.rows() );
vnlX = vnlX.transpose();
sccanobj->SetGetSmall( false );
vMatrix priorROIMat;
// sccanobj->SetMatrixPriorROI( priorROIMat);
// sccanobj->SetMatrixPriorROI2( priorROIMat );
sccanobj->SetCovering( covering );
sccanobj->SetSilent( ! verbose );
if( ell1 > 0 )
{
sccanobj->SetUseL1( true );
}
else
{
sccanobj->SetUseL1( false );
}
sccanobj->SetGradStep( vnl_math_abs( ell1 ) );
sccanobj->SetMaximumNumberOfIterations( its );
sccanobj->SetRowSparseness( z );
sccanobj->SetSmoother( smooth );
if ( sparseness < 0 ) sccanobj->SetKeepPositiveP(false);
sccanobj->SetSCCANFormulation( SCCANType::PQ );
sccanobj->SetFractionNonZeroP( fabs( sparseness ) );
sccanobj->SetMinClusterSizeP( cthresh );
sccanobj->SetMatrixP( vnlX );
// sccanobj->SetMatrixR( r ); // FIXME
sccanobj->SetMaskImageP( mask );
RealType truecorr = 0;
if( powerit == 1 )
{
truecorr = sccanobj->SparseReconHome( nvecs );
}
else if ( priorWeight > 1.e-12 )
truecorr = sccanobj->SparseReconPrior( nvecs, true );
else truecorr = sccanobj->SparseRecon(nvecs);
//.........这里部分代码省略.........
示例5: sccanCppHelper
SEXP sccanCppHelper(
NumericMatrix X,
NumericMatrix Y,
SEXP r_maskx,
SEXP r_masky,
RealType sparsenessx,
RealType sparsenessy,
IntType nvecs,
IntType its,
IntType cthreshx,
IntType cthreshy,
RealType z,
RealType smooth,
Rcpp::List initializationListx,
Rcpp::List initializationListy,
IntType covering,
RealType ell1,
IntType verbose,
RealType priorWeight )
{
enum { Dimension = ImageType::ImageDimension };
typename ImageType::RegionType region;
typedef typename ImageType::PixelType PixelType;
typedef typename ImageType::Pointer ImagePointerType;
typedef double Scalar;
typedef itk::ants::antsSCCANObject<ImageType, Scalar> SCCANType;
typedef typename SCCANType::MatrixType vMatrix;
typename SCCANType::Pointer sccanobj = SCCANType::New();
typename ImageType::Pointer maskx = Rcpp::as<ImagePointerType>( r_maskx );
typename ImageType::Pointer masky = Rcpp::as<ImagePointerType>( r_masky );
bool maskxisnull = maskx.IsNull();
bool maskyisnull = masky.IsNull();
// deal with the initializationList, if any
unsigned int nImagesx = initializationListx.size();
if ( ( nImagesx > 0 ) && ( !maskxisnull ) )
{
itk::ImageRegionIteratorWithIndex<ImageType> it( maskx,
maskx->GetLargestPossibleRegion() );
vMatrix priorROIMatx( nImagesx , X.cols() );
priorROIMatx.fill( 0 );
for ( unsigned int i = 0; i < nImagesx; i++ )
{
typename ImageType::Pointer init =
Rcpp::as<ImagePointerType>( initializationListx[i] );
unsigned long ct = 0;
it.GoToBegin();
while ( !it.IsAtEnd() )
{
PixelType pix = it.Get();
if ( pix >= 0.5 )
{
pix = init->GetPixel( it.GetIndex() );
priorROIMatx( i, ct ) = pix;
ct++;
}
++it;
}
}
sccanobj->SetMatrixPriorROI( priorROIMatx );
nvecs = nImagesx;
}
unsigned int nImagesy = initializationListy.size();
if ( ( nImagesy > 0 ) && ( !maskyisnull ) )
{
itk::ImageRegionIteratorWithIndex<ImageType> it( masky,
masky->GetLargestPossibleRegion() );
vMatrix priorROIMaty( nImagesy , Y.cols() );
priorROIMaty.fill( 0 );
for ( unsigned int i = 0; i < nImagesy; i++ )
{
typename ImageType::Pointer init =
Rcpp::as<ImagePointerType>( initializationListy[i] );
unsigned long ct = 0;
it.GoToBegin();
while ( !it.IsAtEnd() )
{
PixelType pix = it.Get();
if ( pix >= 0.5 )
{
pix = init->GetPixel( it.GetIndex() );
priorROIMaty( i, ct ) = pix;
ct++;
}
++it;
}
}
sccanobj->SetMatrixPriorROI2( priorROIMaty );
nvecs = nImagesy;
}
sccanobj->SetPriorWeight( priorWeight );
sccanobj->SetLambda( priorWeight );
// cast hack from Rcpp type to sccan type
std::vector<double> xdat =
Rcpp::as< std::vector<double> >( X );
const double* _xdata = &xdat[0];
vMatrix vnlX( _xdata , X.cols(), X.rows() );
vnlX = vnlX.transpose();
//.........这里部分代码省略.........
示例6: switch
void mitk::MRNormLinearStatisticBasedFilter::InternalComputeMask(itk::Image<TPixel, VImageDimension>* itkImage)
{
// Define all necessary Types
typedef itk::Image<TPixel, VImageDimension> ImageType;
typedef itk::Image<int, VImageDimension> MaskType;
typedef itk::LabelStatisticsImageFilter<ImageType, MaskType> FilterType;
typedef itk::MinimumMaximumImageCalculator<ImageType> MinMaxComputerType;
typename MaskType::Pointer itkMask0 = MaskType::New();
mitk::CastToItkImage(this->GetMask(), itkMask0);
typename ImageType::Pointer outImage = ImageType::New();
mitk::CastToItkImage(this->GetOutput(0), outImage);
typename MinMaxComputerType::Pointer minMaxComputer = MinMaxComputerType::New();
minMaxComputer->SetImage(itkImage);
minMaxComputer->Compute();
typename FilterType::Pointer labelStatisticsImageFilter = FilterType::New();
labelStatisticsImageFilter->SetUseHistograms(true);
labelStatisticsImageFilter->SetHistogramParameters(256, minMaxComputer->GetMinimum(),minMaxComputer->GetMaximum());
labelStatisticsImageFilter->SetInput( itkImage );
labelStatisticsImageFilter->SetLabelInput(itkMask0);
labelStatisticsImageFilter->Update();
double median0 = labelStatisticsImageFilter->GetMedian(1);
double mean0 = labelStatisticsImageFilter->GetMean(1);
double stddev = labelStatisticsImageFilter->GetSigma(1);
double modulo0=0;
{
auto histo = labelStatisticsImageFilter->GetHistogram(1);
double maxFrequency=0;
for (auto hIter=histo->Begin();hIter!=histo->End();++hIter)
{
if (maxFrequency < hIter.GetFrequency())
{
maxFrequency = hIter.GetFrequency();
modulo0 = (histo->GetBinMin(0,hIter.GetInstanceIdentifier()) + histo->GetBinMax(0,hIter.GetInstanceIdentifier())) / 2.0;
}
}
}
double value0=0;
switch (m_CenterMode)
{
case MRNormLinearStatisticBasedFilter::MEAN:
value0=mean0; break;
case MRNormLinearStatisticBasedFilter::MEDIAN:
value0=median0; break;
case MRNormLinearStatisticBasedFilter::MODE:
value0=modulo0; break;
}
double offset = value0;
double scaling = stddev;
if (scaling < 0.0001)
return;
itk::ImageRegionIterator<ImageType> inIter(itkImage, itkImage->GetLargestPossibleRegion());
itk::ImageRegionIterator<ImageType> outIter(outImage, outImage->GetLargestPossibleRegion());
while (! inIter.IsAtEnd())
{
TPixel value = inIter.Value();
outIter.Set((value - offset) / scaling);
++inIter;
++outIter;
}
}
示例7: sourceIter
void mitk::SurfaceStampImageFilter::SurfaceStampProcessing(itk::Image<TPixel, 3> *input, MeshType *mesh)
{
typedef itk::Image<TPixel, 3> ImageType;
typedef itk::Image<unsigned char, 3> BinaryImageType;
typedef itk::TriangleMeshToBinaryImageFilter<mitk::SurfaceStampImageFilter::MeshType, BinaryImageType> FilterType;
BinaryImageType::Pointer binaryInput = BinaryImageType::New();
binaryInput->SetSpacing(input->GetSpacing());
binaryInput->SetOrigin(input->GetOrigin());
binaryInput->SetDirection(input->GetDirection());
binaryInput->SetRegions(input->GetLargestPossibleRegion());
binaryInput->Allocate();
binaryInput->FillBuffer(0);
FilterType::Pointer filter = FilterType::New();
filter->SetInput(mesh);
filter->SetInfoImage(binaryInput);
filter->SetInsideValue(1);
filter->SetOutsideValue(0);
filter->Update();
BinaryImageType::Pointer resultImage = filter->GetOutput();
resultImage->DisconnectPipeline();
mitk::Image::Pointer outputImage = this->GetOutput();
typename ImageType::Pointer itkOutputImage;
mitk::CastToItkImage(outputImage, itkOutputImage);
typedef itk::ImageRegionConstIterator<BinaryImageType> BinaryIteratorType;
typedef itk::ImageRegionConstIterator<ImageType> InputIteratorType;
typedef itk::ImageRegionIterator<ImageType> OutputIteratorType;
BinaryIteratorType sourceIter(resultImage, resultImage->GetLargestPossibleRegion());
sourceIter.GoToBegin();
InputIteratorType inputIter(input, input->GetLargestPossibleRegion());
inputIter.GoToBegin();
OutputIteratorType outputIter(itkOutputImage, itkOutputImage->GetLargestPossibleRegion());
outputIter.GoToBegin();
typename ImageType::PixelType inputValue;
unsigned char sourceValue;
auto fgValue = static_cast<typename ImageType::PixelType>(m_ForegroundValue);
auto bgValue = static_cast<typename ImageType::PixelType>(m_BackgroundValue);
while (!sourceIter.IsAtEnd())
{
sourceValue = static_cast<unsigned char>(sourceIter.Get());
inputValue = static_cast<typename ImageType::PixelType>(inputIter.Get());
if (sourceValue != 0)
outputIter.Set(fgValue);
else if (m_OverwriteBackground)
outputIter.Set(bgValue);
else
outputIter.Set(inputValue);
++sourceIter;
++inputIter;
++outputIter;
}
}
示例8: jointLabelFusionNeighborhoodSearchHelper
SEXP jointLabelFusionNeighborhoodSearchHelper(
SEXP r_intvec,
SEXP r_center,
unsigned int rad,
unsigned int radSearch,
SEXP r_antsimage,
SEXP r_antsimageseg)
{
unsigned int segval = 0;
typedef typename ImageType::Pointer ImagePointerType;
const unsigned int ImageDimension = ImageType::ImageDimension;
typedef float PixelType;
typename ImageType::Pointer image =
Rcpp::as< ImagePointerType >( r_antsimage );
typename ImageType::Pointer imageseg =
Rcpp::as< ImagePointerType >( r_antsimageseg );
Rcpp::NumericVector intvec( r_intvec );
Rcpp::NumericVector outvec =
Rcpp::NumericVector( intvec.size(), Rcpp::NumericVector::get_na() );
Rcpp::NumericVector bestvec =
Rcpp::NumericVector( intvec.size(), Rcpp::NumericVector::get_na() );
Rcpp::NumericVector outsegvec =
Rcpp::NumericVector( intvec.size(), Rcpp::NumericVector::get_na() );
Rcpp::NumericVector bestsegvec =
Rcpp::NumericVector( intvec.size(), Rcpp::NumericVector::get_na() );
Rcpp::NumericVector center( r_center );
if ( center.size() != ImageDimension )
Rcpp::stop("jointLabelFusionNeighborhoodSearchHelper dim error.");
typename itk::NeighborhoodIterator<ImageType>::SizeType nSize;
typename itk::NeighborhoodIterator<ImageType>::SizeType nSizeSearch;
typename ImageType::IndexType ind;
ind.Fill( 0 );
for ( unsigned int i=0; i<ImageDimension; i++ )
{
nSize[i] = rad;
nSizeSearch[i] = radSearch;
ind[i] = center[i]; // R coords to ITK
}
itk::NeighborhoodIterator<ImageType> nit( nSize, image,
image->GetLargestPossibleRegion() ) ;
itk::NeighborhoodIterator<ImageType> nitSearch( nSizeSearch, image,
image->GetLargestPossibleRegion() ) ;
// for each location in nitSearch, compute the correlation
// of the intvec with the nit neighborhood
nitSearch.SetLocation( ind );
PixelType bestcor = 1.e11;
PixelType bestsd = 0;
PixelType bestmean = 0;
for( unsigned int i = 0; i < nitSearch.Size(); i++ )
{
typename ImageType::IndexType ind2 = nitSearch.GetIndex(i);
nit.SetLocation( ind2 );
PixelType outmean = 0;
PixelType outsd = 0;
PixelType inmean = 0;
PixelType insd = 0;
for ( unsigned int i=0; i < intvec.size(); i++ ) {
PixelType pix = image->GetPixel( nit.GetIndex(i) );
outvec[i] = pix;
outsegvec[i] = imageseg->GetPixel( nit.GetIndex(i) );
outmean += pix;
inmean += intvec[i];
}
outmean /= ( static_cast<PixelType>(intvec.size()) );
inmean /= ( static_cast<PixelType>(intvec.size()) );
for ( unsigned int i=0; i < intvec.size(); i++ ) {
// should use recursive formula in above loop
outsd += ( outvec[i] - outmean ) * ( outvec[i] - outmean );
insd += ( intvec[i] - inmean ) * ( intvec[i] - inmean );
}
outsd = sqrt( outsd );
insd = sqrt( insd );
PixelType sum_uv = 0;
PixelType sum_psearch = 0;
PixelType ssq_psearch = 0;
unsigned int n = intvec.size();
for(unsigned int i = 0; i < n; i++)
{
PixelType v = intvec[i];
PixelType u = outvec[i];
sum_psearch += u;
ssq_psearch += u * u;
sum_uv += u * v;
}
PixelType var_u_unnorm = ssq_psearch - sum_psearch * sum_psearch / n;
if(var_u_unnorm < 1.0e-6)
var_u_unnorm = 1.0e-6;
PixelType locor = 0;
if ( sum_uv > 0 )
locor = ( -1.0 * (sum_uv * sum_uv) / var_u_unnorm );
else
locor = ( sum_uv * sum_uv ) / var_u_unnorm;
// - (\Sum u_i v_i)^2 / z, where z = sigma_v^2 * (n-1)
// locor = locor / ( insd * outsd );
if ( locor < bestcor )
{
segval = imageseg->GetPixel( ind2 );
for ( unsigned int i=0; i < intvec.size(); i++ ) {
bestvec[i] = outvec[i];
bestsegvec[i] = outsegvec[i];
//.........这里部分代码省略.........
示例9: if
template <class inputType, unsigned int Dimension> medAbstractJob::medJobExitStatus medItkBiasCorrectionProcess::N4BiasCorrectionCore()
{
medJobExitStatus eRes = medAbstractJob::MED_JOB_EXIT_SUCCESS;
typedef itk::Image<inputType, Dimension > ImageType;
typedef itk::Image <float, Dimension> OutputImageType;
typedef itk::Image<unsigned char, Dimension> MaskImageType;
typedef itk::N4BiasFieldCorrectionImageFilter<OutputImageType, MaskImageType, OutputImageType> BiasFilter;
typedef itk::ConstantPadImageFilter<OutputImageType, OutputImageType> PadderType;
typedef itk::ConstantPadImageFilter<MaskImageType, MaskImageType> MaskPadderType;
typedef itk::ShrinkImageFilter<OutputImageType, OutputImageType> ShrinkerType;
typedef itk::ShrinkImageFilter<MaskImageType, MaskImageType> MaskShrinkerType;
typedef itk::BSplineControlPointImageFilter<typename BiasFilter::BiasFieldControlPointLatticeType, typename BiasFilter::ScalarImageType> BSplinerType;
typedef itk::ExpImageFilter<OutputImageType, OutputImageType> ExpFilterType;
typedef itk::DivideImageFilter<OutputImageType, OutputImageType, OutputImageType> DividerType;
typedef itk::ExtractImageFilter<OutputImageType, OutputImageType> CropperType;
unsigned int uiThreadNb = static_cast<unsigned int>(m_poUIThreadNb->value());
unsigned int uiShrinkFactors = static_cast<unsigned int>(m_poUIShrinkFactors->value());
unsigned int uiSplineOrder = static_cast<unsigned int>(m_poUISplineOrder->value());
float fWienerFilterNoise = static_cast<float>(m_poFWienerFilterNoise->value());
float fbfFWHM = static_cast<float>(m_poFbfFWHM->value());
float fConvergenceThreshold = static_cast<float>(m_poFConvergenceThreshold->value());
float fSplineDistance = static_cast<float>(m_poFSplineDistance->value());
float fProgression = 0;
QStringList oListValue = m_poSMaxIterations->value().split("x");
std::vector<unsigned int> oMaxNumbersIterationsVector(oListValue.size());
std::vector<float> oInitialMeshResolutionVect(Dimension);
for (int i=0; i<oMaxNumbersIterationsVector.size(); ++i)
{
oMaxNumbersIterationsVector[i] = (unsigned int)oListValue[i].toInt();
}
oInitialMeshResolutionVect[0] = static_cast<float>(m_poFInitialMeshResolutionVect1->value());
oInitialMeshResolutionVect[1] = static_cast<float>(m_poFInitialMeshResolutionVect2->value());
oInitialMeshResolutionVect[2] = static_cast<float>(m_poFInitialMeshResolutionVect3->value());
typename ImageType::Pointer image = dynamic_cast<ImageType *>((itk::Object*)(this->input()->data()));
typedef itk::CastImageFilter <ImageType, OutputImageType> CastFilterType;
typename CastFilterType::Pointer castFilter = CastFilterType::New();
castFilter->SetInput(image);
/********************************************************************************/
/***************************** PREPARING STARTING *******************************/
/********************************************************************************/
/*** 0 ******************* Create filter and accessories ******************/
ABORT_CHECKING(m_bAborting);
typename BiasFilter::Pointer filter = BiasFilter::New();
typename BiasFilter::ArrayType oNumberOfControlPointsArray;
m_filter = filter;
/*** 1 ******************* Read input image *******************************/
ABORT_CHECKING(m_bAborting);
fProgression = 1;
updateProgression(fProgression);
/*** 2 ******************* Creating Otsu mask *****************************/
ABORT_CHECKING(m_bAborting);
itk::TimeProbe timer;
timer.Start();
typename MaskImageType::Pointer maskImage = ITK_NULLPTR;
typedef itk::OtsuThresholdImageFilter<OutputImageType, MaskImageType> ThresholderType;
typename ThresholderType::Pointer otsu = ThresholderType::New();
m_filter = otsu;
otsu->SetInput(castFilter->GetOutput());
otsu->SetNumberOfHistogramBins(200);
otsu->SetInsideValue(0);
otsu->SetOutsideValue(1);
otsu->SetNumberOfThreads(uiThreadNb);
otsu->Update();
updateProgression(fProgression);
maskImage = otsu->GetOutput();
/*** 3A *************** Set Maximum number of Iterations for the filter ***/
ABORT_CHECKING(m_bAborting);
typename BiasFilter::VariableSizeArrayType itkTabMaximumIterations;
itkTabMaximumIterations.SetSize(oMaxNumbersIterationsVector.size());
for (int i = 0; i < oMaxNumbersIterationsVector.size(); ++i)
{
itkTabMaximumIterations[i] = oMaxNumbersIterationsVector[i];
}
filter->SetMaximumNumberOfIterations(itkTabMaximumIterations);
/*** 3B *************** Set Fitting Levels for the filter *****************/
typename BiasFilter::ArrayType oFittingLevelsTab;
oFittingLevelsTab.Fill(oMaxNumbersIterationsVector.size());
filter->SetNumberOfFittingLevels(oFittingLevelsTab);
updateProgression(fProgression);
/*** 4 ******************* Save image's index, size, origine **************/
ABORT_CHECKING(m_bAborting);
typename ImageType::IndexType oImageIndex = image->GetLargestPossibleRegion().GetIndex();
typename ImageType::SizeType oImageSize = image->GetLargestPossibleRegion().GetSize();
typename ImageType::PointType newOrigin = image->GetOrigin();
//.........这里部分代码省略.........