vtkPolarAxesActor.cxx 32.9 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkPolarAxesActor.cxx

  Copyright (c) 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.

 =========================================================================*/
#include "vtkPolarAxesActor.h"

17
#include "vtkArcSource.h"
18
19
20
#include "vtkAxisActor.h"
#include "vtkAxisFollower.h"
#include "vtkCamera.h"
21
#include "vtkCellArray.h"
22
23
24
25
#include "vtkCoordinate.h"
#include "vtkFollower.h"
#include "vtkMath.h"
#include "vtkObjectFactory.h"
26
27
#include "vtkPolyData.h"
#include "vtkPolyDataMapper.h"
28
29
#include "vtkProperty.h"
#include "vtkStringArray.h"
30
#include "vtkTextProperty.h"
31
32
#include "vtkViewport.h"

33
#include <vtksys/ios/sstream>
34

35
#define VTK_POLAR_AXES_ACTOR_RTOL ( 1. - 10. * VTK_DBL_EPSILON )
36

37
38
vtkStandardNewMacro(vtkPolarAxesActor);
vtkCxxSetObjectMacro(vtkPolarAxesActor, Camera,vtkCamera);
39
40
vtkCxxSetObjectMacro(vtkPolarAxesActor,PolarAxisLabelTextProperty,vtkTextProperty);
vtkCxxSetObjectMacro(vtkPolarAxesActor,PolarAxisTitleTextProperty,vtkTextProperty);
41

Aashish Chaudhary's avatar
Aashish Chaudhary committed
42
//-----------------------------------------------------------------------------
Philippe Pébay's avatar
Philippe Pébay committed
43
void vtkPolarAxesActor::PrintSelf( ostream& os, vtkIndent indent )
44
{
Philippe Pébay's avatar
Philippe Pébay committed
45
  this->Superclass::PrintSelf( os,indent );
46

47
48
  os << indent << "Bounds: \n";
  os << indent << "  Xmin,Xmax: (" << this->Bounds[0] << ", "
49
     << this->Bounds[1] << ")\n";
50
  os << indent << "  Ymin,Ymax: (" << this->Bounds[2] << ", "
51
     << this->Bounds[3] << ")\n";
52
  os << indent << "  Zmin,Zmax: (" << this->Bounds[4] << ", "
53
     << this->Bounds[5] << ")\n";
54

55
  os << indent << "ScreenSize: " << this->ScreenSize << "\n";
Philippe Pébay's avatar
Philippe Pébay committed
56

57
58
  os << indent << "Number Of Radial Axes: " << this->NumberOfRadialAxes << endl;
  os << indent << "Number Of Polar Axis Ticks: " << this->NumberOfPolarAxisTicks << endl;
59
60
  os << indent << "Auto Subdivide Polar Axis: "
     << ( this->AutoSubdividePolarAxis ? "On\n" : "Off\n" );
61

Aashish Chaudhary's avatar
Aashish Chaudhary committed
62
  os << indent << "Pole: ("
63
64
     << this->Pole[0] << ", "
     << this->Pole[1] << ", "
65
     << this->Pole[2] << ")\n";
66

67
68
69
70
71
  os << indent << "Maximum Radius: " << this->MaximumRadius << endl;
  os << indent << "Auto-Scale Radius: " << this->AutoScaleRadius << endl;
  os << indent << "Minimum Angle: " << this->MinimumAngle << endl;
  os << indent << "Maximum Angle: " << this->MaximumAngle << endl;
  os << indent << "Smallest Visible Polar Angle: " << this->SmallestVisiblePolarAngle << endl;
Philippe Pébay's avatar
Philippe Pébay committed
72
73
  os << indent << "Radial Units (degrees): "
     << ( this->RadialUnits ? "On\n" : "Off\n" ) << endl;
74

Philippe Pébay's avatar
Philippe Pébay committed
75
  if ( this->Camera )
76
77
    {
    os << indent << "Camera:\n";
Philippe Pébay's avatar
Philippe Pébay committed
78
    this->Camera->PrintSelf( os,indent.GetNextIndent() );
79
80
81
82
83
84
    }
  else
    {
    os << indent << "Camera: (none)\n";
    }

Philippe Pébay's avatar
Philippe Pébay committed
85
86
  os << indent << "EnableDistanceLOD: "   
     << ( this->EnableDistanceLOD ? "On" : "Off" ) << endl;
87
  os << indent << "DistanceLODThreshold: "   << this->DistanceLODThreshold    << "\n";
Philippe Pébay's avatar
Philippe Pébay committed
88

89
90
  os << indent << "EnableViewAngleLOD: "   
     << ( this->EnableViewAngleLOD ? "On" : "Off" ) << endl;
91
  os << indent << "ViewAngleLODThreshold: "   << this->ViewAngleLODThreshold    << "\n";
92

Philippe Pébay's avatar
Philippe Pébay committed
93
  os << indent << "Polar Axis Title: " << this->PolarAxisTitle << "\n";
94
  os << indent << "Polar Label Format: " << this->PolarLabelFormat << "\n";
Philippe Pébay's avatar
Philippe Pébay committed
95
96
  os << indent << "PolarAxisLabelTextProperty: " << this->PolarAxisLabelTextProperty << endl;
  os << indent << "PolarAxisTitleTextProperty: " << this->PolarAxisTitleTextProperty << endl;
97
98
99
100
101
102
103
104
  os << indent << "Polar Axis Visibility: "
     << ( this->PolarAxisVisibility ? "On\n" : "Off\n" );
  os << indent << "Polar Title Visibility: "
     << ( this->PolarTitleVisibility ? "On" : "Off" ) << endl;
  os << indent << "Polar Label Visibility: "
     << ( this->PolarLabelVisibility ? "On" : "Off" ) << endl;
  os << indent << "Polar Tick Visibility: "
     << ( this->PolarTickVisibility ? "On" : "Off" ) << endl;
105
106

  os << indent << "Radial Axes Visibility: "
107
     << ( this->RadialAxesVisibility ? "On\n" : "Off\n" );
108
109
  os << indent << "Radial Title Visibility: "
     << ( this->RadialTitleVisibility ? "On" : "Off" ) << endl;
110

111
112
  os << indent << "Polar Arcs Visibility: "
     << ( this->PolarArcsVisibility ? "On" : "Off" ) << endl;
113
114
}

