vtk多线程简单测试

 vtkMultithreader is a class that provides support for multithreaded execution using sproc() on an SGI, or pthread_create on any platform supporting POSIX threads. This class can be used to execute a single method on multiple threads, or to specify a method per thread.

Examples:

vtkMultiThreader (Examples)

Tests:

vtkMultiThreader (Tests)

 

#ifndef INITIAL_OPENGL
#define INITIAL_OPENGL
#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL)
VTK_MODULE_INIT(vtkInteractionStyle)
#endif
#include <iostream>
using namespace std;
#include "vtkSmartPointer.h"

#include "vtkDEMReader.h"
#include "vtkPolyData.h"
#include "vtkPolyDataMapper.h"
#include "vtkActor.h"
#include "vtkRenderer.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkProperty.h"
#include "vtkCamera.h"
#include "vtkImageDataGeometryFilter.h"
#include "vtkWarpScalar.h"
#include "vtkPolyDataNormals.h"
#include "vtkLODActor.h"
#include "vtkImageData.h"
#include "vtkLookupTable.h"
#include "vtkPoints.h"
#include "vtkCellArray.h"
#include "vtkPolyDataCollection.h"
#include "vtkTriangleFilter.h"
#include "vtkImageResample.h"
#include "vtkHandleWidget.h"
#include "vtkSphereHandleRepresentation.h"
#include "vtkTestUtilities.h"
#include "vtkTesting.h"
#include "vtkAbstractWidget.h"
#include "vtkDataSetWriter.h"
#include "vtkMultiThreader.h"
#include "vtkWarpScalar.h"

int main(int argc, char*argv[])
{

     //读入海拔高度图.SainteHelens.dem
     char* fname = "D:/Qt/VTK6.3.0/vtkExampleModelFiles/SainteHelens.dem";
     vtkMultiThreader::SetGlobalMaximumNumberOfThreads(2);

     // Read height field.
     //
     vtkSmartPointer<vtkDEMReader> demReader = vtkSmartPointer<vtkDEMReader>::New();
     demReader->SetFileName(fname);
     delete [] fname;

     vtkSmartPointer<vtkImageResample>  resample = vtkSmartPointer<vtkImageResample>::New();
     resample->SetInputConnection(demReader->GetOutputPort());
     resample->SetDimensionality(2);
     resample->SetAxisMagnificationFactor(0,1);
     resample->SetAxisMagnificationFactor(1,1);

     // Extract geometry
     vtkSmartPointer<vtkImageDataGeometryFilter> surface =  vtkSmartPointer<vtkImageDataGeometryFilter>::New();
     surface->SetInputConnection(resample->GetOutputPort());

     // The Dijkistra interpolator will not accept cells that aren't triangles
     vtkSmartPointer<vtkTriangleFilter> triangleFilter = vtkSmartPointer<vtkTriangleFilter>::New();
     triangleFilter->SetInputConnection( surface->GetOutputPort() );
     triangleFilter->Update();

     vtkSmartPointer<vtkWarpScalar> warp = vtkSmartPointer<vtkWarpScalar>::New();
     warp->SetInputConnection(triangleFilter->GetOutputPort());
     warp->SetScaleFactor(1);
     warp->UseNormalOn();
     warp->SetNormal(0, 0, 1);
     warp->Update();

     // cout << warp->GetOutput()->GetNumberOfCells() << endl;

     // vtkSmartPointer<vtkDataSetWriter> writer = vtkSmartPointer<vtkDataSetWriter>::New();
     // writer->SetInputConnection(resample->GetOutputPort());
     // writer->SetFileName("foo.vtk");
     // writer->Write();

     // Define a LUT mapping for the height field

     double lo = demReader->GetOutput()->GetScalarRange()[0];
     double hi = demReader->GetOutput()->GetScalarRange()[1];

     vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
     lut->SetHueRange(0.6, 0);
     lut->SetSaturationRange(1.0, 0);
     lut->SetValueRange(0.5, 1.0);

     vtkSmartPointer<vtkPolyDataNormals> normals = vtkSmartPointer<vtkPolyDataNormals>::New();

     vtkSmartPointer<vtkPolyDataMapper> demMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
     demMapper->SetInputConnection(warp->GetOutputPort());
     demMapper->SetScalarRange(lo, hi);
     demMapper->SetLookupTable(lut);

     vtkSmartPointer<vtkActor> demActor = vtkSmartPointer<vtkActor>::New();
     demActor->SetMapper(demMapper);

     // Create the RenderWindow, Renderer and the DEM + path actors.
     vtkSmartPointer<vtkRenderer> ren1 =  vtkSmartPointer<vtkRenderer>::New();
     vtkSmartPointer<vtkRenderWindow> renWin =  vtkSmartPointer<vtkRenderWindow>::New();
     renWin->AddRenderer(ren1);
     vtkSmartPointer<vtkRenderWindowInteractor> iren =
       vtkSmartPointer<vtkRenderWindowInteractor>::New();
     iren->SetRenderWindow(renWin);

     // Add the actors to the renderer, set the background and size
     ren1->AddActor(demActor);
     ren1->GetActiveCamera()->SetViewUp(0, 0, 1);
     ren1->GetActiveCamera()->SetPosition(-99900, -21354, 131801);
     ren1->GetActiveCamera()->SetFocalPoint(41461, 41461, 2815);
     ren1->ResetCamera();
     ren1->ResetCameraClippingRange();

     // Here comes the surface constrained handle widget stuff.....
     vtkSmartPointer<vtkHandleWidget> widget = vtkSmartPointer<vtkHandleWidget>::New();
     widget->SetInteractor(iren);
     vtkSmartPointer<vtkSphereHandleRepresentation> rep = vtkSmartPointer<vtkSphereHandleRepresentation>::New();
     widget->SetRepresentation( rep );

     // Let the surface constrained point-placer be the sole constraint dictating
     // the placement of handles. Lets not over-constrain it allowing axis
     // constrained interactions.
     widget->EnableAxisConstraintOff();

     // Set some defaults on the handle widget
     double d[3] = {562532, 5.11396e+06, 2618.62};
     rep->SetWorldPosition( d );
     rep->GetProperty()->SetColor( 1.0, 0.0, 0.0 );
     rep->GetProperty()->SetLineWidth(1.0);
     rep->GetSelectedProperty()->SetColor( 0.2, 0.0, 1.0 );
     renWin->Render();
     iren->Initialize();
     widget->EnabledOn();
     renWin->Render();
     ren1->ResetCamera();
     ren1->ResetCameraClippingRange();
     return vtkTesting::InteractorEventLoop(argc, argv, iren);
    return 0;
}