C++ 如何告知VTK管道使用通过TimerEvent更新的新vtkPolyData？ 意图

我编写了一个VTK应用程序，它使用vtkPoints>vtkPolyLine>vtkPolyData>vtkPolyDataMapper生成一个螺旋并显示它。如果在程序初始化时静态完成，则此操作可以正常工作。 现在，我想动态添加新的数据点。其目的是实时可视化测量结果，因此将在一定的时间间隔内添加新数据

问题 目前，我刚刚实现了一个TimerEvent来更新vtkPoints和vtkPolyLine。但是，该程序只显示在vtkRenderWindowInteractor启动之前生成的静态数据。我还尝试对几乎所有对象使用“Modified（）”和“Update（）”调用，尝试删除、重新生成并向渲染器添加一个新的参与者，但没有成功！我在下面添加了我的C++代码…… 相关问题 以下邮件列表问题与此问题有关，但给出的解决方案不适用于我：

以下问题似乎相关，但没有有用的答案：

问题

如何告知VTK vtkPolyData对象已更改

我应该仔细查看哪一个VTK用户指南

详细信息/源代码 我正在使用Visual Studio Community 2017和VTK 8.0.0，它们都编译为Win32 target

#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkRenderingContextOpenGL2);
VTK_MODULE_INIT(vtkRenderingVolumeOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);
VTK_MODULE_INIT(vtkRenderingFreeType);

#include <vtkSmartPointer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkConeSource.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkProperty.h>

#include <vtkPoints.h>
#include <vtkPolyLine.h>


vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkPolyLine> polyLine = vtkSmartPointer<vtkPolyLine>::New();

int numOfPoints = 0;
double t = 0;

void NextPoint() {
    double x = t * cos(t);
    double y = t * sin(t);
    points->InsertNextPoint(x, y, t);
    polyLine->GetPointIds()->InsertNextId(numOfPoints);

    numOfPoints++;
    t += 0.1;
}

vtkSmartPointer<vtkPolyData> generateEllipse() {
    // Add some points so we actually see something at all...
    for (int i = 0; i < 100; ++i) {
        NextPoint();
    }

    vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
    cells->InsertNextCell(polyLine);

    vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
    polyData->SetPoints(points);
    polyData->SetLines(cells);
    
    return polyData;
}


class vtkTimerCallback : public vtkCommand
{
public:
    static vtkTimerCallback *New()
    {
        vtkTimerCallback *cb = new vtkTimerCallback;
        cb->TimerCount = 0;
        return cb;
    }

    virtual void Execute(vtkObject *vtkNotUsed(caller), unsigned long eventId,
        void *vtkNotUsed(callData))
    {
        if (vtkCommand::TimerEvent == eventId)
        {
            NextPoint(); // Add another point to polyData

            ++this->TimerCount;
            cout << this->TimerCount << endl;
        }
        
    }

private:
    int TimerCount;

};



int main(int argc, char** argv) {
    vtkSmartPointer<vtkRenderWindow> renderWindow =
        vtkSmartPointer<vtkRenderWindow>::New();

    vtkSmartPointer<vtkRenderWindowInteractor> rwi = vtkSmartPointer<vtkRenderWindowInteractor>::New();
    rwi->SetRenderWindow(renderWindow);

    vtkSmartPointer<vtkPolyData> data = generateEllipse();

    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
    mapper->SetInputData(data);

    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
    actor->SetMapper(mapper);
    actor->GetProperty()->SetDiffuseColor(255, 255, 0);

    vtkSmartPointer<vtkRenderer> renderer = vtkSmartPointer<vtkRenderer>::New();
    renderWindow->AddRenderer(renderer);
    renderer->AddActor(actor);
    renderer->ResetCamera();

    renderWindow->Render();
    
    // Add Timer Event...
    rwi->Initialize();
    vtkSmartPointer<vtkTimerCallback> cb = vtkSmartPointer<vtkTimerCallback>::New();
    rwi->AddObserver(vtkCommand::TimerEvent, cb);
    int timerId = rwi->CreateRepeatingTimer(100); // every 100ms
    std::cout << "timerId: " << timerId << std::endl;

    // Start Displaying...
    rwi->Start();

    return 0;
}

