AmbientSpheres.tar

AmbientSpheres/0000755000076500000240000000000013424703035014740 5ustar  lorensenstaff00000000000000AmbientSpheres/AmbientSpheres.cxx0000644000076500000240000001067413424703035020405 0ustar  lorensenstaff00000000000000#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 ambient 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.125;
  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());
    ambient += 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);
  std::cout << "DPI: " << renWin->GetDPI() << std::endl;
  renWin->SetWindowName("Ambient 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;
}
AmbientSpheres/CMakeLists.txt0000644000076500000240000000170413424703035017502 0ustar  lorensenstaff00000000000000
cmake_minimum_required(VERSION 3.3 FATAL_ERROR)

project(AmbientSpheres)

find_package(VTK COMPONENTS 
  vtkCommonColor
  vtkCommonCore
  vtkFiltersSources
  vtkInteractionStyle
  vtkRenderingContextOpenGL2
  vtkRenderingCore
  vtkRenderingFreeType
  vtkRenderingGL2PSOpenGL2
  vtkRenderingOpenGL2 QUIET)
if (NOT VTK_FOUND)
  message("Skipping AmbientSpheres: ${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(AmbientSpheres MACOSX_BUNDLE AmbientSpheres.cxx )
  target_link_libraries(AmbientSpheres PRIVATE ${VTK_LIBRARIES})
else ()
  # include all components
  add_executable(AmbientSpheres MACOSX_BUNDLE AmbientSpheres.cxx )
  target_link_libraries(AmbientSpheres PRIVATE ${VTK_LIBRARIES})
  # vtk_module_autoinit is needed
  vtk_module_autoinit(
    TARGETS AmbientSpheres
    MODULES ${VTK_LIBRARIES}
    )
endif () 
AmbientSpheres/AmbientSpheres.py0000755000076500000240000000607013424703035020231 0ustar  lorensenstaff00000000000000# !/usr/bin/env python

import vtk


def main():
    colors = vtk.vtkNamedColors()

    # Set the background color.
    colors.SetColor("bkg", [26, 51, 102, 255])

    # The following lines create a sphere represented by polygons.
    #
    sphere = vtk.vtkSphereSource()
    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.
    #
    sphereMapper = vtk.vtkPolyDataMapper()
    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 ambient lighting coefficients. A little ambient
    # is turned on so the sphere is not completely black on the back side.
    #
    numberOfSpheres = 8
    spheres = list()
    ambient = 0.125
    diffuse = 0.0
    specular = 0.0
    position = [0, 0, 0]
    for i in range(0, numberOfSpheres):
        spheres.append(vtk.vtkActor())
        spheres[i].SetMapper(sphereMapper)
        spheres[i].GetProperty().SetColor(colors.GetColor3d("Red"))
        spheres[i].GetProperty().SetAmbient(ambient)
        spheres[i].GetProperty().SetDiffuse(diffuse)
        spheres[i].GetProperty().SetSpecular(specular)
        spheres[i].AddPosition(position)
        ambient += 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.
    #
    ren = vtk.vtkRenderer()
    renWin = vtk.vtkRenderWindow()
    renWin.AddRenderer(ren)
    iren = vtk.vtkRenderWindowInteractor()
    iren.SetRenderWindow(renWin)

    # Add the actors to the renderer, set the background and size.
    #
    for i in range(0, numberOfSpheres):
        ren.AddActor(spheres[i])

    ren.SetBackground(colors.GetColor3d("bkg"))
    renWin.SetSize(640, 480)
    renWin.SetWindowName("Ambient Spheres")

    # Set up the lighting.
    #
    light = vtk.vtkLight()
    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()


if __name__ == "__main__":
    main()
AmbientSpheres/AmbientSpheres.java0000644000076500000240000001001513424703035020511 0ustar  lorensenstaff00000000000000import vtk.vtkActor;
import vtk.vtkLight;
import vtk.vtkNamedColors;
import vtk.vtkNativeLibrary;
import vtk.vtkPolyDataMapper;
import vtk.vtkRenderer;
import vtk.vtkRenderWindow;
import vtk.vtkRenderWindowInteractor;
import vtk.vtkSphereSource;

public class AmbientSpheres {
  // -----------------------------------------------------------------
  // Load VTK library and print which library was not properly loaded
  static {
    if (!vtkNativeLibrary.LoadAllNativeLibraries()) {
      for (vtkNativeLibrary lib : vtkNativeLibrary.values()) {
        if (!lib.IsLoaded()) {
          System.out.println(lib.GetLibraryName() + " not loaded");
        }
      }
    }
    vtkNativeLibrary.DisableOutputWindow(null);
  }
  // -----------------------------------------------------------------

  public static void main(String s[]) {

    vtkNamedColors colors = new vtkNamedColors();

    double bkg[] = new double[]{0.1, 0.2, 0.4, 1.0};

    double spheresColor[] = new double[4];
    colors.GetColor("Red", spheresColor);

    // The following lines create a sphere represented by polygons.
    //
    vtkSphereSource SphereSource = new vtkSphereSource();
    SphereSource.SetThetaResolution(100);
    SphereSource.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.
    //
    vtkPolyDataMapper sphereMapper = new vtkPolyDataMapper();
    sphereMapper.SetInputConnection(SphereSource.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 specular 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 an array.
    //
    double ambient = 0.125;
    double diffuse = 0.0;
    double specular = 0.0;
    double position[] = new double[]{0.0, 0.0, 0.0};
    vtkActor[] Sphere = new vtkActor[8];
    for (int i = 0; i < 8; ++i) {
      Sphere[i] = new vtkActor();
      Sphere[i].SetMapper(sphereMapper);
      Sphere[i].GetProperty().SetColor(spheresColor);
      Sphere[i].GetProperty().SetAmbient(ambient);
      Sphere[i].GetProperty().SetDiffuse(diffuse);
      Sphere[i].GetProperty().SetSpecular(specular);
      Sphere[i].AddPosition(position);
      ambient += 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.
    //
    vtkRenderer ren = new vtkRenderer();
    vtkRenderWindow renWin = new vtkRenderWindow();
    renWin.AddRenderer(ren);
    vtkRenderWindowInteractor iren = new vtkRenderWindowInteractor();
    iren.SetRenderWindow(renWin);

    // Add the actors to the renderer, set the background and size.
    for (int i = 0; i < 8; ++i) {
      ren.AddActor(Sphere[i]);
    }
    ren.SetBackground(bkg);
    renWin.SetSize(640, 480);

    // Set up the lighting.
    vtkLight Light = new vtkLight();
    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);

    iren.Initialize();
    renWin.Render();
    iren.Start();

  }
}
AmbientSpheres/build/0000755000076500000240000000000013424703035016037 5ustar  lorensenstaff00000000000000