C++ typenamefiltertype::Pointer类代码示例

void
  CalculateVolumeStatistic(itk::Image<TPixel, VImageDimension>* itkImage, mitk::Image::Pointer mask, mitk::GIFVolumetricStatistics::FeatureListType & featureList, std::string prefix)
{
  typedef itk::Image<TPixel, VImageDimension> ImageType;
  typedef itk::Image<int, VImageDimension> MaskType;
  typedef itk::LabelStatisticsImageFilter<ImageType, MaskType> FilterType;

  typename MaskType::Pointer maskImage = MaskType::New();
  mitk::CastToItkImage(mask, maskImage);

  typename FilterType::Pointer labelStatisticsImageFilter = FilterType::New();
  labelStatisticsImageFilter->SetInput( itkImage );
  labelStatisticsImageFilter->SetLabelInput(maskImage);
  labelStatisticsImageFilter->Update();

  double volume = labelStatisticsImageFilter->GetCount(1);
  double voxelVolume = 1;
  for (int i = 0; i < (int)(VImageDimension); ++i)
  {
    volume *= itkImage->GetSpacing()[i];
    voxelVolume *= itkImage->GetSpacing()[i];
  }

  featureList.push_back(std::make_pair(prefix + "Voxel Volume", voxelVolume));
  featureList.push_back(std::make_pair(prefix + "Volume (voxel based)", volume));
}

void ComputeMaskedIsophotesInRegion(const TVectorImageType* const image, const Mask* const mask,
                                    const itk::ImageRegion<2>& region, TIsophoteImageType* const outputIsophotes)
{
  //Helpers::WriteImageConditional<FloatScalarImageType>(image, "Debug/ComputeMaskedIsophotes.luminance.mha",
//                                                      this->DebugImages);

  typename TIsophoteImageType::Pointer gradient = TIsophoteImageType::New();
  ITKHelpers::InitializeImage(gradient.GetPointer(), image->GetLargestPossibleRegion());
  Derivatives::MaskedGradientInRegion(image, mask, region, gradient.GetPointer());

  //Helpers::DebugWriteImageConditional<FloatVector2ImageType>(gradient,
  //               "Debug/ComputeMaskedIsophotes.gradient.mha", this->DebugImages);
  //Helpers::Write2DVectorImage(gradient, "Debug/ComputeMaskedIsophotes.gradient.mha");

  // Rotate the gradient 90 degrees to obtain isophotes from gradient
  typedef itk::UnaryFunctorImageFilter<TIsophoteImageType, TIsophoteImageType,
  RotateVectors<typename TIsophoteImageType::PixelType,
                typename TIsophoteImageType::PixelType> > FilterType;

  typename FilterType::Pointer rotateFilter = FilterType::New();
  rotateFilter->SetInput(gradient);
  rotateFilter->Update();

  //Helpers::DebugWriteImageConditional<FloatVector2ImageType>(rotateFilter->GetOutput(),
  //                   "Debug/ComputeMaskedIsophotes.Isophotes.mha", this->DebugImages);
  //Helpers::Write2DVectorImage(rotateFilter->GetOutput(), "Debug/ComputeMaskedIsophotes.Isophotes.mha");

  ITKHelpers::CopyRegion(rotateFilter->GetOutput(), outputIsophotes, region, region);
}

void QmitkOdfMaximaExtractionView::TemplatedConvertShCoeffsFromFsl(mitk::Image* mitkImg)
{
    typedef itk::FslShCoefficientImageConverter< float, shOrder > FilterType;
    typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
    CasterType::Pointer caster = CasterType::New();
    caster->SetInput(mitkImg);
    caster->Update();

    typename FilterType::Pointer filter = FilterType::New();
    filter->SetInputImage(caster->GetOutput());
    filter->GenerateData();
    typename FilterType::QballImageType::Pointer itkQbi = filter->GetQballImage();
    typename FilterType::CoefficientImageType::Pointer itkCi = filter->GetCoefficientImage();

    {
        mitk::Image::Pointer img = mitk::Image::New();
        img->InitializeByItk( itkCi.GetPointer() );
        img->SetVolume( itkCi->GetBufferPointer() );
        DataNode::Pointer node = DataNode::New();
        node->SetData(img);
        node->SetName("FSL_ShCoefficientImage");
        GetDataStorage()->Add(node);
    }

    {
        mitk::QBallImage::Pointer img = mitk::QBallImage::New();
        img->InitializeByItk( itkQbi.GetPointer() );
        img->SetVolume( itkQbi->GetBufferPointer() );
        DataNode::Pointer node = DataNode::New();
        node->SetData(img);
        node->SetName("FSL_QballImage");
        GetDataStorage()->Add(node);
    }
}

