BlobbyLogo.tar

BlobbyLogo/0000755000076500000240000000000013424703035014061 5ustar  lorensenstaff00000000000000BlobbyLogo/CMakeLists.txt0000644000076500000240000000166013424703035016624 0ustar  lorensenstaff00000000000000
cmake_minimum_required(VERSION 3.3 FATAL_ERROR)

project(BlobbyLogo)

find_package(VTK COMPONENTS 
  vtkCommonColor
  vtkCommonCore
  vtkCommonTransforms
  vtkFiltersCore
  vtkFiltersGeneral
  vtkFiltersHybrid
  vtkIOLegacy
  vtkInteractionStyle
  vtkRenderingCore
  vtkRenderingFreeType
  vtkRenderingOpenGL2 QUIET)
if (NOT VTK_FOUND)
  message("Skipping BlobbyLogo: ${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(BlobbyLogo MACOSX_BUNDLE BlobbyLogo.cxx )
  target_link_libraries(BlobbyLogo PRIVATE ${VTK_LIBRARIES})
else ()
  # include all components
  add_executable(BlobbyLogo MACOSX_BUNDLE BlobbyLogo.cxx )
  target_link_libraries(BlobbyLogo PRIVATE ${VTK_LIBRARIES})
  # vtk_module_autoinit is needed
  vtk_module_autoinit(
    TARGETS BlobbyLogo
    MODULES ${VTK_LIBRARIES}
    )
endif () 
BlobbyLogo/BlobbyLogo.java0000644000076500000240000001270013424703035016756 0ustar  lorensenstaff00000000000000import vtk.vtkNativeLibrary;
import vtk.vtkRenderWindow;
import vtk.vtkRenderWindowInteractor;
import vtk.vtkRenderer;
import vtk.vtkActor;
import vtk.vtkNamedColors;
import vtk.vtkPolyDataMapper;
import vtk.vtkPolyDataReader;
import vtk.vtkTransform;
import vtk.vtkTransformPolyDataFilter;
import vtk.vtkPolyDataNormals;
import vtk.vtkAppendPolyData;
import vtk.vtkImplicitModeller;
import vtk.vtkContourFilter;
import vtk.vtkProperty;

public class BlobbyLogo 
{
  // -----------------------------------------------------------------
  // 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 args[]) 
  {
    //parse command line arguments
    if (args.length != 3) 
    {
      System.err.println("Usage: java -classpath ... Filename(.vtk) Filename(.vtk) Filename(.vtk) e.g v.vtk t.vtk k.vtk");
      return;
    }
    
    vtkRenderer aRenderer = new vtkRenderer();
    vtkRenderWindow aRenderWindow = new vtkRenderWindow();
    aRenderWindow.AddRenderer(aRenderer);
    vtkRenderWindowInteractor anInteractor = new vtkRenderWindowInteractor();
    anInteractor.SetRenderWindow(aRenderWindow);
    aRenderWindow.SetSize( 300, 300 );
    
    //read the geometry file containing the letter v
    vtkPolyDataReader letterV = new vtkPolyDataReader();
    letterV.SetFileName (args[0]);

    //read the geometry file containing the letter t
    vtkPolyDataReader letterT = new vtkPolyDataReader();
    letterT.SetFileName (args[1]);

    //read the geometry file containing the letter k
    vtkPolyDataReader letterK = new vtkPolyDataReader();
    letterK.SetFileName (args[2]);
    
    //create a transform and transform filter for each letter
    vtkTransform VTransform = new vtkTransform();
    vtkTransformPolyDataFilter VTransformFilter = new vtkTransformPolyDataFilter();
    VTransformFilter.SetInputConnection(letterV.GetOutputPort());
    VTransformFilter.SetTransform (VTransform);

    vtkTransform TTransform = new vtkTransform();
    vtkTransformPolyDataFilter TTransformFilter = new vtkTransformPolyDataFilter();
    TTransformFilter.SetInputConnection (letterT.GetOutputPort());
    TTransformFilter.SetTransform (TTransform);

    vtkTransform KTransform = new vtkTransform();
    vtkTransformPolyDataFilter KTransformFilter = new vtkTransformPolyDataFilter();
    KTransformFilter.SetInputConnection(letterK.GetOutputPort());
    KTransformFilter.SetTransform (KTransform);
  
    //now append them all
    vtkAppendPolyData appendAll = new vtkAppendPolyData();
    appendAll.AddInputConnection (VTransformFilter.GetOutputPort());
    appendAll.AddInputConnection (TTransformFilter.GetOutputPort());
    appendAll.AddInputConnection (KTransformFilter.GetOutputPort());

    //create normals
    vtkPolyDataNormals logoNormals = new vtkPolyDataNormals();
    logoNormals.SetInputConnection (appendAll.GetOutputPort());
    logoNormals.SetFeatureAngle (60);

    //map to rendering primitives
    vtkPolyDataMapper logoMapper = new vtkPolyDataMapper();
    logoMapper.SetInputConnection (logoNormals.GetOutputPort());

    //now an actor
    vtkActor logo = new vtkActor();
    logo.SetMapper (logoMapper);
    
    //now create an implicit model of the same letter
    vtkImplicitModeller blobbyLogoImp = new vtkImplicitModeller();
    blobbyLogoImp.SetInputConnection(appendAll.GetOutputPort());
    blobbyLogoImp.SetMaximumDistance (.075);
    blobbyLogoImp.SetSampleDimensions (64,64,64); 
    blobbyLogoImp.SetAdjustDistance (0.05);

    //extract an iso surface
    vtkContourFilter blobbyLogoIso = new vtkContourFilter();
    blobbyLogoIso.SetInputConnection(blobbyLogoImp.GetOutputPort());
    blobbyLogoIso.SetValue (1, 1.5);

    //map to rendering primitives
    vtkPolyDataMapper blobbyLogoMapper = new vtkPolyDataMapper();
    blobbyLogoMapper.SetInputConnection(blobbyLogoIso.GetOutputPort());
    blobbyLogoMapper.ScalarVisibilityOff ();
     
    vtkNamedColors Color = new vtkNamedColors(); 

    double tomatoColor[] = new double[4];
    double bananaColor[] = new double[4];
    double BgColor[] = new double[4];

    Color.GetColor("tomato",tomatoColor);
    Color.GetColor("banana",bananaColor);
    Color.GetColor("SlateGray",BgColor);
    
    vtkProperty tomato = new vtkProperty();
    tomato.SetDiffuseColor(tomatoColor);
    tomato.SetSpecular(.3);
    tomato.SetSpecularPower(20);

    vtkProperty banana = new vtkProperty();
    banana.SetDiffuseColor(bananaColor);
    banana.SetDiffuse (.7);
    banana.SetSpecular(.4);
    banana.SetSpecularPower(20);
    
    //An actor
    vtkActor blobbyLogo = new vtkActor();
    blobbyLogo.SetMapper (blobbyLogoMapper);
    blobbyLogo.SetProperty (banana);

    // position the letters

    VTransform.Translate (-16.0,0.0,12.5);
    VTransform.RotateY (40);

    KTransform.Translate (14.0, 0.0, 0.0);
    KTransform.RotateY (-40);

    // move the polygonal letters to the front
    logo.SetProperty (tomato);
    logo.SetPosition(0,0,6);

    aRenderer.AddActor(logo);
    aRenderer.AddActor(blobbyLogo);

    aRenderer.SetBackground(BgColor);

    aRenderWindow.Render();

    // interact with data
    anInteractor.Start();

  }
}
BlobbyLogo/BlobbyLogo.py0000755000076500000240000001021613424703035016470 0ustar  lorensenstaff00000000000000#!/usr/bin/env python

"""
"""

import vtk


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

    fileName1, fileName2, fileName3 = get_program_parameters()
    aRenderer = vtk.vtkRenderer()
    aRenderWindow = vtk.vtkRenderWindow()
    aRenderWindow.AddRenderer(aRenderer)
    anInteractor = vtk.vtkRenderWindowInteractor()
    anInteractor.SetRenderWindow(aRenderWindow)
    aRenderWindow.SetSize(300, 300)

    # Read the geometry file containing the letter v.
    letterV = vtk.vtkPolyDataReader()
    letterV.SetFileName(fileName1)

    # Read the geometry file containing the letter t.
    letterT = vtk.vtkPolyDataReader()
    letterT.SetFileName(fileName2)

    # Read the geometry file containing the letter k.
    letterK = vtk.vtkPolyDataReader()
    letterK.SetFileName(fileName3)

    # Create a transform and transform filter for each letter.
    VTransform = vtk.vtkTransform()
    VTransformFilter = vtk.vtkTransformPolyDataFilter()
    VTransformFilter.SetInputConnection(letterV.GetOutputPort())
    VTransformFilter.SetTransform(VTransform)

    TTransform = vtk.vtkTransform()
    TTransformFilter = vtk.vtkTransformPolyDataFilter()
    TTransformFilter.SetInputConnection(letterT.GetOutputPort())
    TTransformFilter.SetTransform(TTransform)

    KTransform = vtk.vtkTransform()
    KTransformFilter = vtk.vtkTransformPolyDataFilter()
    KTransformFilter.SetInputConnection(letterK.GetOutputPort())
    KTransformFilter.SetTransform(KTransform)

    # Now append them all.
    appendAll = vtk.vtkAppendPolyData()
    appendAll.AddInputConnection(VTransformFilter.GetOutputPort())
    appendAll.AddInputConnection(TTransformFilter.GetOutputPort())
    appendAll.AddInputConnection(KTransformFilter.GetOutputPort())

    # Create normals.
    logoNormals = vtk.vtkPolyDataNormals()
    logoNormals.SetInputConnection(appendAll.GetOutputPort())
    logoNormals.SetFeatureAngle(60)

    # Map to rendering primitives.
    logoMapper = vtk.vtkPolyDataMapper()
    logoMapper.SetInputConnection(logoNormals.GetOutputPort())

    # Now an actor.
    logo = vtk.vtkActor()
    logo.SetMapper(logoMapper)

    # Now create an implicit model of the same letter.
    blobbyLogoImp = vtk.vtkImplicitModeller()
    blobbyLogoImp.SetInputConnection(appendAll.GetOutputPort())
    blobbyLogoImp.SetMaximumDistance(.075)
    blobbyLogoImp.SetSampleDimensions(64, 64, 64)
    blobbyLogoImp.SetAdjustDistance(0.05)

    # Extract an iso surface.
    blobbyLogoIso = vtk.vtkContourFilter()
    blobbyLogoIso.SetInputConnection(blobbyLogoImp.GetOutputPort())
    blobbyLogoIso.SetValue(1, 1.5)

    # Map to rendering primitives.
    blobbyLogoMapper = vtk.vtkPolyDataMapper()
    blobbyLogoMapper.SetInputConnection(blobbyLogoIso.GetOutputPort())
    blobbyLogoMapper.ScalarVisibilityOff()

    tomato = vtk.vtkProperty()
    tomato.SetDiffuseColor(colors.GetColor3d("tomato"))
    tomato.SetSpecular(.3)
    tomato.SetSpecularPower(20)

    banana = vtk.vtkProperty()
    banana.SetDiffuseColor(colors.GetColor3d("banana"))
    banana.SetDiffuse(.7)
    banana.SetSpecular(.4)
    banana.SetSpecularPower(20)

    # Now an actor.
    blobbyLogo = vtk.vtkActor()
    blobbyLogo.SetMapper(blobbyLogoMapper)
    blobbyLogo.SetProperty(banana)

    # Position the letters.

    VTransform.Translate(-16.0, 0.0, 12.5)
    VTransform.RotateY(40)

    KTransform.Translate(14.0, 0.0, 0.0)
    KTransform.RotateY(-40)

    # Move the polygonal letters to the front.
    logo.SetProperty(tomato)
    logo.SetPosition(0, 0, 6)

    aRenderer.AddActor(logo)
    aRenderer.AddActor(blobbyLogo)

    aRenderer.SetBackground(colors.GetColor3d("SlateGray"))

    aRenderWindow.Render()

    # Interact with the data.
    anInteractor.Start()


def get_program_parameters():
    import argparse
    description = 'Use implicit modeller to create the VTK logo.'
    epilogue = '''
   '''
    parser = argparse.ArgumentParser(description=description, epilog=epilogue)
    parser.add_argument('filename1', help='v.vtk.')
    parser.add_argument('filename2', help='t.vtk.')
    parser.add_argument('filename3', help='k.vtk.')
    args = parser.parse_args()
    return args.filename1, args.filename2, args.filename3


if __name__ == '__main__':
    main()
BlobbyLogo/build/0000755000076500000240000000000013424703035015160 5ustar  lorensenstaff00000000000000BlobbyLogo/BlobbyLogo.cxx0000644000076500000240000001274713424703035016652 0ustar  lorensenstaff00000000000000//
// use implicit modeller to create the VTK logo
//

#include <vtkActor.h>
#include <vtkAppendPolyData.h>
#include <vtkContourFilter.h>
#include <vtkImplicitModeller.h>
#include <vtkNamedColors.h>
#include <vtkPolyDataMapper.h>
#include <vtkPolyDataNormals.h>
#include <vtkPolyDataReader.h>
#include <vtkProperty.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkSmartPointer.h>
#include <vtkTransform.h>
#include <vtkTransformPolyDataFilter.h>

int main( int argc, char *argv[] )
{
  if (argc < 4)
  {
    std::cout << "Usage: " << argv[0] << " v.vtk t.vtk k.vtk" << std::endl;
    return EXIT_FAILURE;
  }

  vtkSmartPointer<vtkRenderer> aRenderer =
    vtkSmartPointer<vtkRenderer>::New();
  vtkSmartPointer<vtkRenderWindow> aRenderWindow =
    vtkSmartPointer<vtkRenderWindow>::New();
  aRenderWindow->AddRenderer(aRenderer);
  vtkSmartPointer<vtkRenderWindowInteractor> anInteractor =
    vtkSmartPointer<vtkRenderWindowInteractor>::New();
  anInteractor->SetRenderWindow(aRenderWindow);
  aRenderWindow->SetSize( 300, 300 );

  // read the geometry file containing the letter v
  vtkSmartPointer<vtkPolyDataReader> letterV =
    vtkSmartPointer<vtkPolyDataReader>::New();
  letterV->SetFileName (argv[1]);

  // read the geometry file containing the letter t
  vtkSmartPointer<vtkPolyDataReader> letterT =
    vtkSmartPointer<vtkPolyDataReader>::New();
  letterT->SetFileName (argv[2]);

  // read the geometry file containing the letter k
  vtkSmartPointer<vtkPolyDataReader> letterK =
    vtkSmartPointer<vtkPolyDataReader>::New();
  letterK->SetFileName (argv[3]);

  // create a transform and transform filter for each letter
  vtkSmartPointer<vtkTransform> VTransform =
    vtkSmartPointer<vtkTransform>::New();
  vtkSmartPointer<vtkTransformPolyDataFilter> VTransformFilter =
    vtkSmartPointer<vtkTransformPolyDataFilter>::New();
  VTransformFilter->SetInputConnection(letterV->GetOutputPort());
  VTransformFilter->SetTransform (VTransform);

  vtkSmartPointer<vtkTransform> TTransform =
    vtkSmartPointer<vtkTransform>::New();
  vtkSmartPointer<vtkTransformPolyDataFilter> TTransformFilter =
    vtkSmartPointer<vtkTransformPolyDataFilter>::New();
  TTransformFilter->SetInputConnection (letterT->GetOutputPort());
  TTransformFilter->SetTransform (TTransform);

  vtkSmartPointer<vtkTransform> KTransform =
    vtkSmartPointer<vtkTransform>::New();
  vtkSmartPointer<vtkTransformPolyDataFilter> KTransformFilter =
    vtkSmartPointer<vtkTransformPolyDataFilter>::New();
  KTransformFilter->SetInputConnection(letterK->GetOutputPort());
  KTransformFilter->SetTransform (KTransform);

  // now append them all
  vtkSmartPointer<vtkAppendPolyData> appendAll =
    vtkSmartPointer<vtkAppendPolyData>::New();
  appendAll->AddInputConnection (VTransformFilter->GetOutputPort());
  appendAll->AddInputConnection (TTransformFilter->GetOutputPort());
  appendAll->AddInputConnection (KTransformFilter->GetOutputPort());

  // create normals
  vtkSmartPointer<vtkPolyDataNormals> logoNormals =
    vtkSmartPointer<vtkPolyDataNormals>::New();
  logoNormals->SetInputConnection (appendAll->GetOutputPort());
  logoNormals->SetFeatureAngle (60);

  // map to rendering primitives
  vtkSmartPointer<vtkPolyDataMapper> logoMapper =
    vtkSmartPointer<vtkPolyDataMapper>::New();
  logoMapper->SetInputConnection (logoNormals->GetOutputPort());

  // now an actor
  vtkSmartPointer<vtkActor> logo =
    vtkSmartPointer<vtkActor>::New();
  logo->SetMapper (logoMapper);

  // now create an implicit model of the same letter
  vtkSmartPointer<vtkImplicitModeller> blobbyLogoImp =
    vtkSmartPointer<vtkImplicitModeller>::New();
  blobbyLogoImp->SetInputConnection(appendAll->GetOutputPort());
  blobbyLogoImp->SetMaximumDistance (.075);
  blobbyLogoImp->SetSampleDimensions (64,64,64); 
  blobbyLogoImp->SetAdjustDistance (0.05);

  // extract an iso surface
  vtkSmartPointer<vtkContourFilter> blobbyLogoIso =
    vtkSmartPointer<vtkContourFilter>::New();
  blobbyLogoIso->SetInputConnection (blobbyLogoImp->GetOutputPort());
  blobbyLogoIso->SetValue (1, 1.5);

  // map to rendering primitives
  vtkSmartPointer<vtkPolyDataMapper> blobbyLogoMapper =
    vtkSmartPointer<vtkPolyDataMapper>::New();
  blobbyLogoMapper->SetInputConnection (blobbyLogoIso->GetOutputPort());
  blobbyLogoMapper->ScalarVisibilityOff ();

  vtkSmartPointer<vtkNamedColors> colors =
    vtkSmartPointer<vtkNamedColors>::New();

  vtkSmartPointer<vtkProperty> tomato =
    vtkSmartPointer<vtkProperty>::New();
  tomato->SetDiffuseColor(colors->GetColor3d("tomato").GetData());
  tomato->SetSpecular(.3);
  tomato->SetSpecularPower(20);

  vtkSmartPointer<vtkProperty> banana =
    vtkSmartPointer<vtkProperty>::New();
  banana->SetDiffuseColor(colors->GetColor3d("banana").GetData());
  banana->SetDiffuse (.7);
  banana->SetSpecular(.4);
  banana->SetSpecularPower(20);

  // now an actor
  vtkSmartPointer<vtkActor> blobbyLogo =
    vtkSmartPointer<vtkActor>::New();
  blobbyLogo->SetMapper (blobbyLogoMapper);
  blobbyLogo->SetProperty (banana);

  // position the letters

  VTransform->Translate (-16.0,0.0,12.5);
  VTransform->RotateY (40);

  KTransform->Translate (14.0, 0.0, 0.0);
  KTransform->RotateY (-40);

  // move the polygonal letters to the front
  logo->SetProperty (tomato);
  logo->SetPosition(0,0,6);
  
  aRenderer->AddActor(logo);
  aRenderer->AddActor(blobbyLogo);

  aRenderer->SetBackground(colors->GetColor3d("SlateGray").GetData());

  aRenderWindow->Render();

  // interact with data
  anInteractor->Start();

  return EXIT_SUCCESS;
}