3d 渲染多重vtkpolydata等高线

我正在尝试制作一些轮廓的三维模型

为此，我使用vtkAppendFilter来附加vtkPolyData（这是我的轮廓）。 然后在新的vtkPolyData实例中获取输出

我放了一个制图器，然后是一个演员。。。等等但出于某种原因

当我渲染它时，我什么也看不到。只是一个黑屏

如果有人知道我错在哪里。请让我知道

多谢各位

以下是代码：

vtkSmartPointer<vtkAppendPolyData> appendFilter = vtkSmartPointer<vtkAppendPolyData>::New();
double z=0;
//Does the job to append them
for(int i=0; i < this->mAllContoursRepresentations.size();i++){
    for(int j=0; j< this->mAllContoursRepresentations.at(i).size();j++){
        // z. is the number of the image
        z = this->mAllContoursRepresentations.at(i).at(j).first;
        //contour to copy
        vtkPolyData* pld = this->mAllContoursRepresentations.at(i).at(j).second->GetContourRepresentationAsPolyData();
        //contour to paste
        vtkSmartPointer<vtkPolyData> vtp = vtkSmartPointer<vtkPolyData>::New();
        //copy contour and paste it in another one
        vtp->DeepCopy(pld);
        vtkPoints* vtpPoints = vtp->GetPoints();
        vtkPoints* pldPoints = pld->GetPoints();
        vtpPoints->SetNumberOfPoints(pld->GetNumberOfPoints());
        for(int k=0;k<vtp->GetNumberOfPoints();k++){
            double toPixel[3];
            double points[3];
            pldPoints->GetPoint(k,points);
            vtkInteractorObserver::ComputeWorldToDisplay(Activity::GetActivity().GetDefaultRendererVisit(),points[0],points[1],points[2],toPixel);
            points[2]= z;
            points[1]=toPixel[1];
            points[0]=toPixel[0];
            vtpPoints->SetPoint(k,points);
        }
        //append contour to the filter
        appendFilter->AddInputData(vtp);
    }
}
appendFilter->Update();

vtkSmartPointer<vtkPolyDataMapper> contoursMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
contoursMapper->SetInputData(contours);
contoursMapper->ScalarVisibilityOff();
vtkSmartPointer<vtkActor> contoursActor = vtkSmartPointer<vtkActor>::New();
contoursActor->SetMapper(contoursMapper);
contoursActor->GetProperty()->SetRepresentationToWireframe();
contoursActor->GetProperty()->SetColor(1,0,1);
vtkSmartPointer<vtkVRMLExporter> exporter = vtkSmartPointer<vtkVRMLExporter>::New();
vtkSmartPointer<vtkRenderer> renderer = vtkSmartPointer<vtkRenderer>::New();
vtkSmartPointer<vtkRenderWindow> renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
vtkSmartPointer<vtkRenderWindowInteractor> interactor = vtkSmartPointer<vtkRenderWindowInteractor>::New();
renderer->AddActor(contoursActor);
renderer->ResetCamera();
renderWindow->AddRenderer(renderer);
interactor->SetRenderWindow(renderWindow);  
renderWindow->Render();
exporter->SetFileName("C:\\Users\\stagiaire\\Desktop\\toto.wrl");
exporter->SetRenderWindow(renderWindow);
exporter->Write();
interactor->Initialize();
interactor->Start();