void medResliceViewer::generateOutput(vtkImageReslice* reslicer, QString destType)
{
    typedef itk::Image<DATA_TYPE, 3> ImageType;

    typedef itk::VTKImageToImageFilter<ImageType> FilterType;
    typename FilterType::Pointer filter = FilterType::New();
    filter->SetInput(reslicer->GetOutput());
    filter->Update();
    filter->GetOutput()->Update();

    outputData = medAbstractDataFactory::instance()->createSmartPointer(destType);
    outputData->setData(filter->GetOutput());

    // Apply resampling in pix
    if (reformaTlbx->findChild<QComboBox*>("bySpacingOrDimension")->currentText() == "Dimension")
    {
        applyResamplingPix();
    }

    typename ImageType::Pointer outputImage = static_cast<itk::Image<DATA_TYPE, 3>*>(outputData->data());

    compensateForRadiologicalView<DATA_TYPE>(outputImage);
    correctOutputTransform<DATA_TYPE>(outputImage, reslicer->GetResliceAxes());

    // Final output image
    outputData->setData(outputImage);

    medUtilities::setDerivedMetaData(outputData, inputData, "reformatted");
    medUtilitiesITK::updateMetadata<ImageType>(outputData);
}

void mitk::CLUtil::itkFillHoleGrayscale(TImageType * image, mitk::Image::Pointer & outimage)
{
  typedef itk::GrayscaleFillholeImageFilter<TImageType,TImageType>    FilterType;

  typename FilterType::Pointer filter = FilterType::New();
  filter->SetInput(image);
  filter->Update();

  mitk::CastToMitkImage(filter->GetOutput(),outimage);
}

void BayesianClassifierImageFilterITK::bayesianClassifierImageFilterITK() {

    if (!enableProcessing_.get()) {
        outport1_.setData(inport1_.getData(), false);
        return;
    }

    typedef itk::Image<T, 3> InputImageType;
    typedef itk::Image<uint8_t, 3> OutputImageType;
    typedef itk::VectorImage<float, 3> VectorImageType;
    typename InputImageType::Pointer p1 = voreenToITK<T>(inport1_.getData());

    typedef itk::BayesianClassifierInitializationImageFilter<InputImageType> InitFilterType;
    typename InitFilterType::Pointer initializer = InitFilterType::New();

    initializer->SetInput(p1);
    initializer->SetNumberOfClasses(numberOfClasses_.get());

    try
    {
        initializer->Update();
    }
    catch (itk::ExceptionObject &e)
    {
        LERROR(e);
    }
    //Filter define
    typedef itk::BayesianClassifierImageFilter<VectorImageType> FilterType;
    typename FilterType::Pointer filter = FilterType::New();

    filter->SetInput(0, initializer->GetOutput());
    observe(filter.GetPointer());

    try
    {
        filter->Update();

    }
    catch (itk::ExceptionObject &e)
    {
        LERROR(e);
    }


    Volume* outputVolume1 = 0;
    outputVolume1 = ITKToVoreenCopy<uint8_t>(filter->GetOutput());

    if (outputVolume1) {
        transferTransformation(inport1_.getData(), outputVolume1);
        outport1_.setData(outputVolume1);
    }
    else
        outport1_.setData(0);

}

void DiscreteGaussianImageFilterITK::discreteGaussianImageFilterITK() {
    maximumError_.setVolume(inport1_.getData());
    maximumError_.setMinValue<T>(1.0f);
    variance_.setVolume(inport1_.getData());

    if (!enableProcessing_.get()) {
        outport1_.setData(inport1_.getData(), false);
        return;
    }

    typedef itk::Image<T, 3> InputImageType1;
    typedef itk::Image<float, 3> OutputImageType1;

    typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());


    //Filter define
    typedef itk::DiscreteGaussianImageFilter<InputImageType1, OutputImageType1> FilterType;
    typename FilterType::Pointer filter = FilterType::New();

    filter->SetInput(p1);

    filter->SetInternalNumberOfStreamDivisions(internalNumberOfStreamDivisions_.get());
    filter->SetMaximumError(maximumError_.getValue<T>());
    filter->SetVariance(variance_.getValue<T>());
    filter->SetUseImageSpacing(useImageSpacing_.get());
    filter->SetFilterDimensionality(filterDimensionality_.get());


    observe(filter.GetPointer());

    try
    {
        filter->Update();

    }
    catch (itk::ExceptionObject &e)
    {
        LERROR(e);
    }


    Volume* outputVolume1 = 0;
    outputVolume1 = ITKToVoreenCopy<float>(filter->GetOutput());

    if (outputVolume1) {
        transferRWM(inport1_.getData(), outputVolume1);
        transferTransformation(inport1_.getData(), outputVolume1);
        outport1_.setData(outputVolume1);
    } else
        outport1_.setData(0);



}

