《itk实用demo》-B样条曲线---pointsToBSplinefliter

版权声明：本文为博主原创文章，转载请注明出处，谢谢 https://blog.csdn.net/rabbitbride/article/details/82423033

B样条曲线—pointsToBSplinefliter

PointSetType::Pointer 
    pointsToBSplinefliter(ImageType::Pointer image,PointSetType::Pointer pointset_temp)
{
    const unsigned int ParametricDimension = 1;
    const unsigned int DataDimension = 2;
    typedef itk::Vector< float, DataDimension > floatDataType;
    typedef itk::PointSet< floatDataType, ParametricDimension >   floatPointSetType;
    floatPointSetType::Pointer pointset = floatPointSetType::New();

    for (int i=0;i < pointset_temp->GetNumberOfPoints();i++)
    {
        PointType pos_this;
        pointset_temp->GetPoint( i, &pos_this );

        floatPointSetType::PointType param;
        param[0] = (float)i;

        floatDataType pos_this2;
        pos_this2[0] =(float)pos_this[0];
        pos_this2[1] = (float)pos_this[1];
        //cout<<"pos_this2:"<<pos_this2[0]<<","<<pos_this2[1]<<endl;

        pointset->SetPoint(i, param);
        pointset->SetPointData( i, pos_this2 );
    }

    //cout<<"pointSet size"<<pointset->GetNumberOfPoints()<<endl;

    typedef itk::Image<floatDataType, ParametricDimension> floatImageType;
    typedef itk::BSplineScatteredDataPointSetToImageFilter < floatPointSetType, floatImageType > SplineFilterType;
    SplineFilterType::Pointer splineFilter = SplineFilterType::New();
    int splineorder= 2; // complexity of the spline

    SplineFilterType::ArrayType ncontrol;
    ncontrol[0]=splineorder + 1;
    SplineFilterType::ArrayType closedim;
    closedim[0]= 0;

    floatImageType::PointType parametricDomainOrigin;
    parametricDomainOrigin[0] = 0.0;

    floatImageType::SpacingType parametricDomainSpacing;
    parametricDomainSpacing[0] = 0.0001;  // this determines the sampling of the continuous B-spline object.

    floatImageType::SizeType parametricDomainSize;
    float fuck_temp = pointset->GetNumberOfPoints() - 1;//  [8/17/2016 winston-pc]
    parametricDomainSize[0] = fuck_temp / parametricDomainSpacing[0] + 1;
    splineFilter->SetGenerateOutputImage( true );   // the only reason to turn this off is if one only wants to use the control point lattice for further processing
    splineFilter->SetInput ( pointset );
    splineFilter->SetSplineOrder ( splineorder );
    splineFilter->SetNumberOfControlPoints ( ncontrol );
    splineFilter->SetNumberOfLevels( 10 );//  [8/17/2016 winston-pc]
    splineFilter->SetCloseDimension ( closedim );
    splineFilter->SetSize( parametricDomainSize );
    splineFilter->SetSpacing( parametricDomainSpacing );
    splineFilter->SetOrigin( parametricDomainOrigin );
    splineFilter->Update();

    ImageType::RegionType inputRegion = image->GetLargestPossibleRegion();
    ImageType::SizeType size = inputRegion.GetSize();
    ImageType::IndexType start  = inputRegion.GetIndex();
    itk::ImageRegion<2> region(start, size);
    ImageType::Pointer outputImage = ImageType2D::New();
    outputImage->SetRegions(region);
    outputImage->Allocate();
    outputImage->FillBuffer(0);

    for(unsigned int i = 0; i < splineFilter->GetOutput()->GetLargestPossibleRegion().GetSize()[0]; ++i)
    {
        floatImageType::IndexType splineIndex;
        splineIndex[0] = i;

        floatDataType outputPixel = splineFilter->GetOutput()->GetPixel(splineIndex);

        ImageType::IndexType index;
        index[0] = outputPixel[0];
        index[1] = outputPixel[1];
        index[2] = sliceIndex;
        outputImage->SetPixel(index, 5 );
    }

    PointSetType::Pointer pointset_output= this->ImageToPoints(outputImage);
    return pointset_output;
}
--------------------------------------------------------------------------------
PointSetType::Pointer 
    pointsToSplinefliter(PointSetType::Pointer pointset_temp)
{
    PointSetType::Pointer  PointSet = PointSetType::New();
    PointsContainerPointer  points = PointSet->GetPoints();
    int temp_index = 0;
    for (int i=0;i < pointset_temp->GetNumberOfPoints()-4;i++)
    {
        if (i%3 != 0)
            continue;

        PointType pos_this;
        pointset_temp->GetPoint( i, &pos_this );
        PointType pos_next;
        pointset_temp->GetPoint( i+3, &pos_next );

        itk::Index<2> pixel0;
        pixel0[0] = pos_this[0];
        pixel0[1] = pos_this[1];

        itk::Index<2> pixel1;
        pixel1[0] = pos_next[0];
        pixel1[1] = pos_next[1];

        cout<<"pixel:"<<pixel0<<"|"<<pixel1<<endl;

        itk::Point<float,2> point0;
        itk::Point<float,2> point1;
        for(unsigned int i = 0; i < 2; i++)
        {
            point0[i] = pixel0[i];
            point1[i] = pixel1[i];
        }

        itk::BresenhamLine<2> line;

        const unsigned int distance = itk::Math::RoundHalfIntegerToEven<unsigned int, double>( point0.EuclideanDistanceTo(point1) );    
        std::cout <<distance<<std::endl;
        if (distance == 0)
        {
            continue;
        }
        std::vector< itk::Offset<2> > offsets = line.BuildLine(point1-point0, distance);

        for(unsigned int i = 0; i < offsets.size(); i++)
        {            
            PointType p0;
            p0[0] = pos_this[0] + offsets[i][0];
            p0[1] = pos_this[1] + offsets[i][1];
            p0[2] = sliceIndex;
            std::cout << p0 <<"\t"<<distance<<";"<<offsets.size()<<std::endl;
            points->InsertElement(temp_index, p0); 
            temp_index++;
        }
    }
    return PointSet;
}