Aashish Chaudhary's avatar
Aashish Chaudhary committed
115
//-----------------------------------------------------------------------------
116
117
vtkPolarAxesActor::vtkPolarAxesActor() : vtkActor()
{
118
119
120
121
122
  // Default bounds
  this->Bounds[0] = -1.0; this->Bounds[1] = 1.0;
  this->Bounds[2] = -1.0; this->Bounds[3] = 1.0;
  this->Bounds[4] = -1.0; this->Bounds[5] = 1.0;

123
  // Default pole coordinates
124
125
126
  this->Pole[0] = 0.;
  this->Pole[1] = 0.;
  this->Pole[2] = 0.;
127

128
  // Default number of radial axes
129
  this->NumberOfRadialAxes = VTK_DEFAULT_NUMBER_OF_RADIAL_AXES;
130

131
132
133
134
  // Invalid default number of polar arcs, and auto-calculate by default
  this->NumberOfPolarAxisTicks = -1;
  this->AutoSubdividePolarAxis = true;

135
  // Default maximum polar radius
136
  this->MaximumRadius = 1.;
137

138
139
140
  // Do not auto-scale radius by default
  this->AutoScaleRadius = false;

141
142
143
  // Default minimum polar angle
  this->MinimumAngle = 0.;

144
  // Default maximum polar angle
145
  this->MaximumAngle = 90.;
146

147
148
149
  // Default smallest radial angle distinguishable from polar axis
  this->SmallestVisiblePolarAngle = .5;

150
  // By default show angle units (degrees)
151
  this->RadialUnits = true;
152
153
154

  this->Camera = NULL;

155
  // Default text screen size
156
157
  this->ScreenSize = 10.0;

158
159
  // Screen offset for labels
  // Pivot point at center of the geometry hence this->ScreenSize * 0.5
Philippe Pébay's avatar
Philippe Pébay committed
160
  this->LabelScreenOffset = 15.0 + this->ScreenSize * 0.5;
161

162
  // Text properties of polar axis title and labels, with default color white
163
164
165
  // Properties of the radial axes, with default color black
  this->PolarAxisProperty = vtkProperty::New();
  this->PolarAxisProperty->SetColor( 0., 0., 0. );
Philippe Pébay's avatar
Philippe Pébay committed
166
  this->PolarAxisTitleTextProperty = vtkTextProperty::New();
167
  this->PolarAxisTitleTextProperty->SetColor( 1., 1. ,1. );
Philippe Pébay's avatar
Philippe Pébay committed
168
169
  this->PolarAxisTitleTextProperty->SetFontFamilyToArial();
  this->PolarAxisLabelTextProperty = vtkTextProperty::New();
170
  this->PolarAxisLabelTextProperty->SetColor( 1., 1. ,1. );
Philippe Pébay's avatar
Philippe Pébay committed
171
172
  this->PolarAxisLabelTextProperty->SetFontFamilyToArial();

173
174
175
176
177
178
179
  // Create and set polar axis of type X
  this->PolarAxis = vtkAxisActor::New();
  this->PolarAxis->SetAxisTypeToX();
  this->PolarAxis->SetAxisPositionToMinMax();
  this->PolarAxis->SetCalculateTitleOffset( 0 );
  this->PolarAxis->SetCalculateLabelOffset( 0 );

180
  // Default distance LOD settings
181
182
183
  this->EnableDistanceLOD = 1;
  this->DistanceLODThreshold = .7;

184
  // Default view angle LOD settings
185
186
187
  this->EnableViewAngleLOD = 1;
  this->ViewAngleLODThreshold = .3;

188
189
190
191
  // Properties of the radial axes, with default color black
  this->RadialAxesProperty = vtkProperty::New();
  this->RadialAxesProperty->SetColor( 0., 0., 0. );

192
193
  // Create and set radial axes of type X
  this->CreateRadialAxes();
194

195
  // Create and set polar arcs and ancillary objects, with default color white
196
197
198
199
200
  this->PolarArcs = vtkPolyData::New();
  this->PolarArcsMapper = vtkPolyDataMapper::New();
  this->PolarArcsMapper->SetInput( this->PolarArcs );
  this->PolarArcsActor = vtkActor::New();
  this->PolarArcsActor->SetMapper( this->PolarArcsMapper );
201
  this->PolarArcsActor->GetProperty()->SetColor( 1., 1., 1. );
202

203
  // Default title for polar axis (sometimes also called "Radius")
204
205
  this->PolarAxisTitle = new char[16];
  sprintf(this->PolarAxisTitle, "%s", "Radial Distance");
206
207
  this->PolarLabelFormat = new char[8];
  sprintf( this->PolarLabelFormat, "%s", "%-#6.3g" );
208

209
210
211
212
213
214
215
216
217
218
219
220
  // By default all polar axis features are visible
  this->PolarAxisVisibility = 1;
  this->PolarTitleVisibility = 1;
  this->PolarLabelVisibility = 1;
  this->PolarTickVisibility = 1;

  // By default all radial axes features are visible
  this->RadialAxesVisibility = 1;
  this->RadialTitleVisibility = 1;

  // By default polar arcs are visible
  this->PolarArcsVisibility = 1;
221

222
223
224
225
226
227
  // Default title scale
  this->TitleScale = -1.;

  // Default label scale
  this->LabelScale = -1.;

228
229
230
231
232
  this->RenderCount = 0;

  this->RenderSomething = 0;
}