void AddOffset(itk::Image<TPixel, VImageDimension>* image, int offset, mitk::Image::Pointer outputImage)
{
  typedef itk::Image<TPixel, VImageDimension> ImageType;
  typedef itk::ShiftScaleInPlaceImageFilter<ImageType> FilterType;

  typename FilterType::Pointer filter = FilterType::New();
  filter->SetShift(offset);

  filter->SetInput(image);
  filter->Update();
  mitk::CastToMitkImage(filter->GetOutput(), outputImage);
}

void SignedDanielssonDistanceMapImageFilterITK::signedDanielssonDistanceMapImageFilterITK() {


    typedef itk::Image<T, 3> InputImageType1;
    typedef itk::Image<T, 3> OutputImageType1;
    typedef itk::Image<T, 3> OutputImageType2;

    typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());


    //Filter define
    typedef itk::SignedDanielssonDistanceMapImageFilter<InputImageType1, OutputImageType1> FilterType;
    typename FilterType::Pointer filter = FilterType::New();

    filter->SetInput(p1);

    filter->SetInsideIsPositive(insideIsPositive_.get());
    filter->SetSquaredDistance(squaredDistance_.get());
    filter->SetUseImageSpacing(useImageSpacing_.get());


    observe(filter.GetPointer());

    try
    {
        filter->Update();

    }
    catch (itk::ExceptionObject &e)
    {
        LERROR(e);
    }


    Volume* outputVolume1 = 0;
    outputVolume1 = ITKToVoreenCopy<T>(filter->GetDistanceMap());

    if (outputVolume1) {
        transferRWM(inport1_.getData(), outputVolume1);
        transferTransformation(inport1_.getData(), outputVolume1);
        outport1_.setData(outputVolume1);
    } else
        outport1_.setData(0);

    Volume* outputVolume2 = 0;
    outputVolume2 = ITKToVoreenCopy<T>(filter->GetVoronoiMap());

    if (outputVolume2) {
        transferRWM(inport1_.getData(), outputVolume2);
        transferTransformation(inport1_.getData(), outputVolume2);
        outport2_.setData(outputVolume2);
    } else
        outport2_.setData(0);



}

void IntensityWindowingImageFilterITK::intensityWindowingImageFilterITK() {
    outputMinimum_.setVolume(inport1_.getData());
    outputMaximum_.setVolume(inport1_.getData());
    windowMinimum_.setVolume(inport1_.getData());
    windowMaximum_.setVolume(inport1_.getData());

    if (!enableProcessing_.get()) {
        outport1_.setData(inport1_.getData(), false);
        return;
    }

    typedef itk::Image<T, 3> InputImageType1;
    typedef itk::Image<T, 3> OutputImageType1;

    typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());


    //Filter define
    typedef itk::IntensityWindowingImageFilter<InputImageType1, OutputImageType1> FilterType;
    typename FilterType::Pointer filter = FilterType::New();

    filter->SetInput(p1);

    filter->SetOutputMinimum(outputMinimum_.getValue<T>());
    filter->SetOutputMaximum(outputMaximum_.getValue<T>());
    filter->SetWindowMinimum(windowMinimum_.getValue<T>());
    filter->SetWindowMaximum(windowMaximum_.getValue<T>());


    observe(filter.GetPointer());

    try
    {
        filter->Update();

    }
    catch (itk::ExceptionObject &e)
    {
        LERROR(e);
    }


    Volume* outputVolume1 = 0;
    outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());

    if (outputVolume1) {
        transferRWM(inport1_.getData(), outputVolume1);
        transferTransformation(inport1_.getData(), outputVolume1);
        outport1_.setData(outputVolume1);
    } else
        outport1_.setData(0);



}

void mitk::CLUtil::itkDilateGrayscale(TImageType * image, mitk::Image::Pointer & outimage , unsigned int radius, mitk::CLUtil::MorphologicalDimensions d)
{
  typedef itk::BinaryBallStructuringElement<typename TImageType::PixelType, 3>          StructureElementType;
  typedef itk::GrayscaleDilateImageFilter<TImageType,TImageType,StructureElementType>    FilterType;

  StructureElementType ball;
  itkFitStructuringElement(ball,d, radius);

  typename FilterType::Pointer filter = FilterType::New();
  filter->SetKernel(ball);
  filter->SetInput(image);
  filter->Update();

  mitk::CastToMitkImage(filter->GetOutput(),outimage);
}

typename ImageType::Pointer convolveImageHelper(
  typename ImageType::Pointer image,
  typename ImageType::Pointer kernel )
{
  enum { Dimension = ImageType::ImageDimension };
  if( image.IsNotNull() & kernel.IsNotNull() )
    {
    typedef itk::ConvolutionImageFilter<ImageType> FilterType;
    typename FilterType::Pointer convolutionFilter = FilterType::New();
    convolutionFilter->SetInput( image );
    convolutionFilter->SetKernelImage( kernel );
    convolutionFilter->Update();
    return convolutionFilter->GetOutput();
    }
  return NULL;
}

