[vtkusers] vtkProp3D::SetUserTransform doing hack to support legacy code

[Renaud Detry]

Hi,

I modified the Cone5 example in Examples/Tutorial to add a second cone
which contains a user transform:

   vtkActor *coneActor = vtkActor::New();
   coneActor->SetMapper( coneMapper );
   vtkActor *coneActor2 = vtkActor::New();
   coneActor2->SetMapper( coneMapper );

   vtkTransform* transform = vtkTransform::New();
   coneActor2->SetUserTransform(transform);

I also changed the interactor style to "switch". (See end of message
for the complete source.)

When I interactively move coneActor, everything is fine. When I move
coneActor2, I hear a complain that

   Warning: In /usr/local/vtk-5.0.3/src/VTK/Common/vtkTransform.cxx,
   line 202 vtkTransform (0x2914670): InternalUpdate: doing hack to
   support legacy code.  This is deprecated in VTK 4.2.  May be removed
   in a future version.

Is this normal? Is there a better way?

Thanks very much,
Renaud.


/ 
*======================================================================= 
==

   Program:   Visualization Toolkit
   Module:    $RCSfile: Cone5.cxx,v $

   Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
   All rights reserved.
   See Copyright.txt or http://www.kitware.com/Copyright.htm for  
details.

      This software is distributed WITHOUT ANY WARRANTY; without even
      the implied warranty of MERCHANTABILITY or FITNESS FOR A  
PARTICULAR
      PURPOSE.  See the above copyright notice for more information.

======================================================================== 
=*/
//
// This example introduces the concepts of interaction into the
// C++ environment. A different interaction style (than
// the default) is defined.
//

// First include the required header files for the VTK classes we are  
using.
#include "vtkConeSource.h"
#include "vtkPolyDataMapper.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkCamera.h"
#include "vtkActor.h"
#include "vtkRenderer.h"
#include "vtkTransform.h"
#include "vtkInteractorStyleSwitch.h"

int main()
{
   //
   // Next we create an instance of vtkConeSource and set some of its
   // properties. The instance of vtkConeSource "cone" is part of a
   // visualization pipeline (it is a source process object); it  
produces data
   // (output type is vtkPolyData) which other filters may process.
   //
   vtkConeSource *cone = vtkConeSource::New();
   cone->SetHeight( 3.0 );
   cone->SetRadius( 1.0 );
   cone->SetResolution( 10 );

   //
   // In this example we terminate the pipeline with a mapper process  
object.
   // (Intermediate filters such as vtkShrinkPolyData could be  
inserted in
   // between the source and the mapper.)  We create an instance of
   // vtkPolyDataMapper to map the polygonal data into graphics  
primitives. We
   // connect the output of the cone souece to the input of this mapper.
   //
   vtkPolyDataMapper *coneMapper = vtkPolyDataMapper::New();
   coneMapper->SetInputConnection( cone->GetOutputPort() );

   //
   // Create an actor to represent the cone. The actor orchestrates  
rendering
   // of the mapper's graphics primitives. An actor also refers to  
properties
   // via a vtkProperty instance, and includes an internal  
transformation
   // matrix. We set this actor's mapper to be coneMapper which we  
created
   // above.
   //
   vtkActor *coneActor = vtkActor::New();
   coneActor->SetMapper( coneMapper );
   vtkActor *coneActor2 = vtkActor::New();
   coneActor2->SetMapper( coneMapper );

   vtkTransform* transform = vtkTransform::New();
   coneActor2->SetUserTransform(transform);


   //
   // Create the Renderer and assign actors to it. A renderer is like a
   // viewport. It is part or all of a window on the screen and it is
   // responsible for drawing the actors it has.  We also set the  
background
   // color here.
   //
   vtkRenderer *ren1= vtkRenderer::New();
   ren1->AddActor( coneActor );
   ren1->AddActor( coneActor2 );
   ren1->SetBackground( 0.1, 0.2, 0.4 );

   //
   // Finally we create the render window which will show up on the  
screen.
   // We put our renderer into the render window using AddRenderer.  
We also
   // set the size to be 300 pixels by 300.
   //
   vtkRenderWindow *renWin = vtkRenderWindow::New();
   renWin->AddRenderer( ren1 );
   renWin->SetSize( 300, 300 );

   //
   // The vtkRenderWindowInteractor class watches for events (e.g.,  
keypress,
   // mouse) in the vtkRenderWindow. These events are translated into
   // event invocations that VTK understands (see VTK/Common/ 
vtkCommand.h
   // for all events that VTK processes). Then observers of these VTK
   // events can process them as appropriate.
   vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
   iren->SetRenderWindow(renWin);

   //
   // By default the vtkRenderWindowInteractor instantiates an instance
   // of vtkInteractorStyle. vtkInteractorStyle translates a set of  
events
   // it observes into operations on the camera, actors, and/or  
properties
   // in the vtkRenderWindow associated with the  
vtkRenderWinodwInteractor.
   // Here we specify a particular interactor style.
   vtkInteractorStyleSwitch *style =
     vtkInteractorStyleSwitch::New();
   iren->SetInteractorStyle(style);

   //
   // Unlike the previous scripts where we performed some operations  
and then
   // exited, here we leave an event loop running. The user can use  
the mouse
   // and keyboard to perform the operations on the scene according  
to the
   // current interaction style. When the user presses the "e" key,  
by default
   // an ExitEvent is invoked by the vtkRenderWindowInteractor which  
is caught
   // and drops out of the event loop (triggered by the Start()  
method that
   // follows.
   //
   iren->Initialize();
   iren->Start();

   //
   // Final note: recall that an observers can watch for particular  
events and
   // take appropriate action. Pressing "u" in the render window  
causes the
   // vtkRenderWindowInteractor to invoke a UserEvent. This can be  
caught to
   // popup a GUI, etc. So the Tcl Cone5.tcl example for an idea of  
how this
   // works.

   //
   // Free up any objects we created. All instances in VTK are  
deleted by
   // using the Delete() method.
   //
   cone->Delete();
   coneMapper->Delete();
   coneActor->Delete();
   coneActor2->Delete();
   ren1->Delete();
   renWin->Delete();
   iren->Delete();
   style->Delete();

   return 0;
}