vtkSmartPointer appendFilter=vtkSmartPointer:：New（）；
双z=0；
//是否执行附加它们的作业
对于（inti=0；imallcourtsresresrepresentations.size（）；i++）{
对于（int j=0；jmall.at（i）.size（）；j++）{
//z.是图像的编号
z=这个->mall.at（i）.at（j）.first；
//要复制的轮廓
vtkPolyData*pld=this->mAllContoursRepresentations.at（i）.at（j）.second->GetContourRepresentationAsPolyData（）；
//要粘贴的轮廓
vtkSmartPointer vtp=vtkSmartPointer:：New（）；
//复制轮廓并粘贴到另一个轮廓中
vtp->DeepCopy（pld）；
vtkPoints*vtpPoints=vtp->GetPoints（）；
vtkPoints*pldPoints=pld->GetPoints（）；
vtpPoints->SetNumberOfPoints（pld->GetNumberOfPoints（））；
对于（int k=0；kGetNumberOfPoints（）；k++）{
双toPixel[3]；
双积分[3]；
pldPoints->GetPoint（k，points）；
VTKInteratorObserver:：ComputeWorldToDisplay（Activity:：GetActivity（）.GetDefaultRenderVisite（），点[0]，点[1]，点[2]，toPixel）；
点[2]=z；
点[1]=toPixel[1]；
点[0]=toPixel[0]；
VTP点->设定点（k，点）；
}
//将轮廓附加到过滤器
appendFilter->AddInputData（vtp）；
}
}
appendFilter->Update（）；
vtkSmartPointer-toursmapper=vtkSmartPointer:：New（）；
轮廓映射->设置输入数据（轮廓）；
轮廓映射->缩放可视性关闭（）；
vtkSmartPointer轮廓器=vtkSmartPointer:：New（）；
轮廓仪->设置映射器（轮廓仪）；
contoursActor->GetProperty（）->SetRepresentationToWireframe（）；
contoursActor->GetProperty（）->SetColor（1,0,1）；
vtkSmartPointer=vtkSmartPointer:：New（）；
vtkSmartPointer=vtkSmartPointer:：New（）；
vtkSmartPointer renderWindow=vtkSmartPointer:：New（）；
vtksmartpointeractor=vtkSmartPointer:：New（）；
渲染器->添加器（轮廓器）；
渲染器->重置摄影机（）；
renderWindow->AddRenderer（渲染器）；
交互器->设置渲染窗口（渲染窗口）；
renderWindow->Render（）；
exporter->SetFileName（“C:\\Users\\stagiaire\\Desktop\\toto.wrl”）；
导出器->设置渲染窗口（渲染窗口）；
导出器->写入（）；
交互->初始化（）；
交互器->开始（）；

多亏了谷歌，我找到了自助的方法

基本上，我所做的是存储我的积分 在一个向量中构建一个新的vtkpolydata结构（它是一个轮廓->简单线）并将其附加到vtkAppendPolyData中。然后使用通常的指令，我渲染它

以下是代码，如果有人需要帮助（请随意询问）：