Aashish Chaudhary's avatar
Aashish Chaudhary committed
233
//-----------------------------------------------------------------------------
234
235
236
237
vtkPolarAxesActor::~vtkPolarAxesActor()
{
  this->SetCamera( NULL );

238
239
240
241
242
  if ( this->PolarAxisProperty )
    {
    this->PolarAxisProperty->Delete();
    }

Philippe Pébay's avatar
Philippe Pébay committed
243
  if ( this->RadialAxesProperty )
244
245
246
247
    {
    this->RadialAxesProperty->Delete();
    }

248
  if ( this->PolarLabelFormat )
249
    {
250
251
    delete [] this->PolarLabelFormat;
    this->PolarLabelFormat = NULL;
252
    }
Philippe Pébay's avatar
Philippe Pébay committed
253

Philippe Pébay's avatar
Philippe Pébay committed
254
  if ( this->PolarAxisTitle )
255
256
257
258
259
    {
    delete [] this->PolarAxisTitle;
    this->PolarAxisTitle = NULL;
    }

Philippe Pébay's avatar
Philippe Pébay committed
260
261
262
263
264
265
266
267
268
269
270
271
  if ( this->PolarAxisTitleTextProperty )
    {
    this->PolarAxisTitleTextProperty->Delete();
    this->PolarAxisTitleTextProperty = NULL;
    }

  if ( this->PolarAxisLabelTextProperty )
    {
    this->PolarAxisLabelTextProperty->Delete();
    this->PolarAxisLabelTextProperty = NULL;
    }

272
273
274
275
276
277
  if ( this->PolarAxis )
    {
    this->PolarAxis->Delete();
    this->PolarAxis = NULL;
    }

Philippe Pébay's avatar
Philippe Pébay committed
278
279
  if ( this->RadialAxes )
    {
280
    for ( int i = 0; i < this->NumberOfRadialAxes; ++ i )
Philippe Pébay's avatar
Philippe Pébay committed
281
282
283
284
285
286
287
288
289
290
      {
      if ( this->RadialAxes[i] )
        {
        this->RadialAxes[i]->Delete();
        this->RadialAxes[i] = NULL;
        }
      }
    delete [] this->RadialAxes;
    this->RadialAxes = NULL;
    }
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307

  if (this->PolarArcs)
    {
    this->PolarArcs->Delete();
    this->PolarArcs = NULL;
    }
  if (this->PolarArcsMapper)
    {
    this->PolarArcsMapper->Delete();
    this->PolarArcsMapper = NULL;
    }
  if (this->PolarArcsActor)
    {
    this->PolarArcsActor->Delete();
    this->PolarArcsActor = NULL;
    }

308
309
}

Aashish Chaudhary's avatar
Aashish Chaudhary committed
310
//-----------------------------------------------------------------------------
Philippe Pébay's avatar
Philippe Pébay committed
311
int vtkPolarAxesActor::RenderOpaqueGeometry( vtkViewport *viewport )
312
313
{
  // Initialization
314
  int renderedSomething = 0;
315
  if ( !this->Camera )
316
317
318
    {
    vtkErrorMacro( <<"No camera!" );
    this->RenderSomething = 0;
319
    return renderedSomething;
320
321
322
323
    }

  this->BuildAxes( viewport );

324
325
326
327
328
329
330
  // Render the polar axis
  if ( this->PolarAxisVisibility )
    {
    renderedSomething += this->PolarAxis->RenderOpaqueGeometry( viewport );
    }

  // Render the radial axes
331
332
333
334
  if ( this->RadialAxesVisibility )
    {
    for ( int i = 0; i < this->NumberOfRadialAxes; ++ i )
      {
335
      renderedSomething += this->RadialAxes[i]->RenderOpaqueGeometry( viewport );
336
337
338
      }
    }

339
340
341
342
343
344
  // Render the polar arcs
  if ( this->PolarArcsVisibility )
    {
    renderedSomething += this->PolarArcsActor->RenderOpaqueGeometry(viewport);
    }

345
346
347
  return renderedSomething;
}

Aashish Chaudhary's avatar
Aashish Chaudhary committed
348
//-----------------------------------------------------------------------------
Philippe Pébay's avatar
Philippe Pébay committed
349
void vtkPolarAxesActor::SetScreenSize( double screenSize )
350
351
{
  this->ScreenSize = screenSize;
352
353
  // Considering pivot point at center of the geometry,
  // hence ( this->ScreenSize * 0.5 ).
Philippe Pébay's avatar
Philippe Pébay committed
354
  this->LabelScreenOffset = 15.0 + this->ScreenSize * 0.5;
355

356
357
358
  vtkAxisFollower** labelActors = this->PolarAxis->GetLabelActors();
  int numberOfLabels = this->PolarAxis->GetNumberOfLabelsBuilt();
  for( int i = 0; i < numberOfLabels; ++ i )
359
    {
360
    labelActors[i]->SetScreenOffset( this->LabelScreenOffset );
361
362
363
364
365
    }

  this->Modified();
}

Aashish Chaudhary's avatar
Aashish Chaudhary committed
366
//-----------------------------------------------------------------------------
Philippe Pébay's avatar
Philippe Pébay committed
367
void vtkPolarAxesActor::ReleaseGraphicsResources( vtkWindow *win )
368
{
369
  this->PolarAxis->ReleaseGraphicsResources(win);
370
  for ( int i = 0; i < this->NumberOfRadialAxes;  ++ i )
371
    {
Philippe Pébay's avatar
Philippe Pébay committed
372
    this->RadialAxes[i]->ReleaseGraphicsResources( win );
373
    }
374
  this->PolarArcsActor->ReleaseGraphicsResources( win );
375
376
}