void mitk::ShImage::Construct() const
{
  typedef itk::Image<itk::Vector<float, ( nShOrder * nShOrder + nShOrder + 2)/2 + nShOrder >,3> ImageType;
  typedef itk::ShToRgbImageFilter<ImageType, nShOrder> FilterType;
  typename FilterType::Pointer filter = FilterType::New();

  typename ImageType::Pointer itkvol = ImageType::New();
  mitk::CastToItkImage(this, itkvol);
  filter->SetInput(itkvol);
  filter->Update();

  itk::Image<itk::RGBAPixel<unsigned char>,3>::Pointer tmp = filter->GetOutput();
  m_RgbImage = mitk::Image::New();
  m_RgbImage->InitializeByItk( tmp.GetPointer() );
  m_RgbImage->SetVolume( tmp->GetBufferPointer() );
}

int itkFiltersComponentSizeThresholdProcess::updateProcess(medAbstractData* inputData)
{
    dtkSmartPointer<medAbstractData> adjustedInputData = inputData;

    if (std::is_floating_point<typename InputImageType::PixelType>::value)
    {
        adjustedInputData = castToOutputType<InputImageType>(inputData);;
    }

    typename InputImageType::Pointer inputImage = static_cast<InputImageType*>(inputData->data());

    typedef itk::ConnectedComponentImageFilter <InputImageType, OutputImageType> ConnectedComponentFilterType;
    typename ConnectedComponentFilterType::Pointer connectedComponentFilter = ConnectedComponentFilterType::New();
    connectedComponentFilter->SetInput(inputImage);
    connectedComponentFilter->Update();

    // RELABEL COMPONENTS according to their sizes (0:largest(background))
    typedef itk::RelabelComponentImageFilter<OutputImageType, OutputImageType> FilterType;
    typename FilterType::Pointer relabelFilter = FilterType::New();
    relabelFilter->SetInput(connectedComponentFilter->GetOutput());
    relabelFilter->SetMinimumObjectSize(d->minimumSize);
    relabelFilter->Update();

    // BINARY FILTER
    typedef itk::BinaryThresholdImageFilter <OutputImageType, OutputImageType> BinaryThresholdImageFilterType;
    typename BinaryThresholdImageFilterType::Pointer thresholdFilter
            = BinaryThresholdImageFilterType::New();
    thresholdFilter->SetInput(relabelFilter->GetOutput());
    thresholdFilter->SetUpperThreshold(0);
    thresholdFilter->SetInsideValue(0);
    thresholdFilter->SetOutsideValue(1);

    thresholdFilter->Update();

    itk::CStyleCommand::Pointer callback = itk::CStyleCommand::New();
    callback->SetClientData ( ( void * ) this );
    callback->SetCallback ( itkFiltersProcessBase::eventCallback );
    connectedComponentFilter->AddObserver ( itk::ProgressEvent(), callback );

    setOutputData(medAbstractDataFactory::instance()->createSmartPointer(medUtilitiesITK::itkDataImageId<OutputImageType>()));
    getOutputData()->setData ( thresholdFilter->GetOutput() );

    QString newSeriesDescription = "connectedComponent " + QString::number(d->minimumSize);
    medUtilities::setDerivedMetaData(getOutputData(), inputData, newSeriesDescription);

    return DTK_SUCCEED;
}

void OtsuThresholdImageFilterITK::otsuThresholdImageFilterITK() {
    outsideValue_.setVolume(inport1_.getData());
    outsideValue_.setMinValue<T>(0.0001f);
    insideValue_.setVolume(inport1_.getData());
    insideValue_.setMinValue<T>(0.0001f);

    if (!enableProcessing_.get()) {
        outport1_.setData(inport1_.getData(), false);
        return;
    }

    typedef itk::Image<T, 3> InputImageType1;
    typedef itk::Image<T, 3> OutputImageType1;

    typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());


    //Filter define
    typedef itk::OtsuThresholdImageFilter<InputImageType1, OutputImageType1> FilterType;
    typename FilterType::Pointer filter = FilterType::New();

    filter->SetInput(p1);

    filter->SetNumberOfHistogramBins(numberOfHistogramBins_.get());
    filter->SetOutsideValue(outsideValue_.getValue<T>());
    filter->SetInsideValue(insideValue_.getValue<T>());


    observe(filter.GetPointer());

    try
    {
        filter->Update();

    }
    catch (itk::ExceptionObject &e)
    {
        LERROR(e);
    }


    Volume* outputVolume1 = 0;
    outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());

    if (outputVolume1) {
        transferRWM(inport1_.getData(), outputVolume1);
        transferTransformation(inport1_.getData(), outputVolume1);
        outport1_.setData(outputVolume1);
    } else
        outport1_.setData(0);



}