VTK与ITK在VS（2008,2012）下的安装

    C:/Qt/Qt5.2.1/5.2.1/msvc2012_64_opengl/lib/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake  
    set(CMAKE_LIBRARY_PATH "C:/Program Files (x86)/Windows Kits/8.0/Lib/win8/um/x64")

    cmake_minimum_required(VERSION 2.8)
     
    PROJECT(Cylinder)
     
    find_package(VTK REQUIRED)
    include(${VTK_USE_FILE})
     
    add_executable(Cylinder MACOSX_BUNDLE Cylinder)
     
    if(VTK_LIBRARIES)
      target_link_libraries(Cylinder ${VTK_LIBRARIES})
    else()
      target_link_libraries(Cylinder vtkHybrid vtkWidgets)
    endif()

 #include "vtkCylinderSource.h"

    
 #include "vtkPolyDataMapper.h"
    
 #include "vtkActor.h"
    
 #include "vtkRenderer.h"
    
 #include "vtkRenderWindow.h"
    
 #include "vtkRenderWindowInteractor.h"
    
 #include "vtkProperty.h"
    
 #include "vtkCamera.h"
    
 #include "vtkSmartPointer.h"
    
  
    
 int main()
    
 {
    
   // This creates a polygonal cylinder model with eight circumferential facets
    
   // (i.e, in practice an octagonal prism).
    
   vtkSmartPointer<vtkCylinderSource> cylinder =
    
     vtkSmartPointer<vtkCylinderSource>::New();
    
   cylinder->SetResolution(8);
    
  
    
   // The mapper is responsible for pushing the geometry into the graphics library.
    
   // It may also do color mapping, if scalars or other attributes are defined.
    
   vtkSmartPointer<vtkPolyDataMapper> cylinderMapper =
    
     vtkSmartPointer<vtkPolyDataMapper>::New();
    
   cylinderMapper->SetInputConnection(cylinder->GetOutputPort());
    
  
    
   // The actor is a grouping mechanism: besides the geometry (mapper), it
    
   // also has a property, transformation matrix, and/or texture map.
    
   // Here we set its color and rotate it around the X and Y axes.
    
   vtkSmartPointer<vtkActor> cylinderActor =
    
     vtkSmartPointer<vtkActor>::New();
    
   cylinderActor->SetMapper(cylinderMapper);
    
   cylinderActor->GetProperty()->SetColor(1.0000, 0.3882, 0.2784);
    
   cylinderActor->RotateX(30.0);
    
   cylinderActor->RotateY(-45.0);
    
  
    
   // The renderer generates the image
    
   // which is then displayed on the render window.
    
   // It can be thought of as a scene to which the actor is added
    
   vtkSmartPointer<vtkRenderer> renderer =
    
     vtkSmartPointer<vtkRenderer>::New();
    
   renderer->AddActor(cylinderActor);
    
   renderer->SetBackground(0.1, 0.2, 0.4);
    
   // Zoom in a little by accessing the camera and invoking its "Zoom" method.
    
   renderer->ResetCamera();
    
   renderer->GetActiveCamera()->Zoom(1.5);
    
  
    
   // The render window is the actual GUI window
    
   // that appears on the computer screen
    
   vtkSmartPointer<vtkRenderWindow> renderWindow =
    
     vtkSmartPointer<vtkRenderWindow>::New();
    
   renderWindow->SetSize(200, 200);
    
   renderWindow->AddRenderer(renderer);
    
  
    
   // The render window interactor captures mouse events
    
   // and will perform appropriate camera or actor manipulation
    
   // depending on the nature of the events.
    
   vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
    
     vtkSmartPointer<vtkRenderWindowInteractor>::New();
    
   renderWindowInteractor->SetRenderWindow(renderWindow);
    
  
    
   // This starts the event loop and as a side effect causes an initial render.
    
   renderWindowInteractor->Start();
    
  
    
   return 0;
    
 }

    cmake_minimum_required(VERSION 2.8)
     
    PROJECT(Cylinder)
     
    find_package(VTK REQUIRED)
    include(${VTK_USE_FILE})
     
    add_executable(Cylinder MACOSX_BUNDLE Cylinder)
     
    if(VTK_LIBRARIES)
      target_link_libraries(Cylinder ${VTK_LIBRARIES})
    else()
      target_link_libraries(Cylinder vtkHybrid vtkWidgets)
    endif()

  #include"vtkRenderWindow.h"

    
  #include"vtkSmartPointer.h"
    
  int main()
    
 {
    
    vtkSmartPointer<vtkRenderWindow> renWin =vtkSmartPointer<vtkRenderWindow>::New();
    
    renWin->Render();
    
    std::cin.get();
    
     return 0;
    
  }

    #include "itkImage.h"

    
    #include <iostream>
    
    int main()
    
    {
    
       //声明图像类型,  像素类型为 unsigned short,  图像维数为 3维
    
       typedef itk::Image< unsigned short, 3 > ImageType;
    
  
    
       //新建一幅图像, 并将其赋值给图像类的智能指针, 智能指针不需要 delete
    
       //自动释放, ITK 中每一个类基本都提供智能指针, 且使用New() 实例化. 除少数极小的对象不使用智能指针
    
       ImageType::Pointer image = ImageType::New();
    
  
    
       std::cout << "ITK Hello World !" << std::endl;
    
       return 0;
    
     }

     CMAKE_MINIMUM_REQUIRED(VERSION 2.4)               //CMake 最小版本
     PROJECT(HelloWorld)                                                 //工程名
     FIND_PACKAGE(ITK)                                                   //寻找 ITK
     IF(ITK_FOUND)
            INCLUDE(${ITK_USE_FILE})    //找到则使用, 否则需要手动指定 D:/I_VTK/ITK/ITK-3.14.0-bin
     ELSE(ITK_FOUND)
          MESSAGE(FATAL_ERROR
                          "ITK not found. Please set ITK_DIR.") //没有找到,弹出对话框提示
     ENDIF(ITK_FOUND)
     
     ADD_EXECUTABLEHelloWorld HelloWorld.cxx )         //生成可执行文件名, 及需要编译的源文件
     
     //该工程所需要的 ITK 子系统, 该句会生成工程所需的 ITk lib库文件
     TARGET_LINK_LIBRARIES(HelloWorld  ITKCommon)

 #include "vtkConeSource.h"

    
 #include "vtkPolyDataMapper.h"
    
 #include "vtkRenderWindow.h"
    
 #include "vtkActor.h"
    
 #include "vtkRenderer.h"
    
 int main()
    
 {
    
   // 创建一个圆锥，并设置其参数：高度、底面半径和分辨率。
    
   vtkConeSource *cone = vtkConeSource::New();
    
   cone->SetHeight( 3.0 );
    
   cone->SetRadius( 1.0 );
    
   cone->SetResolution( 10 );// 决定其棱角的多少
    
   // 创建一个多边形映射器，用于把多边形数据映射为可被计算机渲染的图元。
    
   vtkPolyDataMapper *coneMapper = vtkPolyDataMapper::New();
    
   coneMapper->SetInputConnection( cone->GetOutputPort() );
    
   // 创建一个演员，并关联一个映射器，从而确定了演员的形状。
    
   vtkActor *coneActor = vtkActor::New();
    
   coneActor->SetMapper( coneMapper );
    
  
    
   // 创建一个渲染器，添加要被渲染的演员，设置背景颜色。
    
   vtkRenderer *ren1= vtkRenderer::New();
    
   ren1->AddActor( coneActor );
    
   ren1->SetBackground( 0.1, 0.2, 0.4 );
    
   // 创建渲染窗口，供渲染器渲染用。
    
   vtkRenderWindow *renWin = vtkRenderWindow::New();
    
   renWin->AddRenderer( ren1 );
    
   renWin->SetSize( 300, 300 );
    
   // 渲染360次，这里主要是为了延时。
    
   int i;
    
   for (i = 0; i < 360; ++i)  renWin->Render();
    
   // 清除对象。
    
   cone->Delete();
    
   coneMapper->Delete();
    
   coneActor->Delete();
    
   ren1->Delete();
    
   renWin->Delete();
    
   return 0;
    
 }

 #include "itkImage.h"

    
 #include <iostream>
    
 int main()
    
 {
    
 //定义一个图像类型
    
   typedef itk::Image< unsigned short, 3 > ImageType;
    
   ImageType::Pointer image = ImageType::New();
    
  
    
 //输出：ITK Hello World！
    
   std::cout << "ITK Hello World !" << std::endl;
    
   return 0;
    
 }

 #include "itkImage.h"

    
 #include "itkImageFileReader.h"
    
 #include "itkImageToVTKImageFilter.h"
    
 #include "vtkImageViewer.h"
    
 #include "vtkRenderWindowInteractor.h"
    
 #include "vtkImageActor.h"
    
 #include "vtkRenderer.h"
    
 #include "vtkRenderWindow.h"
    
 #include <iostream>
    
 using namespace std;
    
 int main( int argc, char **argv) {
    
  
    
 typedef itk::Image<unsigned short,2> ImageType;
    
 typedef itk::ImageFileReader<ImageType> ReaderType;// 文件读取器
    
 typedef itk::ImageToVTKImageFilter<ImageType> ConnectorType;// VTK与ITK链接器
    
  
    
 ReaderType::Pointer reader= ReaderType::New();
    
 ConnectorType::Pointer connector= ConnectorType::New();
    
 reader->SetFileName("E:\ Program Files\ ITK\ InsightToolkit\ Wrapping\ WrapITK\ images\ ThresholdSegmentationLevelSetWhiteMatterTest.png");
    
 connector->SetInput(reader->GetOutput());
    
  
    
 vtkImageActor *actor = vtkImageActor::New();
    
 actor->SetInput(connector->GetOutput());
    
 vtkRenderer * ren = vtkRenderer::New();
    
 ren->AddActor(actor);
    
 vtkRenderWindow *renWin = vtkRenderWindow::New();
    
 renWin->AddRenderer(ren);
    
  
    
 vtkImageViewer* viewer= vtkImageViewer::New();
    
 // 绘制窗口交互器
    
 vtkRenderWindowInteractor* renderWindowInteractor=vtkRenderWindowInteractor::New();
    
 viewer->SetInput( connector->GetOutput() );
    
 viewer->SetupInteractor( renderWindowInteractor);
    
 viewer->SetColorWindow( 255);
    
 viewer->SetColorLevel( 128);
    
 viewer->Render();
    
 renderWindowInteractor->Initialize();
    
 renderWindowInteractor->Start();
    
  
    
 return 0;
    
 }

 #include <iostream>

    
 #include "itkMesh.h"
    
 #include "itkLineCell.h"
    
 #include "itkTriangleCell.h"
    
 #include "vtkPolyDataReader.h"
    
 #include "vtkPolyData.h"
    
 #include "vtkPoints.h"
    
 #include "vtkCellArray.h"
    
  
    
 int main( int argc, char * argv [] )
    
 {
    
   vtkPolyDataReader * reader = vtkPolyDataReader::New();
    
   reader->SetFileName("E:/Program Files/VTK/vtkdata/Data/fran_cut.vtk");
    
   reader->Update();// 触发立即执行读取操作
    
  
    
   vtkPolyData * polyData = reader->GetOutput();
    
  
    
   const unsigned int PointDimension   = 3;
    
   const unsigned int MaxCellDimension = 2;
    
   typedef itk::DefaultStaticMeshTraits< 
    
                   vtkFloatingPointType, 
    
                   PointDimension,
    
                   MaxCellDimension, 
    
                   vtkFloatingPointType, 
    
                   vtkFloatingPointType  >       MeshTraits;
    
  
    
   typedef itk::Mesh<
    
                   vtkFloatingPointType, 
    
                   PointDimension, 
    
                   MeshTraits              >     MeshType;
    
  
    
   MeshType::Pointer  mesh = MeshType::New();
    
  
    
   const unsigned int numberOfPoints = polyData->GetNumberOfPoints();
    
   
    
   vtkPoints * vtkpoints = polyData->GetPoints();
    
  
    
   mesh->GetPoints()->Reserve( numberOfPoints );
    
   
    
   for(unsigned int p =0; p < numberOfPoints; p++)
    
     {
    
     vtkFloatingPointType * apoint = vtkpoints->GetPoint( p );
    
 mesh->SetPoint( p, MeshType::PointType( apoint ));
    
 }
    
  
    
   vtkCellArray * triangleStrips = polyData->GetStrips();
    
   vtkIdType  * cellPoints;
    
   vtkIdType    numberOfCellPoints;
    
   unsigned int numberOfTriangles = 0;
    
   triangleStrips->InitTraversal();
    
  
    
   while( triangleStrips->GetNextCell( numberOfCellPoints, cellPoints ) )
    
     {
    
     numberOfTriangles += numberOfCellPoints-2;
    
 }
    
  
    
   vtkCellArray * polygons = polyData->GetPolys();
    
   polygons->InitTraversal();
    
  
    
   while( polygons->GetNextCell( numberOfCellPoints, cellPoints ) )
    
     {
    
     if( numberOfCellPoints == 3 )
    
       {
    
       numberOfTriangles ++;
    
       }
    
 }
    
  
    
   mesh->GetCells()->Reserve( numberOfTriangles );
    
   typedef MeshType::CellType   CellType;
    
   typedef itk::TriangleCell< CellType > TriangleCellType;
    
   int cellId = 0;
    
  
    
   triangleStrips->InitTraversal();
    
  
    
   while( triangleStrips->GetNextCell( numberOfCellPoints, cellPoints ) )
    
     {
    
     unsigned int numberOfTrianglesInStrip = numberOfCellPoints - 2;
    
     unsigned long pointIds[3];
    
     pointIds[0] = cellPoints[0];
    
     pointIds[1] = cellPoints[1];
    
 pointIds[2] = cellPoints[2];
    
  
    
     for( unsigned int t=0; t < numberOfTrianglesInStrip; t++ )
    
       {
    
       MeshType::CellAutoPointer c;
    
       TriangleCellType * tcell = new TriangleCellType;
    
       tcell->SetPointIds( pointIds );
    
       c.TakeOwnership( tcell );
    
       mesh->SetCell( cellId, c );
    
       cellId++;
    
       pointIds[0] = pointIds[1];
    
       pointIds[1] = pointIds[2];
    
       pointIds[2] = cellPoints[t+3];
    
       }
    
  
    
 }
    
  
    
   polygons->InitTraversal();
    
   while( polygons->GetNextCell( numberOfCellPoints, cellPoints ) )
    
     {
    
     if( numberOfCellPoints !=3 )      {
    
       continue;
    
       }
    
  
    
     MeshType::CellAutoPointer c;
    
     TriangleCellType * t = new TriangleCellType;
    
     t->SetPointIds( (unsigned long*)cellPoints );
    
     c.TakeOwnership( t );
    
     mesh->SetCell( cellId, c );
    
     cellId++;
    
 }
    
  
    
   std::cout << "Mesh  " << std::endl;
    
   std::cout << "Number of Points =   " << mesh->GetNumberOfPoints() << std::endl;
    
   std::cout << "Number of Cells  =   " << mesh->GetNumberOfCells()  << std::endl;
    
 getchar();
    
   reader->Delete();
    
   return 0;
    
 }

 #include "itkCommand.h"

    
 #include "itkImage.h"
    
 #include "itkVTKImageExport.h"
    
 #include "itkVTKImageImport.h"
    
 #include "itkConfidenceConnectedImageFilter.h"
    
 #include "itkCastImageFilter.h"
    
 #include "itkRGBPixel.h"
    
 #include "itkImageFileReader.h"
    
 #include "itkImageFileWriter.h"
    
 #include "vtkImageImport.h"
    
 #include "vtkImageExport.h"
    
 #include "vtkImageActor.h"
    
 #include "vtkInteractorStyleImage.h"
    
 #include "vtkRenderer.h"
    
 #include "vtkRenderWindow.h"
    
 #include "vtkRenderWindowInteractor.h"
    
 #include "vtkActor.h"
    
 #include "vtkPolyData.h"
    
 #include "vtkPolyDataMapper.h"
    
 #include "vtkContourFilter.h"
    
 #include "vtkImageData.h"
    
 #include "vtkDataSet.h"
    
 #include "vtkProperty.h"
    
  
    
 template <typename ITK_Exporter, typename VTK_Importer>
    
 void ConnectPipelines(ITK_Exporter exporter, VTK_Importer* importer)
    
 {
    
   importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
    
   importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
    
   importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
    
   importer->SetSpacingCallback(exporter->GetSpacingCallback());
    
   importer->SetOriginCallback(exporter->GetOriginCallback());
    
   importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
    
   importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
    
   importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
    
   importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
    
   importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
    
   importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
    
   importer->SetCallbackUserData(exporter->GetCallbackUserData());
    
 }
    
  
    
 template <typename VTK_Exporter, typename ITK_Importer>
    
 void ConnectPipelines(VTK_Exporter* exporter, ITK_Importer importer)
    
 {
    
   importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
    
   importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
    
   importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
    
   importer->SetSpacingCallback(exporter->GetSpacingCallback());
    
   importer->SetOriginCallback(exporter->GetOriginCallback());
    
   importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
    
   importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
    
   importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
    
   importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
    
   importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
    
   importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
    
   importer->SetCallbackUserData(exporter->GetCallbackUserData());
    
 }
    
  
    
 int main()
    
 {  
    
     typedef unsigned char PixelType;
    
     const unsigned int Dimension = 2;
    
     typedef itk::Image< PixelType, Dimension > ImageType;
    
     
    
     typedef itk::ImageFileReader< ImageType > ReaderType;
    
  
    
     ReaderType::Pointer reader  = ReaderType::New();
    
     reader->SetFileName( "E:/Program Files/VTK/vtkdata/Data/fullhead15.png" );
    
     reader->Update();
    
  
    
     typedef itk::ConfidenceConnectedImageFilter<ImageType,ImageType> SegmentationFilterType;
    
  
    
     SegmentationFilterType::Pointer filter = SegmentationFilterType::New();
    
  
    
     filter->SetInput( reader->GetOutput() );
    
     filter->SetNumberOfIterations(2);
    
     filter->SetReplaceValue(255);
    
     filter->SetMultiplier(2.5);
    
  
    
     ImageType::IndexType index;
    
     index[0] = 100;
    
     index[1] = 100;
    
 filter->SetSeed( index );
    
  
    
     typedef itk::VTKImageExport< ImageType > ExportFilterType;
    
     ExportFilterType::Pointer itkExporter1 = ExportFilterType::New();
    
     ExportFilterType::Pointer itkExporter2 = ExportFilterType::New();
    
  
    
     itkExporter1->SetInput( reader->GetOutput() );
    
     itkExporter2->SetInput( filter->GetOutput() );
    
  
    
     vtkImageImport* vtkImporter1 = vtkImageImport::New();  
    
     ConnectPipelines(itkExporter1, vtkImporter1);
    
     
    
     vtkImageImport* vtkImporter2 = vtkImageImport::New();  
    
     ConnectPipelines(itkExporter2, vtkImporter2);
    
     
    
     vtkImageActor* actor = vtkImageActor::New();
    
     actor->SetInput(vtkImporter1->GetOutput());
    
     
    
     vtkInteractorStyleImage * interactorStyle = vtkInteractorStyleImage::New();
    
  
    
     vtkRenderer* renderer = vtkRenderer::New();
    
     vtkRenderWindow* renWin = vtkRenderWindow::New();
    
     vtkRenderWindowInteractor* iren = vtkRenderWindowInteractor::New();
    
     
    
     renWin->SetSize(500, 500);
    
     renWin->AddRenderer(renderer);
    
     iren->SetRenderWindow(renWin);
    
     iren->SetInteractorStyle( interactorStyle );
    
     
    
     renderer->AddActor(actor);
    
     renderer->SetBackground(0.4392, 0.5020, 0.5647);
    
  
    
     vtkContourFilter * contour = vtkContourFilter::New();
    
     contour->SetInput( vtkImporter2->GetOutput() );
    
 contour->SetValue(0, 128);
    
  
    
     vtkPolyDataMapper * polyMapper = vtkPolyDataMapper::New();
    
     vtkActor          * polyActor  = vtkActor::New();
    
  
    
     polyActor->SetMapper( polyMapper );
    
     polyMapper->SetInput( contour->GetOutput() );
    
     polyMapper->ScalarVisibilityOff();
    
     
    
     vtkProperty * property = vtkProperty::New();
    
     property->SetRepresentationToSurface();
    
     property->SetAmbient(0.1);
    
     property->SetDiffuse(0.1);
    
     property->SetSpecular(0.5);
    
     property->SetColor(1.0,0.0,0.0);
    
     property->SetLineWidth(2.0);
    
  
    
     polyActor->SetProperty( property );
    
     renderer->AddActor( polyActor );
    
     renWin->Render();
    
     iren->Start();
    
  
    
     actor->Delete();
    
     interactorStyle->Delete(); 
    
     polyActor->Delete();
    
     vtkImporter1->Delete();
    
     vtkImporter2->Delete();
    
     contour->Delete();
    
     property->Delete();
    
     polyMapper->Delete();
    
     renWin->Delete();
    
     renderer->Delete();
    
 iren->Delete();
    
  
    
   return 0;
    
 }

    <pre name="code" class="plain" data-index="14"><pre data-index="15"></pre>
    <pre data-index="16"></pre>
    <pre data-index="17"></pre>
    <pre data-index="18"></pre>
    <pre data-index="19"></pre>
    <pre data-index="20"></pre>
    <pre data-index="21"></pre>
    <pre data-index="22"></pre>
    <pre data-index="23"></pre>
    <pre data-index="24"></pre>
    <pre data-index="25"></pre>
    <pre data-index="26"></pre>
    <pre data-index="27"></pre>
    <pre data-index="28"></pre>
    <pre data-index="29"></pre>
    <pre data-index="30"></pre>
    <pre data-index="31"></pre>
    <pre data-index="32"></pre>
    <pre data-index="33"></pre>
    <pre data-index="34"></pre>
    <pre data-index="35"></pre>
    <pre data-index="36"></pre>
    <pre data-index="37"></pre>
    <pre data-index="38"></pre>
    <pre data-index="39"></pre>
    <pre data-index="40"></pre>
    <pre data-index="41"></pre>
    <pre data-index="42"></pre>
    <pre data-index="43"></pre>
    <pre data-index="44"></pre>
    </pre>