#包括
VTK_模块_INIT（VTKrenderingOL2）；
VTK_模块_INIT（vtkRenderingContextOpenGL2）；
VTK_模块初始化（vtkRenderingVolumeOpenGL2）；
VTK_MODULE_INIT（vtkInteractionStyle）；
VTK_MODULE_INIT（vtkRenderingFreeType）；
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
vtkSmartPointer points=vtkSmartPointer:：New（）；
vtkSmartPointer多段线=vtkSmartPointer:：New（）；
int numOfPoints=0；
双t=0；
void NextPoint（）{
双x=t*cos（t）；
双y=t*sin（t）；
点->插入下一个点（x、y、t）；
多段线->GetPointId（）->InsertNextId（numOfPoints）；
numOfPoints++；
t+=0.1；
}
vtkSmartPointer generateEllipse（）{
//添加一些点，让我们真正看到一些东西。。。
对于（int i=0；i<100；++i）{
NextPoint（）；
}
vtkSmartPointer cells=vtkSmartPointer:：New（）；
单元->插入下一个单元（多段线）；
vtkSmartPointer polyData=vtkSmartPointer:：New（）；
polyData->设定点（点）；
polyData->设置线（单元格）；
返回数据；
}
类vtkTimerCallback：公共vtkCommand
{
公众：
静态vtkTimerCallback*New（）
{
vtkTimerCallback*cb=新vtkTimerCallback；
cb->TimerCount=0；
返回cb；
}
虚空执行（vtkObject*vtnotused（调用者），无符号长事件ID，
void*vtnotused（调用数据））
{
如果（vtkCommand:：TimerEvent==eventId）
{
NextPoint（）；//向polyData添加另一个点
++这->时间计数；
cout TimerCount SetRenderWindow（渲染窗口）；
vtkSmartPointer data=generateEllipse（）；
vtkSmartPointer映射器=vtkSmartPointer:：New（）；
映射器->设置输入数据（数据）；
vtkSmartPointer=vtkSmartPointer:：New（）；
actor->SetMapper（映射器）；
actor->GetProperty（）->SetDiffuseColor（255,255,0）；
vtkSmartPointer=vtkSmartPointer:：New（）；
renderWindow->AddRenderer（渲染器）；
渲染器->AddActor（actor）；
渲染器->重置摄影机（）；
renderWindow->Render（）；
//添加计时器事件。。。
rwi->Initialize（）；
vtkSmartPointer cb=vtkSmartPointer:：New（）；
rwi->AddObserver（vtkCommand:：TimerEvent，cb）；
int timerId=rwi->CreateRepeatingTimer（100）；//每100ms
std:：cout问题在于单元格不是通过指针存储的-当您调用
单元格->InsertNextCell（多段线）；
数据是复制的，而不是指向的，以便在数组中创建单元格的有效存储（整个实现实际上在vtkCellArray的头中，因此您可以将其签出）。因此，当您更新多段线时，它在polydata中没有任何效果，因为polydata有自己的副本，您没有更新。以下代码适用于我（您必须公开polydata和光线）：

virtual void Execute（vtkObject*vtnotused（调用者），未签名的长事件ID，
void*vtnotused（调用数据））
{
如果（vtkCommand:：TimerEvent==eventId）
{
NextPoint（）；//向polyData添加另一个点
单元格->初始化（）；//重置单元格以删除旧的螺旋
单元->插入下一个单元（多段线）；//重新插入更新的螺旋线
单元格->已修改（）；//需要更新
数据->已修改（）；//需要更新
++这->时间计数；
cout GetNumberOfPoints（）Render（）；//每次更新后刷新渲染窗口
}
}
昨天我用VTKDealabdDATAObjistObjor作为数据源，设计了一个替代的解决方案。Tomj的解决方案是更直接和简单的解决方案……但是，VTK.ORG没有C++示例代码，它解释了如何使用VTKDeababeDATAObjistObjor，我必须通过试错来解决它。所以，我将在这里发布它。可能会帮助其他人：
#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkRenderingContextOpenGL2);
VTK_MODULE_INIT(vtkRenderingVolumeOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);
VTK_MODULE_INIT(vtkRenderingFreeType);

#include <vtkSmartPointer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkConeSource.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkProperty.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
#include <vtkProgrammableFilter.h>
#include <vtkCallbackCommand.h>
#include <vtkPolyDataStreamer.h>

#include <vtkProgrammableDataObjectSource.h>


vtkSmartPointer<vtkProgrammableDataObjectSource> pDOS = vtkSmartPointer<vtkProgrammableDataObjectSource>::New();
vtkSmartPointer<vtkRenderer> renderer = vtkSmartPointer<vtkRenderer>::New();

vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkPolyLine> polyLine = vtkSmartPointer<vtkPolyLine>::New();

int numOfPoints = 0;
double t = 0;

void NextPoint() {
    double x = t * cos(t);
    double y = t * sin(t);
    points->InsertNextPoint(x, y, t);
    polyLine->GetPointIds()->InsertNextId(numOfPoints);

    numOfPoints++;
    t += 0.1;
}

void generateEllipse(void *caller) {
    vtkProgrammableDataObjectSource *pDOS = vtkProgrammableDataObjectSource::SafeDownCast((vtkObjectBase*)caller);

    vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
    cells->InsertNextCell(polyLine);

    vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
    polyData->SetPoints(points);
    polyData->SetLines(cells);

    pDOS->SetOutput(polyData);
}


int counter2 = 0;
void TimerCallbackFunction(vtkObject* caller, long unsigned int vtkNotUsed(eventId), void* clientData, void* vtkNotUsed(callData)) {
    cout << "timer callback: " << counter2 << endl;

// To avoid globals we can implement this later... 
//  vtkSmartPointer<vtkProgrammableDataObjectSource> pDOS =
//      static_cast<vtkProgrammableDataObjectSource*>(clientData);

    vtkRenderWindowInteractor *rwi =
        static_cast<vtkRenderWindowInteractor*>(caller);

    NextPoint();

    pDOS->Modified();
    rwi->Render();
    renderer->ResetCamera(); // Optional: Reposition Camera, so it displays the whole object

    counter2++;
}



int main(int argc, char** argv) {
    vtkSmartPointer<vtkRenderWindow> renderWindow =
        vtkSmartPointer<vtkRenderWindow>::New();

    vtkSmartPointer<vtkRenderWindowInteractor> rwi = vtkSmartPointer<vtkRenderWindowInteractor>::New();
    rwi->SetRenderWindow(renderWindow);


    pDOS->SetExecuteMethod(&generateEllipse, pDOS);

    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
    mapper->SetInputConnection(pDOS->GetOutputPort());

    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
    actor->SetMapper(mapper);
    actor->GetProperty()->SetDiffuseColor(255, 255, 0);

    renderWindow->AddRenderer(renderer);
    renderer->AddActor(actor);
    renderer->ResetCamera();

    renderWindow->Render();

    // Add Timer Event...
    vtkSmartPointer<vtkCallbackCommand> timerCallback = vtkSmartPointer<vtkCallbackCommand>::New();
    timerCallback->SetCallback(TimerCallbackFunction);

    rwi->Initialize();
    rwi->CreateRepeatingTimer(100);
    rwi->AddObserver(vtkCommand::TimerEvent, timerCallback);


    // Start Displaying...
    rwi->Start();

    return 0;
}

#包括
VTK_模块_INIT（VTKrenderingOL2）；
VTK_模块_INIT（vtkRenderingContextOpenGL2）；
VTK_模块初始化（vtkRenderingVolumeOpenGL2）；
VTK_MODULE_INIT（vtkInteractionStyle）；
VTK_MODULE_INIT（vtkRenderingFreeType）；
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
vtkSmartPointer pDOS=vtkSmartPointer:：New（）；
vtkSmartPointer=vtkSmartPointer:：New（）；
vtkSmartPointer points=vtkSmartPointer:：New（）；
vtkSmartPointer多段线=vtkSmartPointer:：New（）；
int numOfPoints=0；
双t=0；
void NextPoint（）{
双x=t*cos（t）；
双y=t*sin（t）；
点->插入下一个点（x、y、t）；
多段线->GetPointId（）->InsertNextId（numOfPoints）；
numOfPoints++；
t+=0.1；
}
void generateEllipse（void*调用者）{
vtkProgrammableDataObjectSource*pDOS=vtkProgrammableDataObjectSource:：SafeDown
#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkRenderingContextOpenGL2);
VTK_MODULE_INIT(vtkRenderingVolumeOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);
VTK_MODULE_INIT(vtkRenderingFreeType);

#include <vtkSmartPointer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkConeSource.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkProperty.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>
#include <vtkProgrammableFilter.h>
#include <vtkCallbackCommand.h>
#include <vtkPolyDataStreamer.h>

#include <vtkProgrammableDataObjectSource.h>


vtkSmartPointer<vtkProgrammableDataObjectSource> pDOS = vtkSmartPointer<vtkProgrammableDataObjectSource>::New();
vtkSmartPointer<vtkRenderer> renderer = vtkSmartPointer<vtkRenderer>::New();

vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkPolyLine> polyLine = vtkSmartPointer<vtkPolyLine>::New();

int numOfPoints = 0;
double t = 0;

void NextPoint() {
    double x = t * cos(t);
    double y = t * sin(t);
    points->InsertNextPoint(x, y, t);
    polyLine->GetPointIds()->InsertNextId(numOfPoints);

    numOfPoints++;
    t += 0.1;
}

void generateEllipse(void *caller) {
    vtkProgrammableDataObjectSource *pDOS = vtkProgrammableDataObjectSource::SafeDownCast((vtkObjectBase*)caller);

    vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
    cells->InsertNextCell(polyLine);

    vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
    polyData->SetPoints(points);
    polyData->SetLines(cells);

    pDOS->SetOutput(polyData);
}


int counter2 = 0;
void TimerCallbackFunction(vtkObject* caller, long unsigned int vtkNotUsed(eventId), void* clientData, void* vtkNotUsed(callData)) {
    cout << "timer callback: " << counter2 << endl;

// To avoid globals we can implement this later... 
//  vtkSmartPointer<vtkProgrammableDataObjectSource> pDOS =
//      static_cast<vtkProgrammableDataObjectSource*>(clientData);

    vtkRenderWindowInteractor *rwi =
        static_cast<vtkRenderWindowInteractor*>(caller);

    NextPoint();

    pDOS->Modified();
    rwi->Render();
    renderer->ResetCamera(); // Optional: Reposition Camera, so it displays the whole object

    counter2++;
}



int main(int argc, char** argv) {
    vtkSmartPointer<vtkRenderWindow> renderWindow =
        vtkSmartPointer<vtkRenderWindow>::New();

    vtkSmartPointer<vtkRenderWindowInteractor> rwi = vtkSmartPointer<vtkRenderWindowInteractor>::New();
    rwi->SetRenderWindow(renderWindow);


    pDOS->SetExecuteMethod(&generateEllipse, pDOS);

    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
    mapper->SetInputConnection(pDOS->GetOutputPort());

    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
    actor->SetMapper(mapper);
    actor->GetProperty()->SetDiffuseColor(255, 255, 0);

    renderWindow->AddRenderer(renderer);
    renderer->AddActor(actor);
    renderer->ResetCamera();

    renderWindow->Render();

    // Add Timer Event...
    vtkSmartPointer<vtkCallbackCommand> timerCallback = vtkSmartPointer<vtkCallbackCommand>::New();
    timerCallback->SetCallback(TimerCallbackFunction);

    rwi->Initialize();
    rwi->CreateRepeatingTimer(100);
    rwi->AddObserver(vtkCommand::TimerEvent, timerCallback);


    // Start Displaying...
    rwi->Start();

    return 0;
}