377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
//-----------------------------------------------------------------------------
void vtkPolarAxesActor::CalculateBounds()
{
  // Fetch angles, at this point it is already known that angular sector <= 360.
  double minAngle = this->MinimumAngle;
  double maxAngle = this->MaximumAngle;

  // Ensure that angles are not both < -180 nor both > 180 degrees
  if ( maxAngle < -180. )
    {
    // Increment angles modulo 360 degrees
    minAngle += 360.;
    maxAngle += 360.;
    }
  else if ( minAngle > 180. )
    {
    // Decrement angles modulo 360 degrees
    minAngle -= 360.;
    maxAngle -= 360.;
    }

  // Prepare trigonometric quantities
  double thetaMin = vtkMath::RadiansFromDegrees( minAngle );
  double cosThetaMin = cos( thetaMin );
  double sinThetaMin = sin( thetaMin );
  double thetaMax = vtkMath::RadiansFromDegrees( maxAngle );
  double cosThetaMax = cos( thetaMax );
  double sinThetaMax = sin( thetaMax );

  // Calculate extremal cosines across angular sector
  double minCos;
  double maxCos;
  if ( minAngle * maxAngle < 0. )
    {
    // Angular sector contains null angle
    maxCos = 1.;
    if ( minAngle < 180. && maxAngle > 180. )
      {
      // Angular sector also contains flat angle
      minCos = -1.;
      }
    else
      {
      // Angular sector does not contain flat angle
      minCos = cosThetaMin < cosThetaMax ? cosThetaMin : cosThetaMax;
      }

    }
  else if ( minAngle < 180. && maxAngle > 180. )
    {
    // Angular sector does not contain flat angle (and not null angle)
    minCos = -1.;
    maxCos = cosThetaMax > cosThetaMin ? cosThetaMax : cosThetaMin;
    }
  else
    {
    // Angular sector does not contain flat nor null angle
    minCos = cosThetaMin < cosThetaMax ? cosThetaMin : cosThetaMax;
    maxCos = cosThetaMax > cosThetaMin ? cosThetaMax : cosThetaMin;
    }

  // Calculate extremal sines across angular sector
  double minSin;
  double maxSin;
  if ( minAngle < -90. && maxAngle > -90. )
    {
    // Angular sector contains negative right angle
    minSin = -1.;
    if ( minAngle < 90. && maxAngle > 90. )
      {
      // Angular sector also contains positive right angle
      maxSin = 1.;
      }
    else
      {
      // Angular sector contain does not contain positive right angle
      maxSin = sinThetaMax > sinThetaMin ? sinThetaMax : sinThetaMin;
      }
    }
  else if ( minAngle < 90. && maxAngle > 90. )
    {
    // Angular sector contains positive right angle (and not negative one)
    minSin = sinThetaMin < sinThetaMax ? sinThetaMin : sinThetaMax;
    maxSin = 1.;
    }
  else
    {
    // Angular sector contain does not contain either right angle
    minSin = sinThetaMin < sinThetaMax ? sinThetaMin : sinThetaMax;
    maxSin = sinThetaMax > sinThetaMin ? sinThetaMax : sinThetaMin;
    }

  // Now calculate bounds
  // xmin
  this->Bounds[0] = this->Pole[0] + this->MaximumRadius * minCos;
  // xmax
  this->Bounds[1] = this->Pole[0] + this->MaximumRadius * maxCos;
  // ymin
  this->Bounds[2] = this->Pole[1] + this->MaximumRadius * minSin;
  // ymax
  this->Bounds[3] = this->Pole[1] + this->MaximumRadius * maxSin;
  // zmin
  this->Bounds[4] = this->Pole[2];
  // zmax
  this->Bounds[5] = this->Pole[2];
482
483
484

  // Update modification time of bounds
  this->BoundsMTime.Modified();
485
486
}

Aashish Chaudhary's avatar
Aashish Chaudhary committed
487
//-----------------------------------------------------------------------------
Philippe Pébay's avatar
Philippe Pébay committed
488
void vtkPolarAxesActor::GetBounds( double bounds[6])
489
{
Philippe Pébay's avatar
Philippe Pébay committed
490
  for ( int i=0; i< 6; i++)
491
492
493
494
495
    {
    bounds[i] = this->Bounds[i];
    }
}

Aashish Chaudhary's avatar
Aashish Chaudhary committed
496
//-----------------------------------------------------------------------------
Philippe Pébay's avatar
Philippe Pébay committed
497
void vtkPolarAxesActor::GetBounds( double& xmin, double& xmax,
498
499
                                   double& ymin, double& ymax,
                                   double& zmin, double& zmax )
500
501
502
503
504
505
506
507
508
{
  xmin = this->Bounds[0];
  xmax = this->Bounds[1];
  ymin = this->Bounds[2];
  ymax = this->Bounds[3];
  zmin = this->Bounds[4];
  zmax = this->Bounds[5];
}

Aashish Chaudhary's avatar
Aashish Chaudhary committed
509
//-----------------------------------------------------------------------------
510
511
512
513
514
double *vtkPolarAxesActor::GetBounds()
{
  return this->Bounds;
}

