vtkParallelRenderManager.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkParallelRenderManager.h,v $

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

  Copyright 2003 Sandia Corporation. Under the terms of Contract
  DE-AC04-94AL85000, there is a non-exclusive license for use of this work by
  or on behalf of the U.S. Government. Redistribution and use in source and
  binary forms, with or without modification, are permitted provided that this
  Notice and any statement of authorship are reproduced on all copies.

     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.

=========================================================================*/
#ifndef __vtkParallelRenderManager_h
#define __vtkParallelRenderManager_h

#include "vtkObject.h"

class vtkRenderWindow;
class vtkRenderer;
class vtkUnsignedCharArray;
class vtkDoubleArray;
class vtkTimerLog;
class vtkMultiProcessController;

class VTK_PARALLEL_EXPORT vtkParallelRenderManager : public vtkObject
{
public:
  vtkTypeRevisionMacro(vtkParallelRenderManager, vtkObject);
  virtual void PrintSelf(ostream &os, vtkIndent indent);

  virtual vtkRenderWindow *MakeRenderWindow();

  virtual vtkRenderer *MakeRenderer();


  vtkGetObjectMacro(RenderWindow, vtkRenderWindow);
  virtual void SetRenderWindow(vtkRenderWindow *renWin);


  vtkGetObjectMacro(Controller, vtkMultiProcessController);
  virtual void SetController(vtkMultiProcessController *controller);

  virtual void InitializePieces();

  virtual void InitializeOffScreen();

  virtual void StartInteractor();

  virtual void StartService();

  virtual void StopServices();


  virtual void StartRender();
  virtual void EndRender();
  virtual void SatelliteStartRender();
  virtual void SatelliteEndRender();
  virtual void RenderRMI();
  virtual void ResetCamera(vtkRenderer *ren);
  virtual void ResetCameraClippingRange(vtkRenderer *ren);
  virtual void ComputeVisiblePropBoundsRMI();

  virtual void InitializeRMIs();

  virtual void ResetAllCameras();

  virtual void ComputeVisiblePropBounds(vtkRenderer *ren, double bounds[6]);


  vtkSetMacro(ParallelRendering, int);
  vtkGetMacro(ParallelRendering, int);
  vtkBooleanMacro(ParallelRendering, int);


  vtkSetMacro(RenderEventPropagation, int);
  vtkGetMacro(RenderEventPropagation, int);
  vtkBooleanMacro(RenderEventPropagation, int);


  vtkSetMacro(UseCompositing, int);
  vtkGetMacro(UseCompositing, int);
  vtkBooleanMacro(UseCompositing, int);


  virtual void SetImageReductionFactor(double factor);
  vtkGetMacro(ImageReductionFactor, double);

  vtkSetMacro(MaxImageReductionFactor, double);
  vtkGetMacro(MaxImageReductionFactor, double);

  virtual void SetImageReductionFactorForUpdateRate(double DesiredUpdateRate);


  vtkSetMacro(AutoImageReductionFactor, int);
  vtkGetMacro(AutoImageReductionFactor, int);
  vtkBooleanMacro(AutoImageReductionFactor, int);


  vtkGetMacro(RenderTime, double);
  vtkGetMacro(ImageProcessingTime, double);


  vtkSetMacro(WriteBackImages, int);
  vtkGetMacro(WriteBackImages, int);
  vtkBooleanMacro(WriteBackImages, int);


  vtkSetMacro(MagnifyImages, int);
  vtkGetMacro(MagnifyImages, int);
  vtkBooleanMacro(MagnifyImages, int);

//BTX
  enum { NEAREST, LINEAR };
//ETX


  virtual void SetMagnifyImageMethod(int method);
  vtkGetMacro(MagnifyImageMethod, int);
  void SetMagnifyImageMethodToNearest() {
    this->SetMagnifyImageMethod(NEAREST);
  }
  void SetMagnifyImageMethodToLinear() {
    this->SetMagnifyImageMethod(LINEAR);
  }


  virtual void GetPixelData(vtkUnsignedCharArray *data);
  virtual void GetPixelData(int x1, int y1, int x2, int y2,
          vtkUnsignedCharArray *data);


  virtual void GetReducedPixelData(vtkUnsignedCharArray *data);
  virtual void GetReducedPixelData(int x1, int y1, int x2, int y2,
           vtkUnsignedCharArray *data);


