VTK
|
00001 /*========================================================================= 00002 00003 Program: Visualization Toolkit 00004 Module: $RCSfile$ 00005 00006 Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen 00007 All rights reserved. 00008 See Copyright.txt or http://www.kitware.com/Copyright.htm for details. 00009 00010 This software is distributed WITHOUT ANY WARRANTY; without even 00011 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 00012 PURPOSE. See the above copyright notice for more information. 00013 00014 =========================================================================*/ 00032 #ifndef __vtkSynchronizedRenderers_h 00033 #define __vtkSynchronizedRenderers_h 00034 00035 #include "vtkObject.h" 00036 #include "vtkUnsignedCharArray.h" // needed for vtkUnsignedCharArray. 00037 #include "vtkSmartPointer.h" // needed for vtkSmartPointer. 00038 00039 class vtkRenderer; 00040 class vtkMultiProcessController; 00041 class vtkMultiProcessStream; 00042 00043 class VTK_PARALLEL_EXPORT vtkSynchronizedRenderers : public vtkObject 00044 { 00045 public: 00046 static vtkSynchronizedRenderers* New(); 00047 vtkTypeMacro(vtkSynchronizedRenderers, vtkObject); 00048 void PrintSelf(ostream& os, vtkIndent indent); 00049 00051 00055 virtual void SetRenderer(vtkRenderer*); 00056 vtkGetObjectMacro(Renderer, vtkRenderer); 00058 00060 00062 virtual void SetParallelController(vtkMultiProcessController*); 00063 vtkGetObjectMacro(ParallelController, vtkMultiProcessController); 00065 00067 00069 vtkSetMacro(ParallelRendering, bool); 00070 vtkGetMacro(ParallelRendering, bool); 00071 vtkBooleanMacro(ParallelRendering, bool); 00073 00075 00076 vtkSetClampMacro(ImageReductionFactor, int, 1, 50); 00077 vtkGetMacro(ImageReductionFactor, int); 00079 00081 00084 vtkSetMacro(WriteBackImages, bool); 00085 vtkGetMacro(WriteBackImages, bool); 00086 vtkBooleanMacro(WriteBackImages, bool); 00088 00090 00094 vtkSetMacro(RootProcessId, int); 00095 vtkGetMacro(RootProcessId, int); 00097 00103 void CollectiveExpandForVisiblePropBounds(double bounds[6]); 00104 00106 00108 virtual void SetCaptureDelegate(vtkSynchronizedRenderers*); 00109 vtkGetObjectMacro(CaptureDelegate, vtkSynchronizedRenderers); 00111 00113 00119 vtkSetMacro(AutomaticEventHandling, bool); 00120 vtkGetMacro(AutomaticEventHandling, bool); 00121 vtkBooleanMacro(AutomaticEventHandling, bool); 00123 00124 //BTX 00125 enum 00126 { 00127 SYNC_RENDERER_TAG = 15101, 00128 RESET_CAMERA_TAG = 15102, 00129 COMPUTE_BOUNDS_TAG = 15103 00130 }; 00131 00134 struct VTK_PARALLEL_EXPORT vtkRawImage 00135 { 00136 public: 00137 vtkRawImage() 00138 { 00139 this->Valid = false; 00140 this->Size[0] = this->Size[1] = 0; 00141 this->Data = vtkSmartPointer<vtkUnsignedCharArray>::New(); 00142 } 00143 00144 void Resize(int dx, int dy, int numcomps) 00145 { 00146 this->Valid = false; 00147 this->Allocate(dx, dy, numcomps); 00148 } 00149 00151 void Initialize(int dx, int dy, vtkUnsignedCharArray* data); 00152 00153 void MarkValid() { this->Valid = true; } 00154 void MarkInValid() { this->Valid = false; } 00155 00156 bool IsValid() { return this->Valid; } 00157 int GetWidth() { return this->Size[0];} 00158 int GetHeight() { return this->Size[1];} 00159 vtkUnsignedCharArray* GetRawPtr() 00160 { return this->Data; } 00161 00162 // Pushes the image to the viewport. 00163 bool PushToViewport(vtkRenderer*); 00164 00165 // This is a raw version of PushToViewport() that assumes that the 00166 // glViewport() has already been setup externally. 00167 bool PushToFrameBuffer(); 00168 00169 // Captures the image from the viewport. 00170 // This doesn't trigger a render, just captures what's currently there in 00171 // the active buffer. 00172 bool Capture(vtkRenderer*); 00173 00174 // Save the image as a png. Useful for debugging. 00175 void SaveAsPNG(const char* filename); 00176 00177 private: 00178 bool Valid; 00179 int Size[2]; 00180 vtkSmartPointer<vtkUnsignedCharArray> Data; 00181 00182 void Allocate(int dx, int dy, int numcomps); 00183 }; 00184 //ETX 00185 protected: 00186 vtkSynchronizedRenderers(); 00187 ~vtkSynchronizedRenderers(); 00188 00189 struct RendererInfo 00190 { 00191 int ImageReductionFactor; 00192 int Draw; 00193 int CameraParallelProjection; 00194 double Viewport[4]; 00195 double CameraPosition[3]; 00196 double CameraFocalPoint[3]; 00197 double CameraViewUp[3]; 00198 double CameraWindowCenter[2]; 00199 double CameraClippingRange[2]; 00200 double CameraViewAngle; 00201 double CameraParallelScale; 00202 00203 // Save/restore the struct to/from a stream. 00204 void Save(vtkMultiProcessStream& stream); 00205 bool Restore(vtkMultiProcessStream& stream); 00206 00207 void CopyFrom(vtkRenderer*); 00208 void CopyTo(vtkRenderer*); 00209 }; 00210 00211 // These methods are called on all processes as a consequence of corresponding 00212 // events being called on the renderer. 00213 virtual void HandleStartRender(); 00214 virtual void HandleEndRender(); 00215 virtual void HandleAbortRender() {} 00216 00217 virtual void MasterStartRender(); 00218 virtual void SlaveStartRender(); 00219 00220 virtual void MasterEndRender(); 00221 virtual void SlaveEndRender(); 00222 00223 vtkMultiProcessController* ParallelController; 00224 vtkRenderer* Renderer; 00225 00231 virtual vtkRawImage& CaptureRenderedImage(); 00232 00236 void PushImageToScreen(); 00237 00238 vtkSynchronizedRenderers* CaptureDelegate; 00239 vtkRawImage ReducedImage; 00240 vtkRawImage FullImage; 00241 00242 bool ParallelRendering; 00243 int ImageReductionFactor; 00244 bool WriteBackImages; 00245 int RootProcessId; 00246 bool AutomaticEventHandling; 00247 00248 private: 00249 vtkSynchronizedRenderers(const vtkSynchronizedRenderers&); // Not implemented 00250 void operator=(const vtkSynchronizedRenderers&); // Not implemented 00251 00252 class vtkObserver; 00253 vtkObserver* Observer; 00254 friend class vtkObserver; 00255 00256 double LastViewport[4]; 00257 }; 00258 00259 #endif 00260