Aashish Chaudhary's avatar
Aashish Chaudhary committed
515
//-----------------------------------------------------------------------------
Philippe Pébay's avatar
Philippe Pébay committed
516
void vtkPolarAxesActor::BuildAxes( vtkViewport *viewport )
517
{
518
  if ( ( this->GetMTime() < this->BuildTime.GetMTime() ) )
519
    {
Philippe Pébay's avatar
Philippe Pébay committed
520
    this->AutoScale( viewport );
521
522
523
    return;
    }

524
  if ( this->MaximumAngle < this->MinimumAngle )
525
526
527
528
529
    {
    // Incorrect angle input
    vtkWarningMacro( << "Cannot draw radial axes: "
                     << " minimum angle = "
                     << this->MinimumAngle
530
531
532
533
534
535
                     << " > maximum angle = "
                     << this->MaximumAngle
                     << ".");
    return;
    }
  
536
  if ( this->MaximumAngle - this->MinimumAngle > 360. )
537
538
539
540
541
542
    {
    // Incorrect angle input
    vtkWarningMacro( << "Cannot draw radial axes: "
                     << " angular sector = "
                     << this->MaximumAngle - this->MinimumAngle
                     << " > 360 deg." );
543
544
545
    return;
    }
  
546
  // Determine the bounds
547
548
  this->CalculateBounds();
  
549
550
  // Set polar axis endpoints
  vtkAxisActor* axis = this->PolarAxis;
551
552
553
  double ox = this->Pole[0] + this->MaximumRadius;
  axis->GetPoint1Coordinate()->SetValue( this->Pole[0], this->Pole[1], this->Pole[2] );
  axis->GetPoint2Coordinate()->SetValue( ox, this->Pole[1], this->Pole[2] );
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568

  // Set common axis attributes
  this->SetCommonAxisAttributes( axis );

  // Set polar axis lines
  axis->SetAxisVisibility( this->PolarAxisVisibility );
  axis->SetAxisLinesProperty( this->PolarAxisProperty );

  // Set polar axis title
  axis->SetTitleVisibility( this->PolarTitleVisibility );
  axis->SetTitle( this->PolarAxisTitle );
  axis->SetTitleTextProperty( this->PolarAxisTitleTextProperty );

  // Set polar axis ticks (major only)
  axis->SetTickVisibility( this->PolarTickVisibility );
569
  axis->SetTickLocation( VTK_TICKS_BOTH );
570
571
572
573
574
575
  axis->SetMajorTickSize( .02 * this->MaximumRadius );
  
  // Set polar axis labels
  axis->SetLabelVisibility( this->PolarLabelVisibility );
  axis->SetLabelTextProperty( this->PolarAxisLabelTextProperty );

576
577
578
579
580
581
582
583
584
  // Build radial axes
  this->BuildRadialAxes();

  // Build polar axis ticks
  this->BuildPolarAxisTicks( this->Pole[0] );

  // Build polar axis labels
  this->BuildPolarAxisLabelsArcs();

585
586
587
  // Build polar axis
  this->PolarAxis->BuildAxis( viewport, true );

588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
  // Scale appropriately
  this->AutoScale( viewport );

  this->RenderSomething = 1;
  this->BuildTime.Modified();
}

//-----------------------------------------------------------------------------
void vtkPolarAxesActor::SetCommonAxisAttributes( vtkAxisActor* axis )
{
  vtkProperty *prop = this->GetProperty();
  prop->SetAmbient( 1.0 );
  prop->SetDiffuse( 0.0 );
  axis->SetProperty( prop );

  // Common space and range attributes
  axis->SetCamera( this->Camera );
  axis->SetBounds( this->Bounds );
  axis->SetRange( 0., this->MaximumRadius );

  // No minor ticks for any kind of axes
  axis->SetMinorTicksVisible( 0 );
}

//-----------------------------------------------------------------------------
inline double vtkPolarAxesActor::FFix( double value )
{
  int ivalue = static_cast<int>( value );
  return ivalue;
}

//-----------------------------------------------------------------------------
inline double vtkPolarAxesActor::FSign( double value, double sign )
{
  value = fabs( value );
  if ( sign < 0.)
    {
    value *= -1.;
    }
  return value;
}

630
//-----------------------------------------------------------------------------
631
void vtkPolarAxesActor::CreateRadialAxes()
632
{
633
  // Create requested number of radial axes
634
635
636
637
638
639
640
641
642
643
  this->RadialAxes = new vtkAxisActor*[this->NumberOfRadialAxes];
  for ( int i = 0; i < this->NumberOfRadialAxes; ++ i )
    {
    // Create axis of type X
    this->RadialAxes[i] = vtkAxisActor::New();
    vtkAxisActor* axis = this->RadialAxes[i];
    axis->SetAxisTypeToX();
    axis->SetAxisPositionToMinMax();
    axis->SetCalculateTitleOffset( 0 );
    axis->SetCalculateLabelOffset( 0 );
644
645
    }
  cerr << this->RadialAxes[0]->GetTitleActor()->GetDistanceLODThreshold() << endl;
646
647
}