  vtkGetVector2Macro(FullImageSize, int);
  // Description:
  // Returns the reduced image size calculated at the last render.
  vtkGetVector2Macro(ReducedImageSize, int);

  void TileWindows(int xsize, int ysize, int nColumns);

//BTX
  enum Tags {
    RENDER_RMI_TAG=34532,
    COMPUTE_VISIBLE_PROP_BOUNDS_RMI_TAG=54636,
    WIN_INFO_INT_TAG=87834,
    WIN_INFO_DOUBLE_TAG=87835,
    REN_INFO_INT_TAG=87836,
    REN_INFO_DOUBLE_TAG=87837,
    LIGHT_INFO_DOUBLE_TAG=87838,
    REN_ID_TAG=58794,
    BOUNDS_TAG=23543
  };

  virtual void CheckForAbortRender() {}
  virtual int CheckForAbortComposite() {return 0;}  
//ETX

protected:
  vtkParallelRenderManager();
  ~vtkParallelRenderManager();

  vtkRenderWindow *RenderWindow;
  vtkMultiProcessController *Controller;

  int RootProcessId;

  int ObservingRenderWindow;
  int ObservingRenderer;
  int ObservingAbort;

  unsigned long StartRenderTag;
  unsigned long EndRenderTag;
  unsigned long ResetCameraTag;
  unsigned long ResetCameraClippingRangeTag;
  unsigned long AbortRenderCheckTag;

  double ImageReductionFactor;
  double MaxImageReductionFactor;
  int AutoImageReductionFactor;

  int WriteBackImages;
  int MagnifyImages;
  int MagnifyImageMethod;

  int FullImageSize[2];
  int ReducedImageSize[2];

  vtkUnsignedCharArray *FullImage;
  vtkUnsignedCharArray *ReducedImage;

  int FullImageUpToDate;
  int ReducedImageUpToDate;
  int RenderWindowImageUpToDate;

  vtkDoubleArray *Viewports;

  int Lock;
  int ParallelRendering;
  int RenderEventPropagation;
  int UseCompositing;

  vtkTimerLog *Timer;

  double RenderTime;
  double ImageProcessingTime;

  double AverageTimePerPixel;


  virtual void SendWindowInformation() {}
  virtual void ReceiveWindowInformation() {}
  virtual void SendRendererInformation(vtkRenderer *) {};
  virtual void ReceiveRendererInformation(vtkRenderer *) {};


  virtual void PreRenderProcessing() = 0;
  virtual void PostRenderProcessing() = 0;

  virtual void SetRenderWindowSize();

  virtual void LocalComputeVisiblePropBounds(vtkRenderer *ren, double bounds[6]);

  virtual void MagnifyReducedImage();

  virtual void WriteFullImage();

  virtual void ReadReducedImage();

  virtual int LastRenderInFrontBuffer();

  virtual int ChooseBuffer();
  

  virtual void SetRenderWindowPixelData(vtkUnsignedCharArray *pixels,
          const int pixelDimensions[2]);

//BTX
  struct RenderWindowInfoInt
  {
    int FullSize[2];
    int ReducedSize[2];
    int NumberOfRenderers;
    int UseCompositing;
  };

  struct RenderWindowInfoDouble
  {
    double ImageReductionFactor;
    double DesiredUpdateRate;
  };
  
  struct RendererInfoInt
  {
    int NumberOfLights;
  };

  struct RendererInfoDouble
  {
    double Viewport[4];
    double CameraPosition[3];
    double CameraFocalPoint[3];
    double CameraViewUp[3];
    double CameraClippingRange[2];
    double CameraViewAngle;
    double Background[3];
    double ParallelScale;
  };
  
  struct LightInfoDouble
  {
    double Position[3];
    double FocalPoint[3];
    double Type;
  };

  static const int WIN_INFO_INT_SIZE;
  static const int WIN_INFO_DOUBLE_SIZE;
  static const int REN_INFO_INT_SIZE;
  static const int REN_INFO_DOUBLE_SIZE;
  static const int LIGHT_INFO_DOUBLE_SIZE;
//ETX

  int AddedRMIs;
private:
  vtkParallelRenderManager(const vtkParallelRenderManager &); //Not implemented
  void operator=(const vtkParallelRenderManager &);  //Not implemented
};

#endif //__vtkParalleRenderManager_h

Generated on Tue Oct 5 08:39:14 2004 for VTK by Doxygen 1.3.8-20040913