for（int i=0；imallcourtsresresrepresentations.size（）；i++）{
对于（int j=0；jmall.at（i）.size（）；j++）{
//要复制的轮廓
vtkPolyData*pld=this->mAllContoursRepresentations.at（i）.at（j）.second->GetContourRepresentationAsPolyData（）；
//z.是图像的编号
z=这个->mall.at（i）.at（j）.first；
vtkPoints*pldPoints=pld->GetPoints（）；
int numberPoints=pld->GetNumberOfPoints（）；
对于（int k=0；kGetPoint（k，toWorld）；
VTKInteratorObserver:：ComputeWorldToDisplay（Activity:：GetActivity（）.GetDefaultRenderVisite（），
toWorld[0]、toWorld[1]、toWorld[2]、toPixel）；
qDebug（）SetId（j，j）；
//创建一个单元格数组来存储行并将行添加到其中
vtkSmartPointer单元格=
vtkSmartPointer:：New（）；
单元->插入下一个单元（多段线）；
VTKSmartData=
vtkSmartPointer:：New（）；
//将点添加到数据集
polyData->设定点（点）；
//将行添加到数据集
polyData->设置线（单元格）；
appendFilter->AddInputData（polyData）；
}
pointsContours.clear（）；
appendFilter->Update（）；
vtkSmartPointer-toursmapper=vtkSmartPointer:：New（）；
轮廓映射->设置输入数据（appendFilter->GetOutput（））；
轮廓映射->缩放可视性关闭（）；
vtkSmartPointer轮廓器=vtkSmartPointer:：New（）；
轮廓仪->设置映射器（轮廓仪）；
contoursActor->GetProperty（）->SetRepresentationToWireframe（）；
contoursActor->GetProperty（）->SetColor（0,0,0）；
vtkSmartPointer=vtkSmartPointer:：New（）；
vtkSmartPointer=vtkSmartPointer:：New（）；
vtkSmartPointer renderWindow=vtkSmartPointer:：New（）；
vtksmartpointeractor=vtkSmartPointer:：New（）；
渲染器->添加器（轮廓器）；
渲染器->重置摄影机（）；
renderWindow->AddRenderer（渲染器）；
渲染器->背景设置（1,1,1）；//背景色
交互器->设置渲染窗口（渲染窗口）；
交互->初始化（）；
renderWindow->Render（）；
交互器->开始（）；

这个例子也可能对您有所帮助。

for(int i=0; i < this->mAllContoursRepresentations.size();i++){
        for(int j=0; j< this->mAllContoursRepresentations.at(i).size();j++){
            //contour to copy
            vtkPolyData* pld = this->mAllContoursRepresentations.at(i).at(j).second->GetContourRepresentationAsPolyData();

            // z. is the number of the image
            z = this->mAllContoursRepresentations.at(i).at(j).first;

            vtkPoints* pldPoints = pld->GetPoints();
            int numberPoints= pld->GetNumberOfPoints();

            for(int k=0;k<numberPoints;k++){
                pldPoints->GetPoint(k,toWorld);

                vtkInteractorObserver::ComputeWorldToDisplay(Activity::GetActivity().GetDefaultRendererVisit(),
                    toWorld[0],toWorld[1],toWorld[2],toPixel);


                qDebug()<< "Points Of contours - Image ";
                qDebug() << z;
                qDebug() << "\n";
                qDebug() << toPixel[0]; 
                qDebug() << toPixel[1];
                qDebug() << z;

                double *pointToSave =new double[3];
                pointToSave[0] =  toPixel[0];
                pointToSave[1] =  toPixel[1];
                pointToSave[2] =  z;

                pointsContours.push_back(pointToSave);  
            }
            pld = NULL;
            pldPoints= NULL;
        }

    }


    delete[] toPixel;
    delete[] toWorld;
    this->Stop();

    //create vtkAppendsPolyData in order to append contours together
    vtkSmartPointer<vtkAppendPolyData> appendFilter = vtkSmartPointer<vtkAppendPolyData>::New();
    int idPoint;
    idPoint=0;
    while(idPoint < pointsContours.size()){

        vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
        unsigned int k=0;       
        for(;idPoint < pointsContours.size()-1;idPoint++){
            if(pointsContours.at(idPoint)[2]==pointsContours.at(idPoint+1)[2]){
                points->InsertNextPoint(pointsContours.at(idPoint));
                k++;                                    
            }
            else 
                break;
        } 

        if(idPoint < pointsContours.size()){
            points->InsertNextPoint(pointsContours.at(idPoint));
            k++;            
            idPoint++;      
        }


        vtkSmartPointer<vtkPolyLine> polyline = vtkSmartPointer<vtkPolyLine>::New();
        polyline->GetPointIds()->SetNumberOfIds(k);
        for(unsigned int j=0; j<k;j++)
            polyline->GetPointIds()->SetId(j,j);

        // Create a cell array to store the lines in and add the lines to it
        vtkSmartPointer<vtkCellArray> cells = 
            vtkSmartPointer<vtkCellArray>::New();
        cells->InsertNextCell(polyline);

        vtkSmartPointer<vtkPolyData> polyData = 
            vtkSmartPointer<vtkPolyData>::New();

        // Add the points to the dataset
        polyData->SetPoints(points);

        // Add the lines to the dataset
        polyData->SetLines(cells);  

        appendFilter->AddInputData(polyData);
    }

    pointsContours.clear();
    appendFilter->Update();


    vtkSmartPointer<vtkPolyDataMapper> contoursMapper = vtkSmartPointer<vtkPolyDataMapper>::New();

    contoursMapper->SetInputData(appendFilter->GetOutput());
    contoursMapper->ScalarVisibilityOff();

    vtkSmartPointer<vtkActor> contoursActor = vtkSmartPointer<vtkActor>::New();
    contoursActor->SetMapper(contoursMapper);
    contoursActor->GetProperty()->SetRepresentationToWireframe();
    contoursActor->GetProperty()->SetColor(0,0,0);


    vtkSmartPointer<vtkVRMLExporter> exporter = vtkSmartPointer<vtkVRMLExporter>::New();
    vtkSmartPointer<vtkRenderer> renderer = vtkSmartPointer<vtkRenderer>::New();
    vtkSmartPointer<vtkRenderWindow> renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
    vtkSmartPointer<vtkRenderWindowInteractor> interactor = vtkSmartPointer<vtkRenderWindowInteractor>::New();


    renderer->AddActor(contoursActor);
    renderer->ResetCamera();
    renderWindow->AddRenderer(renderer);
    renderer->SetBackground(1,1,1); // Background color
    interactor->SetRenderWindow(renderWindow);
    interactor->Initialize();   
    renderWindow->Render();
    interactor->Start();