648
649
650
//-----------------------------------------------------------------------------
void vtkPolarAxesActor::BuildRadialAxes()
{
651
652
653
  // Base offset for radial axis title followers
  double offset = .67 * ( this->LabelScreenOffset + this->ScreenSize * 0.5 );

654
655
656
657
658
  // Create requested number of radial axes
  double dAlpha = 
    ( this->MaximumAngle  - this->MinimumAngle ) / ( this->NumberOfRadialAxes - 1. );
  double alpha = this->MinimumAngle;
  for ( int i = 0; i < this->NumberOfRadialAxes;  ++ i, alpha += dAlpha )
659
    {
660
661
    // Calculate endpoint coordinates
    double alphaRad = vtkMath::RadiansFromDegrees( alpha );
662
663
    double x = this->Pole[0] + this->MaximumRadius * cos( alphaRad );
    double y = this->Pole[1] + this->MaximumRadius * sin( alphaRad );
664
665

    // Set radial axis endpoints
666
    vtkAxisActor* axis = this->RadialAxes[i];
667
668
    axis->GetPoint1Coordinate()->SetValue( this->Pole[0], this->Pole[1], this->Pole[2] );
    axis->GetPoint2Coordinate()->SetValue( x, y, this->Pole[2] );
Philippe Pébay's avatar
Philippe Pébay committed
669

670
671
    // Set common axis attributes
    this->SetCommonAxisAttributes( axis );
672

673
674
675
    // Set radial axis lines
    axis->SetAxisVisibility( this->RadialAxesVisibility );
    axis->SetAxisLinesProperty( this->RadialAxesProperty );
676

677
    // Set radial axis title with polar angle as title for non-polar axes
678
679
680
681
    if ( this->PolarAxisVisibility && fabs( alpha ) < 2. )
      { 
      // Prevent conflict between radial and polar axes titles
      axis->SetTitleVisibility( false );
682
683
684
685
686
687

      if ( fabs( alpha ) < this->SmallestVisiblePolarAngle )
        { 
        // Do not show radial axes too close to polar axis
        axis->SetAxisVisibility( false );
        }
688
689
690
691
692
693
694
695
696
697
      }
    else
      {
      // Use polar angle as a title for the radial axis
      axis->SetTitleVisibility( this->RadialTitleVisibility );
      axis->GetTitleTextProperty()->SetColor( this->RadialAxesProperty->GetColor() );
      vtksys_ios::ostringstream title;
      title << alpha
            << ( this->RadialUnits ? " deg" : "" );
      axis->SetTitle( title.str().c_str() );
698

699
700
701
702
703
704
705
      // Update axis title followers
      axis->GetTitleActor()->SetAxis( axis );
      axis->GetTitleActor()->SetScreenOffset( offset );
      axis->GetTitleActor()->SetEnableDistanceLOD( this->EnableDistanceLOD );
      axis->GetTitleActor()->SetDistanceLODThreshold( this->DistanceLODThreshold );
      axis->GetTitleActor()->SetEnableViewAngleLOD( this->EnableViewAngleLOD );
      axis->GetTitleActor()->SetViewAngleLODThreshold( this->ViewAngleLODThreshold );
706
      }
707
708
709
710

    // No labels nor ticks for radial axes
    axis->SetLabelVisibility( 0 );
    axis->SetTickVisibility( 0 );
711
    }
712
713
}

Aashish Chaudhary's avatar
Aashish Chaudhary committed
714
//-----------------------------------------------------------------------------
715
void vtkPolarAxesActor::BuildPolarAxisTicks( double x0 )
716
{
717
  double delta;
718

719
720
721
  if ( this->AutoSubdividePolarAxis
       || this->NumberOfPolarAxisTicks < 0
       || this->NumberOfPolarAxisTicks > VTK_MAXIMUM_NUMBER_OF_POLAR_AXIS_TICKS )
722
    {
723
724
    // Programatically figure the number of divisions of the polar axis
    double pow10 = log10( this->MaximumRadius );
725

726
727
728
729
730
731
    // Build in numerical tolerance
    if ( pow10 != 0.)
      {
      double eps = 10.0e-10;
      pow10 = this->FSign( ( fabs( pow10 ) + eps ), pow10 );
      }
732

733
734
735
736
737
    // FFix will move in the wrong direction if pow10 is negative.
    if ( pow10 < 0.)
      {
      pow10 = pow10 - 1.;
      }
738

739
740
741
742
743
744
    // Find the number of integral points in the interval.
    delta = pow( 10., this->FFix( pow10 ) );
    double fnt = this->MaximumRadius / delta;
    fnt  = this->FFix( fnt );
    int numTicks = fnt <= 0.5 ? 
      static_cast<int>( this->FFix( fnt ) ) : static_cast<int>( this->FFix( fnt ) + 1 );
745

746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
    // If not enough tick points in this decade, scale down
    double div = 1.;
    if ( numTicks < 5 )
      {
      div = 2.;
      }
    if ( numTicks <= 2 )
      {
      div = 5.;
      }
    if ( div != 1.)
      {
      delta /= div;
      }

    // Finally calculate number of tick points
    this->NumberOfPolarAxisTicks = 0;
    while ( delta * this->NumberOfPolarAxisTicks <= this->MaximumRadius )
      {
      ++ this->NumberOfPolarAxisTicks;
      }
    }
  else // if ( this->AutoSubdividePolarAxis || this->NumberOfPolarAxisTicks ... )
769
    {
770
771
    // Use pre-set number of arcs when it is valid and no auto-subdivision was requested
    delta =  this->MaximumRadius / ( this->NumberOfPolarAxisTicks - 1 );
772
    }
Philippe Pébay's avatar
Philippe Pébay committed
773

774
  // Set major start and delta corresponding to range and coordinates
775
776
777
  this->PolarAxis->SetMajorRangeStart( 0. );
  this->PolarAxis->SetDeltaRangeMajor( delta );
  this->PolarAxis->SetMajorStart( VTK_AXIS_TYPE_X, x0 );
778

779
  // Build in numerical robustness to avoid truncation errors at endpoint
780
  delta *= VTK_POLAR_AXES_ACTOR_RTOL;
781
  this->PolarAxis->SetDeltaMajor( VTK_AXIS_TYPE_X, delta );
782
783
}

