[vtkusers] Re: Multi cameras in a render window

[Aroosha Laghaee]

Hello Ashley,

My understanding of how this can be done is as follows:

1)You need to create 3 renderers
2)add your objects to all of these renderers
2)specify the location of each renderer's camera
4)add all of these renderers to your render window

In this way you can have multiple view points of your objects in one 
window. I enclose the very good example which comes with vtk that shows 
you how to do this.

I hope this helps,
              Aroosha

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

   Program:   Visualization Toolkit
   Module:    $RCSfile: Cone3.cxx,v $
   Language:  C++
   Date:      $Date: 2002/11/15 17:53:45 $
   Version:   $Revision: 1.2 $

   Copyright (c) 1993-2002 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 demonstrates how to use multiple renderers within a
// render window. It is a variation of the Cone.cxx example. Please
// refer to that example for additional documentation.
//

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

int main( int argc, char *argv[] )
{
   //
   // 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->SetInput( cone->GetOutput() );

   //
   // 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 );

   //
   // Create two renderers and assign actors to them. A renderer renders into
   // a viewport within the vtkRenderWindow. 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. In this example we are adding the same
   // actor to two different renderers; it is okay to add different actors to
   // different renderers as well.
   //
   vtkRenderer *ren1= vtkRenderer::New();
   ren1->AddActor( coneActor );
   ren1->SetBackground( 0.1, 0.2, 0.4 );
   ren1->SetViewport(0.0, 0.0, 0.5, 1.0);

   vtkRenderer *ren2= vtkRenderer::New();
   ren2->AddActor( coneActor );
   ren2->SetBackground( 0.2, 0.3, 0.5 );
   ren2->SetViewport(0.5, 0.0, 1.0, 1.0);

   //
   // 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->AddRenderer( ren2 );
   renWin->SetSize( 600, 300 );

   //
   // Make one view 90 degrees from other.
   //
   ren1->GetActiveCamera()->Azimuth(90);

   //
   // Now we loop over 360 degreeees and render the cone each time.
   //
   int i;
   for (i = 0; i < 360; ++i)
     {
     // render the image
     renWin->Render();
     // rotate the active camera by one degree
     ren1->GetActiveCamera()->Azimuth( 1 );
     ren2->GetActiveCamera()->Azimuth( 1 );
     }

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

   return 0;
}

Hi all,

I would like to ask is it possible to have multi cameras in a render window
viewing different angle of an object? For e.g. with one camera, i'll have
the view of a plane in the window. Lets say i have 3 camera, i'll have the
view of the plane being folded into threes (time wall).

Thanks for the help in advance!!
--
View this message in context: 
http://www.nabble.com/Multi-cameras-in-a-render-window-t1409612.html#a3796403
Sent from the VTK - Users forum at Nabble.com.