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();

      // 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();
      resample->SetAxisMagnificationFactor(,);
      resample->SetAxisMagnificationFactor(,);

      // 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();
      warp->UseNormalOn();
      warp->SetNormal(, , );
      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()[];
      double hi = demReader->GetOutput()->GetScalarRange()[];

      vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
      lut->SetHueRange(0.6, );
      lut->SetSaturationRange(1.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(, , );
      ren1->GetActiveCamera()->SetPosition(-, -, );
      ren1->GetActiveCamera()->SetFocalPoint(, , );
      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[] = {, 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 ;
 }