Aashish Chaudhary's avatar
Aashish Chaudhary committed
784
//-----------------------------------------------------------------------------
785
void vtkPolarAxesActor::BuildPolarAxisLabelsArcs()
786
{
787
  // Prepare storage for polar axis labels
788
  vtkStringArray *labels = vtkStringArray::New();
789
  labels->SetNumberOfValues( this->NumberOfPolarAxisTicks );
790

791
  // Prepare trigonometric quantities
792
793
794
795
796
797
798
  double thetaMin = vtkMath::RadiansFromDegrees( this->MinimumAngle );
  double cosThetaMin = cos( thetaMin );
  double sinThetaMin = sin( thetaMin );
  double thetaMax = vtkMath::RadiansFromDegrees( this->MaximumAngle );
  double cosThetaMax = cos( thetaMax );
  double sinThetaMax = sin( thetaMax );
  double angularSector = this->MaximumAngle - this->MinimumAngle;
Aashish Chaudhary's avatar
Aashish Chaudhary committed
799
  vtkIdType arcResolution
800
    = static_cast<vtkIdType>( angularSector * VTK_POLAR_ARC_RESOLUTION_PER_DEG );
801

802
  // Arc points
803
  vtkPoints* polarArcsPoints = vtkPoints::New();
804
805
  this->PolarArcs->SetPoints( polarArcsPoints );
  polarArcsPoints->Delete();
806

807
  // Arc lines
808
  vtkCellArray* polarArcsLines = vtkCellArray::New();
809
810
811
  this->PolarArcs->SetLines( polarArcsLines );
  polarArcsLines->Delete();

812
  // Retreave label features
813
  vtkAxisActor* axis = this->PolarAxis;
814
815
816
817
  double delta = axis->GetDeltaMajor( VTK_AXIS_TYPE_X );
  double value = axis->GetMajorRangeStart();

  // Now create labels and polar arcs
818
  const char *format = this->PolarLabelFormat;
819
  char label[64];
820
  vtkIdType pointIdOffset = 0;
821
  for ( int  i = 0; i < this->NumberOfPolarAxisTicks; ++ i )
822
    {
823
    // Store label
824
    sprintf( label, format, value );
825
    labels->SetValue( i, label );
826

827
    // Build polar arcs for non-zero values
828
    if ( value  > 0. )
829
      {
830
      // Compute and set polar arc parameters
831
832
833
834
      double x1 = value * cosThetaMin;
      double y1 = value * sinThetaMin;
      double x2 = value * cosThetaMax;
      double y2 = value * sinThetaMax;
835
      vtkArcSource* arc = vtkArcSource::New();
836
837
838
      arc->SetCenter( this->Pole );
      arc->SetPoint1( this->Pole[0] + x1, this->Pole[1] + y1, this->Pole[2] );
      arc->SetPoint2( this->Pole[0] + x2, this->Pole[1] + y2, this->Pole[2] );
839
      arc->SetResolution( arcResolution );
840
      arc->SetNegative( angularSector > 180. );
841
      arc->Update();
Aashish Chaudhary's avatar
Aashish Chaudhary committed
842

843
844
845
846
847
848
849
850
851
852
      // Append new polar arc to existing ones
      vtkPoints* arcPoints = arc->GetOutput()->GetPoints();
      vtkIdType nPoints = arcResolution + 1;
      vtkIdType* arcPointIds = new vtkIdType[nPoints];
      for ( vtkIdType j = 0; j < nPoints; ++ j )
        {
        polarArcsPoints->InsertNextPoint( arcPoints->GetPoint( j ) );
        arcPointIds[j] = pointIdOffset + j;
        }
      polarArcsLines->InsertNextCell( nPoints, arcPointIds );
Aashish Chaudhary's avatar
Aashish Chaudhary committed
853

854
855
856
      // Clean up
      arc->Delete();
      delete [] arcPointIds;
Aashish Chaudhary's avatar
Aashish Chaudhary committed
857

858
859
      // Update polyline cell offset
      pointIdOffset += nPoints;
860
861
862
      }

    // Move to next value
863
    value += delta;
864
    }
865
866

  // Store labels
867
  this->PolarAxis->SetLabels( labels );
868
869

  // Clean up
870
  labels->Delete();
871

872
873
874
875
876
877
878
879
880
  // Update axis title follower
  vtkAxisFollower* follower = axis->GetTitleActor();
  follower->SetAxis( axis );
  follower->SetScreenOffset( 2. * this->LabelScreenOffset + this->ScreenSize + 5 );
  follower->SetEnableDistanceLOD( this->EnableDistanceLOD );
  follower->SetDistanceLODThreshold( this->DistanceLODThreshold );
  follower->SetEnableViewAngleLOD( this->EnableViewAngleLOD );
  follower->SetViewAngleLODThreshold( this->ViewAngleLODThreshold );

881
882
  // Update axis label followers
  vtkAxisFollower** labelActors = axis->GetLabelActors();
883
  for( int i = 0; i < this->NumberOfPolarAxisTicks; ++ i )
884
885
886
    {
    labelActors[i]->SetAxis( axis );
    labelActors[i]->SetScreenOffset( this->LabelScreenOffset );
887
    labelActors[i]->SetEnableDistanceLOD( this->EnableDistanceLOD );
888
889
890
    labelActors[i]->SetDistanceLODThreshold( this->DistanceLODThreshold );
    labelActors[i]->SetEnableViewAngleLOD( this->EnableViewAngleLOD );
    labelActors[i]->SetViewAngleLODThreshold( this->ViewAngleLODThreshold );
891
    }
892
893
}

