VTK
|
00001 /*========================================================================= 00002 00003 Program: Visualization Toolkit 00004 Module: $RCSfile: vtkStreamer.h,v $ 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 =========================================================================*/ 00052 #ifndef __vtkStreamer_h 00053 #define __vtkStreamer_h 00054 00055 #include "vtkPolyDataAlgorithm.h" 00056 00057 class vtkInitialValueProblemSolver; 00058 class vtkMultiThreader; 00059 00060 #define VTK_INTEGRATE_FORWARD 0 00061 #define VTK_INTEGRATE_BACKWARD 1 00062 #define VTK_INTEGRATE_BOTH_DIRECTIONS 2 00063 00064 class VTK_GRAPHICS_EXPORT vtkStreamer : public vtkPolyDataAlgorithm 00065 { 00066 public: 00067 vtkTypeRevisionMacro(vtkStreamer,vtkPolyDataAlgorithm); 00068 void PrintSelf(ostream& os, vtkIndent indent); 00069 00073 void SetStartLocation(vtkIdType cellId, int subId, double pcoords[3]); 00074 00076 00079 void SetStartLocation(vtkIdType cellId, int subId, double r, double s, 00080 double t); 00082 00085 vtkIdType GetStartLocation(int& subId, double pcoords[3]); 00086 00090 void SetStartPosition(double x[3]); 00091 00095 void SetStartPosition(double x, double y, double z); 00096 00098 double *GetStartPosition(); 00099 00101 00102 void SetSource(vtkDataSet *source); 00103 vtkDataSet *GetSource(); 00105 00107 00108 vtkSetClampMacro(MaximumPropagationTime,double,0.0,VTK_DOUBLE_MAX); 00109 vtkGetMacro(MaximumPropagationTime,double); 00111 00113 00114 vtkSetClampMacro(IntegrationDirection,int, 00115 VTK_INTEGRATE_FORWARD,VTK_INTEGRATE_BOTH_DIRECTIONS); 00116 vtkGetMacro(IntegrationDirection,int); 00117 void SetIntegrationDirectionToForward() 00118 {this->SetIntegrationDirection(VTK_INTEGRATE_FORWARD);}; 00119 void SetIntegrationDirectionToBackward() 00120 {this->SetIntegrationDirection(VTK_INTEGRATE_BACKWARD);}; 00121 void SetIntegrationDirectionToIntegrateBothDirections() 00122 {this->SetIntegrationDirection(VTK_INTEGRATE_BOTH_DIRECTIONS);}; 00123 const char *GetIntegrationDirectionAsString(); 00125 00127 00129 vtkSetClampMacro(IntegrationStepLength,double,0.0000001,VTK_DOUBLE_MAX); 00130 vtkGetMacro(IntegrationStepLength,double); 00132 00134 00136 vtkSetMacro(SpeedScalars,int); 00137 vtkGetMacro(SpeedScalars,int); 00138 vtkBooleanMacro(SpeedScalars,int); 00140 00142 00147 vtkSetMacro(OrientationScalars, int); 00148 vtkGetMacro(OrientationScalars, int); 00149 vtkBooleanMacro(OrientationScalars, int); 00151 00153 00155 vtkSetClampMacro(TerminalSpeed,double,0.0,VTK_DOUBLE_MAX); 00156 vtkGetMacro(TerminalSpeed,double); 00158 00160 00165 vtkSetMacro(Vorticity,int); 00166 vtkGetMacro(Vorticity,int); 00167 vtkBooleanMacro(Vorticity,int); 00169 00170 vtkSetMacro( NumberOfThreads, int ); 00171 vtkGetMacro( NumberOfThreads, int ); 00172 00173 vtkSetMacro( SavePointInterval, double ); 00174 vtkGetMacro( SavePointInterval, double ); 00175 00177 00181 void SetIntegrator(vtkInitialValueProblemSolver *); 00182 vtkGetObjectMacro ( Integrator, vtkInitialValueProblemSolver ); 00184 00185 protected: 00187 00190 vtkStreamer(); 00191 ~vtkStreamer(); 00193 00194 // Integrate data 00195 void Integrate(vtkDataSet *input, vtkDataSet *source); 00196 00197 // Controls where streamlines start from (either position or location). 00198 int StartFrom; 00199 00200 // Starting from cell location 00201 vtkIdType StartCell; 00202 int StartSubId; 00203 double StartPCoords[3]; 00204 00205 // starting from global x-y-z position 00206 double StartPosition[3]; 00207 00208 // 00209 // Special classes for manipulating data 00210 // 00211 //BTX - begin tcl exclude 00212 // 00213 class StreamPoint { 00214 public: 00215 double x[3]; // position 00216 vtkIdType cellId; // cell 00217 int subId; // cell sub id 00218 double p[3]; // parametric coords in cell 00219 double v[3]; // velocity 00220 double speed; // velocity norm 00221 double s; // scalar value 00222 double t; // time travelled so far 00223 double d; // distance travelled so far 00224 double omega; // stream vorticity, if computed 00225 double theta; // rotation angle, if vorticity is computed 00226 }; 00227 00228 class StreamArray; 00229 friend class StreamArray; 00230 class StreamArray { //;prevent man page generation 00231 public: 00232 StreamArray(); 00233 ~StreamArray() 00234 { 00235 if (this->Array) 00236 { 00237 delete [] this->Array; 00238 } 00239 }; 00240 vtkIdType GetNumberOfPoints() {return this->MaxId + 1;}; 00241 StreamPoint *GetStreamPoint(vtkIdType i) {return this->Array + i;}; 00242 vtkIdType InsertNextStreamPoint() 00243 { 00244 if ( ++this->MaxId >= this->Size ) 00245 { 00246 this->Resize(this->MaxId); 00247 } 00248 return this->MaxId; //return offset from array 00249 } 00250 StreamPoint *Resize(vtkIdType sz); //reallocates data 00251 void Reset() {this->MaxId = -1;}; 00252 00253 StreamPoint *Array; // pointer to data 00254 vtkIdType MaxId; // maximum index inserted thus far 00255 vtkIdType Size; // allocated size of data 00256 vtkIdType Extend; // grow array by this amount 00257 double Direction; // integration direction 00258 }; 00259 //ETX 00260 // 00261 00262 //array of streamers 00263 StreamArray *Streamers; 00264 vtkIdType NumberOfStreamers; 00265 00266 // length of Streamer is generated by time, or by MaximumSteps 00267 double MaximumPropagationTime; 00268 00269 // integration direction 00270 int IntegrationDirection; 00271 00272 // the length (fraction of cell size) of integration steps 00273 double IntegrationStepLength; 00274 00275 // boolean controls whether vorticity is computed 00276 int Vorticity; 00277 00278 // terminal propagation speed 00279 double TerminalSpeed; 00280 00281 // boolean controls whether data scalars or velocity magnitude are used 00282 int SpeedScalars; 00283 00284 // boolean controls whether data scalars or vorticity orientation are used 00285 int OrientationScalars; 00286 00287 // Prototype showing the integrator type to be set by the user. 00288 vtkInitialValueProblemSolver* Integrator; 00289 00290 // Interval with which the stream points will be stored. 00291 // Useful in reducing the memory footprint. Since the initial 00292 // value is small, by default, it will store all/most points. 00293 double SavePointInterval; 00294 00295 static VTK_THREAD_RETURN_TYPE ThreadedIntegrate( void *arg ); 00296 00298 00300 vtkGetMacro( NumberOfStreamers, int ); 00301 StreamArray *GetStreamers() { return this->Streamers; }; 00303 00304 void InitializeThreadedIntegrate(); 00305 vtkMultiThreader *Threader; 00306 int NumberOfThreads; 00307 00308 virtual int FillInputPortInformation(int port, vtkInformation *info); 00309 00310 private: 00311 vtkStreamer(const vtkStreamer&); // Not implemented. 00312 void operator=(const vtkStreamer&); // Not implemented. 00313 }; 00314 00316 inline const char *vtkStreamer::GetIntegrationDirectionAsString() 00317 { 00318 if ( this->IntegrationDirection == VTK_INTEGRATE_FORWARD ) 00319 { 00320 return "IntegrateForward"; 00321 } 00322 else if ( this->IntegrationDirection == VTK_INTEGRATE_BACKWARD ) 00323 { 00324 return "IntegrateBackward"; 00325 } 00326 else 00327 { 00328 return "IntegrateBothDirections"; 00329 } 00330 } 00331 00332 #endif