Assembly.tar

Assembly/0000755000076500000240000000000013424703035013606 5ustar  lorensenstaff00000000000000Assembly/CMakeLists.txt0000644000076500000240000000175213424703035016353 0ustar  lorensenstaff00000000000000
cmake_minimum_required(VERSION 3.3 FATAL_ERROR)

project(Assembly)

find_package(VTK COMPONENTS 
  vtkCommonColor
  vtkCommonCore
  vtkCommonDataModel
  vtkCommonTransforms
  vtkFiltersSources
  vtkInteractionStyle
  vtkInteractionWidgets
  vtkRenderingAnnotation
  vtkRenderingContextOpenGL2
  vtkRenderingCore
  vtkRenderingFreeType
  vtkRenderingGL2PSOpenGL2
  vtkRenderingOpenGL2 QUIET)
if (NOT VTK_FOUND)
  message("Skipping Assembly: ${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(Assembly MACOSX_BUNDLE Assembly.cxx )
  target_link_libraries(Assembly PRIVATE ${VTK_LIBRARIES})
else ()
  # include all components
  add_executable(Assembly MACOSX_BUNDLE Assembly.cxx )
  target_link_libraries(Assembly PRIVATE ${VTK_LIBRARIES})
  # vtk_module_autoinit is needed
  vtk_module_autoinit(
    TARGETS Assembly
    MODULES ${VTK_LIBRARIES}
    )
endif () 
Assembly/build/0000755000076500000240000000000013424703035014705 5ustar  lorensenstaff00000000000000Assembly/Assembly.cxx0000644000076500000240000000607513424703035016121 0ustar  lorensenstaff00000000000000#include <vtkSmartPointer.h>
#include <vtkAssembly.h>

#include <vtkTransform.h>
#include <vtkCubeSource.h>
#include <vtkProperty.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkPolyData.h>
#include <vtkSphereSource.h>
#include <vtkOrientationMarkerWidget.h>
#include <vtkAxesActor.h>
#include <vtkPropAssembly.h>

#include <vtkNamedColors.h>

int main(int, char *[])
{
  vtkSmartPointer<vtkNamedColors> namedColors =
    vtkSmartPointer<vtkNamedColors>::New();

  // Create a sphere
  vtkSmartPointer<vtkSphereSource> sphereSource =
    vtkSmartPointer<vtkSphereSource>::New();
  sphereSource->Update();

  vtkSmartPointer<vtkPolyDataMapper> sphereMapper =
    vtkSmartPointer<vtkPolyDataMapper>::New();
  sphereMapper->SetInputConnection(sphereSource->GetOutputPort());
  vtkSmartPointer<vtkActor> sphereActor =
    vtkSmartPointer<vtkActor>::New();
  sphereActor->SetMapper(sphereMapper);
  sphereActor->GetProperty()->SetColor(
    namedColors->GetColor3d("Banana").GetData());


  // Create a cube
  vtkSmartPointer<vtkCubeSource> cubeSource =
    vtkSmartPointer<vtkCubeSource>::New();
  cubeSource->SetCenter(5.0, 0.0, 0.0);
  cubeSource->Update();

  vtkSmartPointer<vtkPolyDataMapper> cubeMapper =
    vtkSmartPointer<vtkPolyDataMapper>::New();
  cubeMapper->SetInputConnection(cubeSource->GetOutputPort());
  vtkSmartPointer<vtkActor> cubeActor =
    vtkSmartPointer<vtkActor>::New();
  cubeActor->SetMapper(cubeMapper);
  cubeActor->GetProperty()->SetColor(
    namedColors->GetColor3d("Tomato").GetData());
  // Combine the sphere and cube into an assembly
  vtkSmartPointer<vtkAssembly> assembly =
    vtkSmartPointer<vtkAssembly>::New();
  assembly->AddPart(sphereActor);
  assembly->AddPart(cubeActor);

  // Apply a transform to the whole assembly
  vtkSmartPointer<vtkTransform> transform =
    vtkSmartPointer<vtkTransform>::New();
  transform->PostMultiply(); //this is the key line
  transform->Translate(5.0, 0, 0);

  assembly->SetUserTransform(transform);

  // Extract each actor from the assembly and change its opacity
  vtkSmartPointer<vtkPropCollection> collection =
    vtkSmartPointer<vtkPropCollection>::New();

  assembly->GetActors(collection);
  collection->InitTraversal();
  for(vtkIdType i = 0; i < collection->GetNumberOfItems(); i++)
  {
    dynamic_cast<vtkActor*>(collection->GetNextProp())->GetProperty()->SetOpacity(0.5);
  }

  // Visualization
  vtkSmartPointer<vtkRenderer> renderer =
      vtkSmartPointer<vtkRenderer>::New();
  vtkSmartPointer<vtkRenderWindow> renderWindow =
      vtkSmartPointer<vtkRenderWindow>::New();
  renderWindow->AddRenderer(renderer);

  vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
      vtkSmartPointer<vtkRenderWindowInteractor>::New();
  renderWindowInteractor->SetRenderWindow(renderWindow);

  renderer->AddActor(assembly);
  renderer->SetBackground(namedColors->GetColor3d("SlateGray").GetData());

  renderer->ResetCamera();
  renderWindow->Render();

  renderWindowInteractor->Start();

  return EXIT_SUCCESS;
}
Assembly/Assembly.java0000644000076500000240000000636313424703035016240 0ustar  lorensenstaff00000000000000import vtk.vtkActor;
import vtk.vtkNamedColors;
import vtk.vtkNativeLibrary;
import vtk.vtkPolyDataMapper;
import vtk.vtkRenderWindow;
import vtk.vtkRenderWindowInteractor;
import vtk.vtkRenderer;
import vtk.vtkSphereSource;
import vtk.vtkCubeSource;
import vtk.vtkAssembly;
import vtk.vtkTransform;
import vtk.vtkPropCollection;


public class Assembly 
{
  // -----------------------------------------------------------------
  // 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();

    //For sphereActor Color
    double sphereActorColor[] = new double[4];
    //For cubeActor Color
    double cubeActorColor[] = new double[4];
    //Renderer Background Color
    double Bgcolor[] = new double[4];

    colors.GetColor("Banana", sphereActorColor);
    colors.GetColor("Tomato", cubeActorColor);
    colors.GetColor("SlateGray", Bgcolor);
    
    // Create a sphere
    vtkSphereSource sphereSource = new vtkSphereSource();
    sphereSource.Update();

    vtkPolyDataMapper sphereMapper = new vtkPolyDataMapper();
    sphereMapper.SetInputConnection(sphereSource.GetOutputPort());
    
    vtkActor sphereActor = new vtkActor();
    sphereActor.SetMapper(sphereMapper);
    sphereActor.GetProperty().SetColor(sphereActorColor);
    
    // Create a cube
    vtkCubeSource cubeSource = new vtkCubeSource();
    cubeSource.SetCenter(5.0, 0.0, 0.0);
    cubeSource.Update();

    vtkPolyDataMapper cubeMapper = new vtkPolyDataMapper();
    cubeMapper.SetInputConnection(cubeSource.GetOutputPort());
    
    vtkActor cubeActor = new vtkActor();
    cubeActor.SetMapper(cubeMapper);
    cubeActor.GetProperty().SetColor(cubeActorColor);
    
    // Combine the sphere and cube into an assembly
    vtkAssembly assembly = new vtkAssembly();
    assembly.AddPart(sphereActor);
    assembly.AddPart(cubeActor);
    
    // Apply a transform to the whole assembly
    vtkTransform transform = new vtkTransform();
    transform.PostMultiply(); //this is the key line
    transform.Translate(5.0, 0, 0);

    assembly.SetUserTransform(transform);

    // Extract each actor from the assembly and change its opacity
    vtkPropCollection collection = new vtkPropCollection();
	
    assembly.GetActors(collection);
    collection.InitTraversal();
    cubeActor.GetProperty().SetOpacity(0.5);
    sphereActor.GetProperty().SetOpacity(0.5);
    
    // Create the renderer, render window and interactor.
    vtkRenderer ren = new vtkRenderer();
    vtkRenderWindow renWin = new vtkRenderWindow();
    renWin.AddRenderer(ren);
    vtkRenderWindowInteractor iren = new vtkRenderWindowInteractor();
    iren.SetRenderWindow(renWin);
    
    // Visualize
    ren.AddActor(assembly);
	
    ren.SetBackground(Bgcolor);
    
    renWin.SetSize(300, 300);
    renWin.Render();

    iren.Initialize();
    iren.Start();
  }
}