Aashish Chaudhary's avatar
Aashish Chaudhary committed
894
//-----------------------------------------------------------------------------
895
896
897
void vtkPolarAxesActor::AutoScale( vtkViewport *viewport )
{

898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
  // Scale polar axis title
  vtkAxisActor* axis = this->PolarAxis;
  double newTitleScale
    = vtkAxisFollower::AutoScale( viewport, 
                                  this->Camera,
                                  this->ScreenSize, 
                                  axis->GetTitleActor()->GetPosition() );
  axis->SetTitleScale( newTitleScale );

  // Scale polar axis labels
  vtkAxisFollower** labelActors = axis->GetLabelActors();
  for( int i = 0; i < axis->GetNumberOfLabelsBuilt(); ++ i )
    {
    double newLabelScale 
      = vtkAxisFollower::AutoScale( viewport,
                                    this->Camera, 
                                    this->ScreenSize, 
                                    labelActors[i]->GetPosition() );
    labelActors[i]->SetScale( newLabelScale );
    }
918
919

  // Loop over radial axes
920
921
  for ( int i = 0; i < this->NumberOfRadialAxes; ++ i )
    {
922
    axis = this->RadialAxes[i];
923
    // Scale title
924
925
926
927
928
929
    newTitleScale 
      = vtkAxisFollower::AutoScale( viewport, 
                                    this->Camera,
                                    this->ScreenSize,
                                    axis->GetTitleActor()->GetPosition() );
    axis->SetTitleScale( newTitleScale );
930
    }
931
932
}

933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
//-----------------------------------------------------------------------------
void vtkPolarAxesActor::SetPole( double p[3] )
{
  this->Pole[0] = p[0];
  this->Pole[1] = p[1];
  this->Pole[2] = p[2];

  // Update bounds
  this->CalculateBounds();
  this->Modified();
}

//-----------------------------------------------------------------------------
void vtkPolarAxesActor::SetPole( double x, double y, double z )
{
  this->Pole[0] = x;
  this->Pole[1] = y;
  this->Pole[2] = z;

  // Update bounds
  this->CalculateBounds();
  this->Modified();
}

957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
//-----------------------------------------------------------------------------
void vtkPolarAxesActor::SetNumberOfRadialAxes( vtkIdType n )
{
  // Limit number of redial axes
  if ( n > VTK_MAXIMUM_NUMBER_OF_RADIAL_AXES )
    {
    n = VTK_MAXIMUM_NUMBER_OF_RADIAL_AXES;
    }

  // If number of radial axes does not change, do nothing
  if ( this->NumberOfRadialAxes == n )
    {
    return;
    }

  // Delete existing radial axes
  if ( this->RadialAxes )
    {
    for ( int i = 0; i < this->NumberOfRadialAxes; ++ i )
      {
      if ( this->RadialAxes[i] )
        {
        this->RadialAxes[i]->Delete();
        this->RadialAxes[i] = NULL;
        }
      }
Philippe Pébay's avatar
Philippe Pébay committed
983
984
    delete [] this->RadialAxes;
    this->RadialAxes = NULL;
985
986
987
988
    }

  // Create and set n radial axes of type X
  this->NumberOfRadialAxes = n;
989
  this->CreateRadialAxes();
990
991
992
993

  this->Modified();
}

994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
//-----------------------------------------------------------------------------
void vtkPolarAxesActor::SetMaximumRadius( double r )
{
  this->MaximumRadius = r > 0. ? r : 0.;

  // Update bounds
  this->CalculateBounds();
  this->Modified();
}

//-----------------------------------------------------------------------------
void vtkPolarAxesActor::SetMinimumAngle( double a )
{
  if ( a > 360. )
    {
    this->MinimumAngle = 360.;
    }
  else if ( a < -360. )
    {
    this->MinimumAngle = -360.;
    }
  else
    {
    this->MinimumAngle = a;
    }

  // Update bounds
  this->CalculateBounds();
  this->Modified();
}

//-----------------------------------------------------------------------------
void vtkPolarAxesActor::SetMaximumAngle( double a )
{
  if ( a > 360. )
    {
    this->MaximumAngle = 360.;
    }
  else if ( a < -360. )
    {
    this->MaximumAngle = -360.;
    }
  else
    {
    this->MaximumAngle = a;
    }

  // Update bounds
  this->CalculateBounds();
  this->Modified();
}

1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
//-----------------------------------------------------------------------------
void vtkPolarAxesActor::SetPolarAxisProperty( vtkProperty *prop )
{
  this->PolarAxisProperty->DeepCopy( prop );
  this->Modified();
}

//-----------------------------------------------------------------------------
vtkProperty* vtkPolarAxesActor::GetPolarAxisProperty()
{
  return this->PolarAxisProperty;
}

Aashish Chaudhary's avatar
Aashish Chaudhary committed
1059
//-----------------------------------------------------------------------------
Philippe Pébay's avatar
Philippe Pébay committed
1060
void vtkPolarAxesActor::SetRadialAxesProperty( vtkProperty *prop )
1061
{
Philippe Pébay's avatar
Philippe Pébay committed
1062
  this->RadialAxesProperty->DeepCopy( prop );
1063
1064
1065
  this->Modified();
}

Aashish Chaudhary's avatar
Aashish Chaudhary committed
1066
//-----------------------------------------------------------------------------
1067
1068
1069
1070
vtkProperty* vtkPolarAxesActor::GetRadialAxesProperty()
{
  return this->RadialAxesProperty;
}
1071

Aashish Chaudhary's avatar
Aashish Chaudhary committed
1072
//-----------------------------------------------------------------------------
1073
1074
1075
1076
1077
1078
void vtkPolarAxesActor::SetPolarArcsProperty( vtkProperty *prop )
{
  this->PolarArcsActor->SetProperty(prop);
  this->Modified();
}

Aashish Chaudhary's avatar
Aashish Chaudhary committed
1079
//-----------------------------------------------------------------------------
1080
1081
1082
1083
vtkProperty* vtkPolarAxesActor::GetPolarArcsProperty()
{
  return this->PolarArcsActor->GetProperty();
}