DiffuseSpheres

VTKExamples/Cxx/Rendering/DiffuseSpheres


Description

Note

This original source code for this example is here.

Info

Similar examples setting the ambient and specular properties are: See AmbientSpheres.cxx, AmbientSpheres.py, AmbientSpheres.java and SpecularSpheres.cxx, SpecularSpheres.py.

Other Languages

See (Python)

Question

If you have a simple question about this example contact us at VTKExamplesProject If your question is more complex and may require extended discussion, please use the VTK Discourse Forum

Code

DiffuseSpheres.cxx

#include <vtkActor.h>
#include <vtkCamera.h>
#include <vtkLight.h>
#include <vtkNamedColors.h>
#include <vtkNew.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkSphereSource.h>

#include <array>

int main(int, char*[])
{
  vtkNew<vtkNamedColors> colors;

  // Set the background color.
  std::array<unsigned char, 4> bkg{{26, 51, 102, 255}};
  colors->SetColor("bkg", bkg.data());

  // The following lines create a sphere represented by polygons.
  //
  vtkNew<vtkSphereSource> sphere;
  sphere->SetThetaResolution(100);
  sphere->SetPhiResolution(50);

  // 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.
  //
  vtkNew<vtkPolyDataMapper> sphereMapper;
  sphereMapper->SetInputConnection(sphere->GetOutputPort());

  // The actor is a grouping mechanism: besides the geometry (mapper), it
  // also has a property, transformation matrix, and/or texture map.
  // In this example we create eight different spheres (two rows of four
  // spheres) and set the diffuse lighting coefficients. A little ambient
  // is turned on so the sphere is not completely black on the back side.
  //
  // Since we are using the same sphere source and mapper for all eight spheres
  // we will use a std::array holding the actors.
  //
  // If you want/need to use std::vector, then you must use
  // std::vector<vtkSmartPointer<vtkActor>> spheres;
  // and then, in a loop, create the object using
  // spheres.push_back(vtkSmartPointer<vtkActor>::New());
  //
  // The reason:
  // vtkNew, in contrast to vtkSmartPointer, has no assignment operator
  // or copy constructor and owns one object for its whole lifetime.
  // Thus vtkNew does not satisfy the CopyAssignable and CopyConstructible
  // requirements needed for other std containers like std::vector or std::list.
  // std::array, on the other hand, is a container encapsulating fixed size
  // arrays so its elements do not need to be CopyAssignable and
  // CopyConstructible.
  //
  // So:
  //    std::array - vtkNew or vtkSmartPointer can be used.
  //    std::vector, std::list - only vtkSmartPointer can be used.
  //
  auto const numberOfSpheres = 8;
  std::array<vtkNew<vtkActor>, numberOfSpheres> spheres;
  auto ambient = 0.3;
  auto diffuse = 0.0;
  auto specular = 0.0;
  std::array<double, 3> position{{0, 0, 0}};
  for (auto i = 0; i < spheres.size(); ++i)
  {
    spheres[i]->SetMapper(sphereMapper);
    spheres[i]->GetProperty()->SetColor(colors->GetColor3d("Red").GetData());
    spheres[i]->GetProperty()->SetAmbient(ambient);
    spheres[i]->GetProperty()->SetDiffuse(diffuse);
    spheres[i]->GetProperty()->SetSpecular(specular);
    spheres[i]->AddPosition(position.data());
    std::cout << diffuse << std::endl;
    diffuse += 0.125;
    position[0] += 1.25;
    if (i == 3)
    {
      position[0] = 0;
      position[1] = 1.25;
    }
  }

  // Create the graphics structure. The renderer renders into the
  // render window. The render window interactor captures mouse events
  // and will perform appropriate camera or actor manipulation
  // depending on the nature of the events.
  //
  vtkNew<vtkRenderer> ren;
  vtkNew<vtkRenderWindow> renWin;
  renWin->AddRenderer(ren);
  vtkNew<vtkRenderWindowInteractor> iren;
  iren->SetRenderWindow(renWin);

  // Add the actors to the renderer, set the background and size.
  //
  for (auto i = 0; i < numberOfSpheres; ++i)
  {
    ren->AddActor(spheres[i]);
  }

  ren->SetBackground(colors->GetColor3d("bkg").GetData());
  renWin->SetSize(640, 480);
  renWin->SetWindowName("Diffuse Spheres");

  // Set up the lighting.
  //
  vtkNew<vtkLight> light;
  light->SetFocalPoint(1.875, 0.6125, 0);
  light->SetPosition(0.875, 1.6125, 1);
  ren->AddLight(light);

  // We want to eliminate perspective effects on the apparent lighting.
  // Parallel camera projection will be used. To zoom in parallel projection
  // mode, the ParallelScale is set.
  //
  ren->GetActiveCamera()->SetFocalPoint(0, 0, 0);
  ren->GetActiveCamera()->SetPosition(0, 0, 1);
  ren->GetActiveCamera()->SetViewUp(0, 1, 0);
  ren->GetActiveCamera()->ParallelProjectionOn();
  ren->ResetCamera();
  ren->GetActiveCamera()->SetParallelScale(2.0);
  // This starts the event loop and invokes an initial render.
  //
  iren->Initialize();
  renWin->Render();
  iren->Start();

  return EXIT_SUCCESS;
}

CMakeLists.txt

cmake_minimum_required(VERSION 3.3 FATAL_ERROR)

project(DiffuseSpheres)

find_package(VTK COMPONENTS 
  vtkCommonColor
  vtkCommonCore
  vtkFiltersSources
  vtkInteractionStyle
  vtkRenderingContextOpenGL2
  vtkRenderingCore
  vtkRenderingFreeType
  vtkRenderingGL2PSOpenGL2
  vtkRenderingOpenGL2 QUIET)
if (NOT VTK_FOUND)
  message("Skipping DiffuseSpheres: ${VTK_NOT_FOUND_MESSAGE}")
  return ()
endif()
message (STATUS "VTK_VERSION: ${VTK_VERSION}")
if (VTK_VERSION VERSION_LESS "8.90.0")
  # old system
  include(${VTK_USE_FILE})
  add_executable(DiffuseSpheres MACOSX_BUNDLE DiffuseSpheres.cxx )
  target_link_libraries(DiffuseSpheres PRIVATE ${VTK_LIBRARIES})
else ()
  # include all components
  add_executable(DiffuseSpheres MACOSX_BUNDLE DiffuseSpheres.cxx )
  target_link_libraries(DiffuseSpheres PRIVATE ${VTK_LIBRARIES})
  # vtk_module_autoinit is needed
  vtk_module_autoinit(
    TARGETS DiffuseSpheres
    MODULES ${VTK_LIBRARIES}
    )
endif () 

Download and Build DiffuseSpheres

Click here to download DiffuseSpheres and its CMakeLists.txt file. Once the tarball DiffuseSpheres.tar has been downloaded and extracted,

cd DiffuseSpheres/build 

If VTK is installed:

cmake ..

If VTK is not installed but compiled on your system, you will need to specify the path to your VTK build:

cmake -DVTK_DIR:PATH=/home/me/vtk_build ..

Build the project:

make

and run it:

./DiffuseSpheres

WINDOWS USERS

Be sure to add the VTK bin directory to your path. This will resolve the VTK dll's at run time.