dox/Rendering/Parallel/vtkParallelRenderManager.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    vtkParallelRenderManager.h

  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 "vtkRenderingParallelModule.h" // For export macro
#include "vtkObject.h"

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

class VTKRENDERINGPARALLEL_EXPORT vtkParallelRenderManager : public vtkObject
{
public:
  vtkTypeMacro(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 StartServices();

  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(int renderId);

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


  static void SetDefaultRenderEventPropagation(bool val)
    { vtkParallelRenderManager::DefaultRenderEventPropagation = val; }
  static bool GetDefaultRenderEventPropagation()
    { return vtkParallelRenderManager::DefaultRenderEventPropagation; }


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


  vtkGetMacro(SyncRenderWindowRenderers, int);
  vtkSetMacro(SyncRenderWindowRenderers, int);
  vtkBooleanMacro(SyncRenderWindowRenderers, int);
  virtual void AddRenderer(vtkRenderer *);
  virtual void RemoveRenderer(vtkRenderer *);
  virtual void RemoveAllRenderers();


  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 MagnifyImage(vtkUnsignedCharArray *fullImage,
                            const int fullImageSize[2],
                            vtkUnsignedCharArray *reducedImage,
                            const int reducedImageSize[2],
                            const int fullImageViewport[4] = NULL,
                            const int reducedImageViewport[4] = NULL);
  static void MagnifyImageNearest(vtkUnsignedCharArray *fullImage,
                                  const int fullImageSize[2],
                                  vtkUnsignedCharArray *reducedImage,
                                  const int reducedImageSize[2],
                                  const int fullImageViewport[4] = NULL,
                                  const int reducedImageViewport[4] = NULL);
  static void MagnifyImageLinear(vtkUnsignedCharArray *fullImage,
                                 const int fullImageSize[2],
                                 vtkUnsignedCharArray *reducedImage,
                                 const int reducedImageSize[2],
                                 const int fullImageViewport[4] = NULL,
                                 const int reducedImageViewport[4] = NULL);


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


  vtkGetVector2Macro(ReducedImageSize, int);

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


  vtkSetMacro(UseRGBA, int);
  vtkGetMacro(UseRGBA, int);


  vtkSetMacro(ForceRenderWindowSize, int);
  vtkGetMacro(ForceRenderWindowSize, int);


  vtkSetVector2Macro(ForcedRenderWindowSize, int);
  vtkGetVector2Macro(ForcedRenderWindowSize, int);

//BTX
  enum Tags {
    RENDER_RMI_TAG=34532,
    COMPUTE_VISIBLE_PROP_BOUNDS_RMI_TAG=54636,
    WIN_INFO_TAG=87834,
    REN_INFO_TAG=87836,
    LIGHT_INFO_TAG=87838,
    REN_ID_TAG=58794,
    BOUNDS_TAG=23543
  };

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


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


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


  virtual void GenericStartRenderCallback();
  virtual void GenericEndRenderCallback();

//BTX
protected:
  vtkParallelRenderManager();
  ~vtkParallelRenderManager();



  void AddRenderWindowEventHandlers();
  void RemoveRenderWindowEventHandlers();

  vtkRenderWindow *RenderWindow;
  vtkMultiProcessController *Controller;
  vtkRendererCollection *Renderers;

  virtual vtkRendererCollection *GetRenderers();

  int ForceRenderWindowSize;
  int ForcedRenderWindowSize[2];

  int RootProcessId;

  int ObservingRenderWindow;
  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 UseRGBA;
  int SynchronizeTileProperties;
  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;
  int SyncRenderWindowRenderers;

  vtkTimerLog *Timer;

  double RenderTime;
  double ImageProcessingTime;

  double AverageTimePerPixel;


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


  virtual void CollectWindowInformation(vtkMultiProcessStream&) {}
  virtual bool ProcessWindowInformation(vtkMultiProcessStream&)
    { return true; }
  virtual void CollectRendererInformation(vtkRenderer*,
    vtkMultiProcessStream&) {}
  virtual bool ProcessRendererInformation(vtkRenderer*,
    vtkMultiProcessStream&) { return true; }


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

  virtual int ImageReduceRenderer(vtkRenderer *) { return 1; }

  struct RenderWindowInfo
  {
    int FullSize[2];
    int ReducedSize[2];
    int NumberOfRenderers;
    int UseCompositing;
    int TileScale[2];
    double ImageReductionFactor;
    double DesiredUpdateRate;
    double TileViewport[4];

    // Save/restore the struct to/from a stream.
    void Save(vtkMultiProcessStream& stream);
    bool Restore(vtkMultiProcessStream& stream);
  };

  struct RendererInfo
  {
    int Draw;
    int NumberOfLights;
    double Viewport[4];
    double CameraPosition[3];
    double CameraFocalPoint[3];
    double CameraViewUp[3];
    double WindowCenter[2];
    double CameraClippingRange[2];
    double CameraViewAngle;
    double Background[3];
    double Background2[3];
    bool GradientBackground;

    double ParallelScale;

    // Save/restore the struct to/from a stream.
    void Save(vtkMultiProcessStream& stream);
    bool Restore(vtkMultiProcessStream& stream);
  };

  struct LightInfo
  {
    double Position[3];
    double FocalPoint[3];
    double Type;
    // Save/restore the struct to/from a stream.
    void Save(vtkMultiProcessStream& stream);
    bool Restore(vtkMultiProcessStream& stream);
  };

  int AddedRMIs;
  unsigned long RenderRMIId;
  unsigned long BoundsRMIId;
  int UseBackBuffer;

  static bool DefaultRenderEventPropagation;

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

#endif //__vtkParalleRenderManager_h