NorMIT-nav  16.5
An IGT application
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
cxGraphicalPrimitives.cpp
Go to the documentation of this file.
1 /*=========================================================================
2 This file is part of CustusX, an Image Guided Therapy Application.
3 
4 Copyright (c) 2008-2014, SINTEF Department of Medical Technology
5 All rights reserved.
6 
7 Redistribution and use in source and binary forms, with or without
8 modification, are permitted provided that the following conditions are met:
9 
10 1. Redistributions of source code must retain the above copyright notice,
11  this list of conditions and the following disclaimer.
12 
13 2. Redistributions in binary form must reproduce the above copyright notice,
14  this list of conditions and the following disclaimer in the documentation
15  and/or other materials provided with the distribution.
16 
17 3. Neither the name of the copyright holder nor the names of its contributors
18  may be used to endorse or promote products derived from this software
19  without specific prior written permission.
20 
21 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
25 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
27 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
28 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 =========================================================================*/
32 
33 #include "cxGraphicalPrimitives.h"
34 
35 #include "boost/bind.hpp"
36 #include <vtkSphereSource.h>
37 #include <vtkLineSource.h>
38 #include <vtkArcSource.h>
39 #include <vtkPolyDataMapper.h>
40 #include <vtkActor.h>
41 #include <vtkCellArray.h>
42 #include <vtkProperty.h>
43 #include <vtkRenderer.h>
44 #include <vtkCommand.h>
45 #include <vtkFollower.h>
46 #include <vtkVectorText.h>
47 #include <vtkCamera.h>
48 #include "cxTypeConversions.h"
49 #include "cxBoundingBox3D.h"
50 #include "vtkArrowSource.h"
51 #include "vtkMatrix4x4.h"
52 #include "vtkCaptionActor2D.h"
53 #include "vtkTextProperty.h"
54 #include "cxVtkHelperClasses.h"
55 #include "vtkPolyDataNormals.h"
56 
57 namespace cx
58 {
59 
60 
62 {
63  mProperty = vtkPropertyPtr::New();
64  mActor = vtkActorPtr::New();
65  mActor->SetProperty(mProperty);
66 }
67 
69 {
70  this->setRenderer(NULL);
71 }
72 
74 {
76  mSource = source;
77 
78  if (mSource)
79  getMapper()->SetInputConnection(mSource->GetOutputPort());
80  else
81  getMapper()->SetInputConnection(NULL);
82 }
83 
85 {
86  if (mRenderer)
87  mRenderer->RemoveActor(mActor);
88 
89  mRenderer = renderer;
90 
91  if (mRenderer)
92  mRenderer->AddActor(mActor);
93 }
94 
96 {
97  mActor->SetVisibility(visible);
98 }
99 
100 
102 {
103  mActor->GetProperty()->SetBackfaceCulling(val);
104 }
105 
107 {
108  mActor->GetProperty()->SetFrontfaceCulling(val);
109 }
110 
112 {
113  mActor->GetProperty()->SetRepresentationToSurface();
114 }
115 
116 void GraphicalGeometricBase::setColor(double red, double green, double blue)
117 {
118  mActor->GetProperty()->SetColor(red, green, blue);
119 }
120 
122 {
123  mActor->GetProperty()->SetColor(color.begin());
124 }
125 
127 {
128  mActor->SetPosition(point.begin());
129 }
130 
132 {
133  mActor->GetProperty()->SetOpacity(val);
134 }
135 
136 void GraphicalGeometricBase::setUserMatrix(vtkMatrix4x4 *matrix)
137 {
138  mActor->SetUserMatrix(matrix);
139 }
140 
142 {
143  if(pointSize<=0) return;
144  mProperty->SetPointSize(pointSize);
145 }
146 
148 {
149  if(show)
150  {
151  getMapper()->ScalarVisibilityOn();
152  }else
153  {
154  getMapper()->ScalarVisibilityOff();
155  }
156 }
157 
159 {
160  return Vector3D(mActor->GetPosition());
161 }
162 
164 {
165  return mActor;
166 }
167 
169 {
170  if (mSource)
171  return mSource->GetOutput();
172  else
173  return mData;
174 }
175 
177 {
178  return mSource;
179 }
180 
181 //--------------------------------------------------------
182 //--------------------------------------------------------
183 //-------------------------------------------------------
184 
186  GraphicalGeometricBase(source,renderer)
187 {
188  mMapper = vtkPolyDataMapperPtr::New();
189  mIsWireFrame = false;
190 
191  mActor->SetMapper(mMapper);
192  setSource(source);
193  setRenderer(renderer);
194 }
195 
197 {
198  mIsWireFrame = val;
199 }
200 
202 {
203  if (mIsWireFrame)
204  mActor->GetProperty()->SetRepresentationToWireframe();
205  else
206  mActor->GetProperty()->SetRepresentationToSurface();
207 }
208 
210 {
212  mData = data;
213 
214  mMapper->SetInputData(mData);
215 }
216 
217 
219 {
220  return mMapper;
221 }
222 
223 //--------------------------------------------------------
224 //--------------------------------------------------------
225 //-------------------------------------------------------
226 
228  GraphicalGeometricBase(source,renderer)
229 {
230  mMapper = vtkSmartPointer<vtkGlyph3DMapper>::New();
231  vtkSmartPointer<vtkArrowSource> arrowSource = vtkSmartPointer<vtkArrowSource>::New();
232  mMapper->SetSourceConnection(arrowSource->GetOutputPort());
233  mMapper->ScalarVisibilityOn();
234  mMapper->SetUseLookupTableScalarRange(1);
235  mMapper->SetScalarMode(VTK_SCALAR_MODE_USE_POINT_FIELD_DATA);
236  mActor->SetMapper(mMapper);
237  setSource(source);
238  setRenderer(renderer);
239 }
240 
241 
243 {
244  mData = data;
245  if (data)
246  mMapper->SetInputData(mData);
247 }
248 
249 void GraphicalGlyph3DData::setOrientationArray(const char* orientationArray)
250 {
251  mMapper->SetOrientationArray(orientationArray);
252 }
253 
254 void GraphicalGlyph3DData::setColorArray(const char* colorArray)
255 {
256  if(strlen(colorArray)>0)
257  {
258  setScalarVisibility(true);
259  }else
260  {
261  setScalarVisibility(false);
262  }
263  mMapper->SelectColorArray(colorArray);
264 }
265 
266 
267 void GraphicalGlyph3DData::setLUT(const char* lut)
268 {
269  vtkSmartPointer<vtkColorSeries> colorSeries = vtkSmartPointer<vtkColorSeries>::New();
270  vtkSmartPointer<vtkLookupTable> table = vtkLookupTable::New();
271  colorSeries->SetColorSchemeByName(lut);
272  colorSeries->BuildLookupTable(table , vtkColorSeries::ORDINAL);
273  mMapper->SetLookupTable(table);
274 }
275 
276 
277 void GraphicalGlyph3DData::setScaleFactor(double scaleFactor)
278 {
279  if(scaleFactor<=0) return;
280  mMapper->SetScaleFactor(scaleFactor);
281 }
282 
284 {
285  return mMapper;
286 }
287 
288 //--------------------------------------------------------
289 //--------------------------------------------------------
290 //--------------------------------------------------------
291 
293 {
294 // mRenderer = renderer;
295  source = vtkSphereSourcePtr::New();
296  source->SetRadius(4);
297 // default:
298 // source->SetThetaResolution(8);
299 // source->SetPhiResolution(8);
300  // 24*16 = 384, 8*8=64, 16*12=192
301  source->SetThetaResolution(16);
302  source->SetPhiResolution(12);
303  source->LatLongTessellationOn();
304 
305  vtkPolyDataNormalsPtr normals = vtkPolyDataNormalsPtr::New();
306  normals->SetInputConnection(source->GetOutputPort());
307  normals->Update();
308 
309  mapper = vtkPolyDataMapperPtr::New();
310  mapper->SetInputConnection(normals->GetOutputPort());
311 
312  actor = vtkActorPtr::New();
313  actor->SetMapper(mapper);
314 
315  this->setRenderer(renderer);
316 }
317 
319 {
320  this->setRenderer(NULL);
321 }
322 
324 {
325  if (mRenderer)
326  {
327  mRenderer->RemoveActor(actor);
328  }
329 
330  mRenderer = renderer;
331 
332  if (mRenderer)
333  {
334  mRenderer->AddActor(actor);
335  }
336 }
337 
338 void GraphicalPoint3D::setRadius(double radius)
339 {
340  source->SetRadius(radius);
341 }
342 
343 void GraphicalPoint3D::setColor(QColor color)
344 {
345  setColorAndOpacity(actor->GetProperty(), color);
346 }
347 
349 {
350  actor->SetPosition(point.begin());
351 }
352 
354 {
355  return Vector3D(actor->GetPosition());
356 }
357 
359 {
360  return actor;
361 }
362 
364 {
365  return source->GetOutput();
366 }
367 
368 //--------------------------------------------------------
369 //--------------------------------------------------------
370 //--------------------------------------------------------
371 
373 {
374  mRenderer = renderer;
375  source = vtkLineSourcePtr::New();
376  mapper = vtkPolyDataMapperPtr::New() ;
377  actor = vtkActorPtr::New() ;
378 
379  mapper->SetInputConnection( source->GetOutputPort() );
380  actor->SetMapper (mapper );
381  this->setRenderer(renderer);
382 }
383 
385 {
386  this->setRenderer(NULL);
387 }
388 
390 {
391  if (mRenderer)
392  {
393  mRenderer->RemoveActor(actor);
394  }
395 
396  mRenderer = renderer;
397 
398  if (mRenderer)
399  {
400  mRenderer->AddActor(actor);
401  }
402 }
403 
404 void GraphicalLine3D::setColor(QColor color)
405 {
406  setColorAndOpacity(actor->GetProperty(), color);
407 }
408 
410 {
411  source->SetPoint1(point1.begin());
412  source->SetPoint2(point2.begin());
413 }
414 
416 {
417  actor->GetProperty()->SetLineStipplePattern(stipple);
418 }
419 
421 {
422  return actor;
423 }
424 
425 //--------------------------------------------------------
426 //--------------------------------------------------------
427 //--------------------------------------------------------
428 
430 {
431  mRenderer = renderer;
432  source = vtkArcSourcePtr::New();
433  source->SetResolution(20);
434  mapper = vtkPolyDataMapperPtr::New() ;
435  actor = vtkActorPtr::New() ;
436 
437  mapper->SetInputConnection( source->GetOutputPort() );
438  actor->SetMapper (mapper );
439  if (mRenderer)
440  mRenderer->AddActor(actor);
441 }
442 
444 {
445  if (mRenderer)
446  mRenderer->RemoveActor(actor);
447 }
448 
449 void GraphicalArc3D::setColor(QColor color)
450 {
451  setColorAndOpacity(actor->GetProperty(), color);
452 }
453 
455 {
456  source->SetPoint1(point1.begin());
457  source->SetPoint2(point2.begin());
458  source->SetCenter(center.begin());
459 }
460 
461 void GraphicalArc3D::setStipple(int stipple)
462 {
463  actor->GetProperty()->SetLineStipplePattern(stipple);
464 }
465 
467 {
468  return actor;
469 }
470 
471 //--------------------------------------------------------
472 //--------------------------------------------------------
473 //--------------------------------------------------------
474 
476 {
477  mRenderer = renderer;
478  source = vtkArrowSourcePtr::New();
479  source->SetTipResolution(24);
480  source->SetShaftResolution(24);
481  mapper = vtkPolyDataMapperPtr::New() ;
482  actor = vtkActorPtr::New() ;
483 
484  mapper->SetInputConnection( source->GetOutputPort() );
485  actor->SetMapper (mapper );
486  if (mRenderer)
487  mRenderer->AddActor(actor);
488 }
489 
491 {
492  if (mRenderer)
493  mRenderer->RemoveActor(actor);
494 }
495 
496 void GraphicalArrow3D::setColor(QColor color)
497 {
498  setColorAndOpacity(actor->GetProperty(), color);
499 }
500 
502 {
503  // find an arbitrary vector k perpendicular to normal:
504  Vector3D k = cross(Vector3D(1,0,0), normal);
505  if (similar(k, Vector3D(0,0,0)))
506  k = cross(Vector3D(0,1,0), normal);
507  k = k.normalized();
508  Transform3D M = createTransformIJC(normal, k, base);
509 
510 // std::cout << "GraphicalArrow3D::setValue " << base << " - " << normal << std::endl;
511  Transform3D S = createTransformScale(Vector3D(length,1,1));
512  M = M * S;
513  // let arrow shape increase slowly with length:
514 // source->SetTipLength(0.35/sqrt(length));
515 // source->SetTipRadius(0.1*sqrt(length));
516 // source->SetShaftRadius(0.03*sqrt(length));
517  source->SetTipLength(0.35);
518  source->SetTipRadius(0.1*(length));
519  source->SetShaftRadius(0.03*(length));
520  actor->SetUserMatrix(M.getVtkMatrix());
521 }
522 
523 //--------------------------------------------------------
524 //--------------------------------------------------------
525 //--------------------------------------------------------
526 
527 Rect3D::Rect3D(vtkRendererPtr renderer, QColor color)
528 {
529  mRenderer = renderer;
530  mapper = vtkPolyDataMapperPtr::New();
531  actor = vtkActorPtr::New();
532  setColorAndOpacity(actor->GetProperty(), color);
533  actor->SetMapper(mapper);
534  if (mRenderer)
535  mRenderer->AddActor(actor);
536 
537  mPolyData = vtkPolyDataPtr::New();
538  mPoints = vtkPointsPtr::New();
539  mSide = vtkCellArrayPtr::New();
540 
541  vtkIdType cells[5] = { 0,1,2,3,0 };
542  mSide->InsertNextCell(5, cells);
543 
544  mPolyData->SetPoints(mPoints);
545  mapper->SetInputData(mPolyData);
546 }
547 
548 void Rect3D::setLine(bool on, int width)
549 {
550  if (on)
551  {
552  mPolyData->SetLines(mSide);
553  actor->GetProperty()->SetLineWidth(width);
554  }
555  else
556  {
557  mPolyData->SetLines(NULL);
558  }
559 }
560 
561 void Rect3D::setSurface(bool on)
562 {
563  if (on)
564  {
565  mPolyData->SetPolys(mSide);
566  actor->GetProperty()->SetOpacity(1.0); // transparent planes dont work well together with texture volume. Use 1.0
567  }
568  else
569  {
570  mPolyData->SetPolys(NULL);
571  }
572 }
573 
575 {
576  if (mRenderer)
577  mRenderer->RemoveActor(actor);
578 }
579 
580 void Rect3D::setColor(QColor color)
581 {
582  setColorAndOpacity(actor->GetProperty(), color);
583 }
584 
586 {
587  mPoints = vtkPointsPtr::New();
588  mPoints->InsertPoint(0, M.coord(bb.corner(0,0,0)).begin());
589  mPoints->InsertPoint(1, M.coord(bb.corner(0,1,0)).begin());
590  mPoints->InsertPoint(2, M.coord(bb.corner(1,1,0)).begin());
591  mPoints->InsertPoint(3, M.coord(bb.corner(1,0,0)).begin());
592  mPolyData->SetPoints(mPoints);
593 }
594 
595 //--------------------------------------------------------
596 //--------------------------------------------------------
597 //--------------------------------------------------------
598 
600 {
601  mText = vtkVectorTextPtr::New();
602  vtkPolyDataMapperPtr mapper = vtkPolyDataMapperPtr::New();
603  mapper->SetInputConnection(mText->GetOutputPort());
604  mFollower = vtkFollowerPtr::New();
605  mFollower->SetMapper(mapper);
606  Vector3D mTextScale(2,2,2);
607  mFollower->SetScale(mTextScale.begin());
608 
609  this->setSizeInNormalizedViewport(true, 0.025);
610  this->setRenderer(renderer);
611 }
612 
614 {
615  if (mRenderer)
616  {
617  mRenderer->RemoveActor(mFollower);
618  mViewportListener->stopListen();
619  }
620 
621  mRenderer = renderer;
622 
623  if (mRenderer)
624  {
625  mRenderer->AddActor(mFollower);
626  mFollower->SetCamera(mRenderer->GetActiveCamera());
627  if (mViewportListener)
628  mViewportListener->startListen(mRenderer);
629  }
630 }
631 
633 {
634  if (mRenderer)
635  mRenderer->RemoveActor(mFollower);
636 }
637 
638 void FollowerText3D::setSize(double val)
639 {
640  mSize = val;
641  this->scaleText();
642 }
643 
645 {
646  if (on)
647  {
648  if (!mViewportListener)
649  {
650  mViewportListener.reset(new ViewportListener);
651  mViewportListener->setCallback(boost::bind(&FollowerText3D::scaleText, this));
652  }
653  }
654  else
655  {
656  mViewportListener.reset();
657  }
658 
659  this->setSize(size);
660 }
661 
662 void FollowerText3D::setColor(QColor color)
663 {
664  setColorAndOpacity(mFollower->GetProperty(), color);
665 }
666 
667 void FollowerText3D::setText(QString text)
668 {
669  mText->SetText(cstring_cast(text));
670 }
671 
673 {
674  mFollower->SetPosition(pos.begin());
675 }
676 
678 {
679  return mFollower;
680 }
681 
689 {
690  if (!mViewportListener || !mViewportListener->isListening())
691  {
692  mFollower->SetScale(Vector3D(mSize,mSize,mSize).begin());
693  return;
694  }
695 
696  double size = mViewportListener->getVpnZoom();
697 
698  double scale = mSize/size;
699 // std::cout << "s= " << size << " ,scale= " << scale << std::endl;
700  Vector3D mTextScale(scale,scale,scale);
701  if (mFollower)
702  mFollower->SetScale(mTextScale.begin());
703 }
704 
705 //--------------------------------------------------------
706 //--------------------------------------------------------
707 //--------------------------------------------------------
708 
710 {
711  mText = vtkCaptionActor2DPtr::New();
712  mText->BorderOff();
713  mText->LeaderOff();
714 
715  mText->GetCaptionTextProperty()->BoldOff();
716  mText->GetCaptionTextProperty()->ItalicOff();
717  mText->GetCaptionTextProperty()->ShadowOff();
718  mText->SetWidth(10);
719  mText->SetHeight(0.03);
720 
721  this->setRenderer(renderer);
722 }
723 
725 {
726  if (mRenderer)
727  {
728  mRenderer->RemoveActor(mText);
729  }
730 
731  mRenderer = renderer;
732 
733  if (mRenderer)
734  {
735  mRenderer->AddActor(mText);
736  }
737 }
738 
740 {
741  if (mRenderer)
742  mRenderer->RemoveActor(mText);
743 }
744 
745 void CaptionText3D::setSize(double val)
746 {
747  mText->SetHeight(val);
748 }
749 
750 void CaptionText3D::setColor(QColor color)
751 {
752  mText->GetCaptionTextProperty()->SetColor(getColorAsVector3D(color).begin());
753 }
754 
755 void CaptionText3D::setText(QString text)
756 {
757  mText->SetCaption(cstring_cast(text));
758 }
759 
761 {
762  mText->SetAttachmentPoint(pos.begin());
763 }
764 
766 {
767  return mText;
768 }
769 
770 //--------------------------------------------------------
771 //--------------------------------------------------------
772 //--------------------------------------------------------
773 
774 }
vtkPolyDataAlgorithmPtr getSource()
void setStipple(int stipple)
void setColor(QColor color)
vtkSmartPointer< class vtkActor > vtkActorPtr
Vector3D corner(int x, int y, int z) const
Vector3D getColorAsVector3D(QColor color)
virtual vtkMapperPtr getMapper()=0
Scalar * begin()
PlainObject normal() const
vtkSmartPointer< class vtkPolyDataMapper > vtkPolyDataMapperPtr
FollowerText3D(vtkRendererPtr renderer=vtkRendererPtr())
void setRenderer(vtkRendererPtr renderer=vtkRendererPtr())
Transform3D createTransformScale(const Vector3D &scale_)
Transform3D Transform3D
Transform3D is a representation of an affine 3D transform.
GraphicalGeometricBase(vtkPolyDataAlgorithmPtr source=vtkPolyDataAlgorithmPtr(), vtkRendererPtr renderer=vtkRendererPtr())
void scaleText()
internal method
void setRenderer(vtkRendererPtr renderer=vtkRendererPtr())
void setColor(double red, double green, double blue)
cstring_cast_Placeholder cstring_cast(const T &val)
void setText(QString text)
void setUserMatrix(vtkMatrix4x4 *matrix)
void setValue(Vector3D base, Vector3D normal, double length)
void setColor(QColor color)
void setData(vtkPolyDataPtr data)
void setColor(QColor color)
bool similar(const DoubleBoundingBox3D &a, const DoubleBoundingBox3D &b, double tol)
Listens to changes in viewport and camera matrix.
Vector3D cross(const Vector3D &a, const Vector3D &b)
compute cross product of a and b.
Definition: cxVector3D.cpp:62
void setPosition(Vector3D pos)
GraphicalPoint3D(vtkRendererPtr renderer=vtkRendererPtr())
GraphicalGlyph3DData(vtkPolyDataAlgorithmPtr source=vtkPolyDataAlgorithmPtr(), vtkRendererPtr renderer=vtkRendererPtr())
void setRenderer(vtkRendererPtr renderer=vtkRendererPtr())
vtkSmartPointer< class vtkPolyData > vtkPolyDataPtr
GraphicalArrow3D(vtkRendererPtr renderer=vtkRendererPtr())
Transform3D createTransformIJC(const Vector3D &ivec, const Vector3D &jvec, const Vector3D &center)
vtkSmartPointer< class vtkRenderer > vtkRendererPtr
vtkSmartPointer< class vtkFollower > vtkFollowerPtr
void setSurface(bool on)
vtkSmartPointer< class vtkMapper > vtkMapperPtr
void setData(vtkPolyDataPtr data)
void setSizeInNormalizedViewport(bool on, double size)
void setLine(bool on, int width)
void setPosition(Vector3D pos)
void setText(QString text)
vtkSmartPointer< class vtkPolyDataNormals > vtkPolyDataNormalsPtr
Rect3D(vtkRendererPtr renderer, QColor color)
void setValue(Vector3D point1, Vector3D point2)
void setRenderer(vtkRendererPtr renderer=vtkRendererPtr())
vtkSmartPointer< class vtkCaptionActor2D > vtkCaptionActor2DPtr
void setColor(QColor color)
void setRenderer(vtkRendererPtr renderer=vtkRendererPtr())
Representation of a floating-point bounding box in 3D. The data are stored as {xmin,xmax,ymin,ymax,zmin,zmax}, in order to simplify communication with vtk.
Eigen::Vector3d Vector3D
Vector3D is a representation of a point or vector in 3D.
Definition: cxVector3D.h:63
GraphicalLine3D(vtkRendererPtr renderer=vtkRendererPtr())
void setRadius(double radius)
void setValue(Vector3D point1, Vector3D point2, Vector3D center)
CaptionText3D(vtkRendererPtr renderer=vtkRendererPtr())
GraphicalPolyData3D(vtkPolyDataAlgorithmPtr source=vtkPolyDataAlgorithmPtr(), vtkRendererPtr renderer=vtkRendererPtr())
vtkSmartPointer< class vtkPolyDataAlgorithm > vtkPolyDataAlgorithmPtr
Definition: cxViewWrapper.h:47
void setOrientationArray(const char *orientationArray)
RealScalar length() const
vtkCaptionActor2DPtr getActor()
void setColorArray(const char *colorArray)
void setSource(vtkPolyDataAlgorithmPtr source)
vtkPolyDataAlgorithmPtr mSource
void updatePosition(const DoubleBoundingBox3D bb, const Transform3D &M)
GraphicalArc3D(vtkRendererPtr renderer=vtkRendererPtr())
void setStipple(int stipple)
void setScaleFactor(double scaleFactor)
void setColorAndOpacity(vtkPropertyPtr property, QColor color)
void setColor(QColor color)
void setValue(Vector3D point)