Fraxinus  16.5.0-fx-rc4
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  if (mData)
215  mMapper->SetInputData(mData);
216 }
217 
218 
220 {
221  return mMapper;
222 }
223 
224 //--------------------------------------------------------
225 //--------------------------------------------------------
226 //-------------------------------------------------------
227 
229  GraphicalGeometricBase(source,renderer)
230 {
231  mMapper = vtkSmartPointer<vtkGlyph3DMapper>::New();
232  vtkSmartPointer<vtkArrowSource> arrowSource = vtkSmartPointer<vtkArrowSource>::New();
233  mMapper->SetSourceConnection(arrowSource->GetOutputPort());
234  mMapper->ScalarVisibilityOn();
235  mMapper->SetUseLookupTableScalarRange(1);
236  mMapper->SetScalarMode(VTK_SCALAR_MODE_USE_POINT_FIELD_DATA);
237  mActor->SetMapper(mMapper);
238  setSource(source);
239  setRenderer(renderer);
240 }
241 
242 
244 {
245  mData = data;
246  if (data)
247  mMapper->SetInputData(mData);
248 }
249 
250 void GraphicalGlyph3DData::setOrientationArray(const char* orientationArray)
251 {
252  mMapper->SetOrientationArray(orientationArray);
253 }
254 
255 void GraphicalGlyph3DData::setColorArray(const char* colorArray)
256 {
257  if(strlen(colorArray)>0)
258  {
259  setScalarVisibility(true);
260  }else
261  {
262  setScalarVisibility(false);
263  }
264  mMapper->SelectColorArray(colorArray);
265 }
266 
267 
268 void GraphicalGlyph3DData::setLUT(const char* lut)
269 {
270  vtkSmartPointer<vtkColorSeries> colorSeries = vtkSmartPointer<vtkColorSeries>::New();
271  vtkSmartPointer<vtkLookupTable> table = vtkLookupTable::New();
272  colorSeries->SetColorSchemeByName(lut);
273  colorSeries->BuildLookupTable(table , vtkColorSeries::ORDINAL);
274  mMapper->SetLookupTable(table);
275 }
276 
277 
278 void GraphicalGlyph3DData::setScaleFactor(double scaleFactor)
279 {
280  if(scaleFactor<=0) return;
281  mMapper->SetScaleFactor(scaleFactor);
282 }
283 
285 {
286  return mMapper;
287 }
288 
289 //--------------------------------------------------------
290 //--------------------------------------------------------
291 //--------------------------------------------------------
292 
294 {
295 // mRenderer = renderer;
296  source = vtkSphereSourcePtr::New();
297  source->SetRadius(4);
298 // default:
299 // source->SetThetaResolution(8);
300 // source->SetPhiResolution(8);
301  // 24*16 = 384, 8*8=64, 16*12=192
302  source->SetThetaResolution(16);
303  source->SetPhiResolution(12);
304  source->LatLongTessellationOn();
305 
306  vtkPolyDataNormalsPtr normals = vtkPolyDataNormalsPtr::New();
307  normals->SetInputConnection(source->GetOutputPort());
308  normals->Update();
309 
310  mapper = vtkPolyDataMapperPtr::New();
311  mapper->SetInputConnection(normals->GetOutputPort());
312 
313  actor = vtkActorPtr::New();
314  actor->SetMapper(mapper);
315 
316  this->setRenderer(renderer);
317 }
318 
320 {
321  this->setRenderer(NULL);
322 }
323 
325 {
326  if (mRenderer)
327  {
328  mRenderer->RemoveActor(actor);
329  }
330 
331  mRenderer = renderer;
332 
333  if (mRenderer)
334  {
335  mRenderer->AddActor(actor);
336  }
337 }
338 
339 void GraphicalPoint3D::setRadius(double radius)
340 {
341  source->SetRadius(radius);
342 }
343 
344 void GraphicalPoint3D::setColor(QColor color)
345 {
346  setColorAndOpacity(actor->GetProperty(), color);
347 }
348 
350 {
351  actor->SetPosition(point.begin());
352 }
353 
355 {
356  return Vector3D(actor->GetPosition());
357 }
358 
360 {
361  return actor;
362 }
363 
365 {
366  return source->GetOutput();
367 }
368 
369 //--------------------------------------------------------
370 //--------------------------------------------------------
371 //--------------------------------------------------------
372 
374 {
375  mRenderer = renderer;
376  source = vtkLineSourcePtr::New();
377  mapper = vtkPolyDataMapperPtr::New() ;
378  actor = vtkActorPtr::New() ;
379 
380  mapper->SetInputConnection( source->GetOutputPort() );
381  actor->SetMapper (mapper );
382  this->setRenderer(renderer);
383 }
384 
386 {
387  this->setRenderer(NULL);
388 }
389 
391 {
392  if (mRenderer)
393  {
394  mRenderer->RemoveActor(actor);
395  }
396 
397  mRenderer = renderer;
398 
399  if (mRenderer)
400  {
401  mRenderer->AddActor(actor);
402  }
403 }
404 
405 void GraphicalLine3D::setColor(QColor color)
406 {
407  setColorAndOpacity(actor->GetProperty(), color);
408 }
409 
411 {
412  source->SetPoint1(point1.begin());
413  source->SetPoint2(point2.begin());
414 }
415 
417 {
418  actor->GetProperty()->SetLineStipplePattern(stipple);
419 }
420 
422 {
423  return actor;
424 }
425 
426 //--------------------------------------------------------
427 //--------------------------------------------------------
428 //--------------------------------------------------------
429 
431 {
432  mRenderer = renderer;
433  source = vtkArcSourcePtr::New();
434  source->SetResolution(20);
435  mapper = vtkPolyDataMapperPtr::New() ;
436  actor = vtkActorPtr::New() ;
437 
438  mapper->SetInputConnection( source->GetOutputPort() );
439  actor->SetMapper (mapper );
440  if (mRenderer)
441  mRenderer->AddActor(actor);
442 }
443 
445 {
446  if (mRenderer)
447  mRenderer->RemoveActor(actor);
448 }
449 
450 void GraphicalArc3D::setColor(QColor color)
451 {
452  setColorAndOpacity(actor->GetProperty(), color);
453 }
454 
456 {
457  source->SetPoint1(point1.begin());
458  source->SetPoint2(point2.begin());
459  source->SetCenter(center.begin());
460 }
461 
462 void GraphicalArc3D::setStipple(int stipple)
463 {
464  actor->GetProperty()->SetLineStipplePattern(stipple);
465 }
466 
468 {
469  return actor;
470 }
471 
472 //--------------------------------------------------------
473 //--------------------------------------------------------
474 //--------------------------------------------------------
475 
477 {
478  mRenderer = renderer;
479  source = vtkArrowSourcePtr::New();
480  source->SetTipResolution(24);
481  source->SetShaftResolution(24);
482  mapper = vtkPolyDataMapperPtr::New() ;
483  actor = vtkActorPtr::New() ;
484 
485  mapper->SetInputConnection( source->GetOutputPort() );
486  actor->SetMapper (mapper );
487  if (mRenderer)
488  mRenderer->AddActor(actor);
489 }
490 
492 {
493  if (mRenderer)
494  mRenderer->RemoveActor(actor);
495 }
496 
497 void GraphicalArrow3D::setColor(QColor color)
498 {
499  setColorAndOpacity(actor->GetProperty(), color);
500 }
501 
503 {
504  // find an arbitrary vector k perpendicular to normal:
505  Vector3D k = cross(Vector3D(1,0,0), normal);
506  if (similar(k, Vector3D(0,0,0)))
507  k = cross(Vector3D(0,1,0), normal);
508  k = k.normalized();
509  Transform3D M = createTransformIJC(normal, k, base);
510 
511 // std::cout << "GraphicalArrow3D::setValue " << base << " - " << normal << std::endl;
512  Transform3D S = createTransformScale(Vector3D(length,1,1));
513  M = M * S;
514  // let arrow shape increase slowly with length:
515 // source->SetTipLength(0.35/sqrt(length));
516 // source->SetTipRadius(0.1*sqrt(length));
517 // source->SetShaftRadius(0.03*sqrt(length));
518  source->SetTipLength(0.35);
519  source->SetTipRadius(0.1*(length));
520  source->SetShaftRadius(0.03*(length));
521  actor->SetUserMatrix(M.getVtkMatrix());
522 }
523 
524 //--------------------------------------------------------
525 //--------------------------------------------------------
526 //--------------------------------------------------------
527 
528 Rect3D::Rect3D(vtkRendererPtr renderer, QColor color)
529 {
530  mRenderer = renderer;
531  mapper = vtkPolyDataMapperPtr::New();
532  actor = vtkActorPtr::New();
533  setColorAndOpacity(actor->GetProperty(), color);
534  actor->SetMapper(mapper);
535  if (mRenderer)
536  mRenderer->AddActor(actor);
537 
538  mPolyData = vtkPolyDataPtr::New();
539  mPoints = vtkPointsPtr::New();
540  mSide = vtkCellArrayPtr::New();
541 
542  vtkIdType cells[5] = { 0,1,2,3,0 };
543  mSide->InsertNextCell(5, cells);
544 
545  mPolyData->SetPoints(mPoints);
546  mapper->SetInputData(mPolyData);
547 }
548 
549 void Rect3D::setLine(bool on, int width)
550 {
551  if (on)
552  {
553  mPolyData->SetLines(mSide);
554  actor->GetProperty()->SetLineWidth(width);
555  }
556  else
557  {
558  mPolyData->SetLines(NULL);
559  }
560 }
561 
562 void Rect3D::setSurface(bool on)
563 {
564  if (on)
565  {
566  mPolyData->SetPolys(mSide);
567  actor->GetProperty()->SetOpacity(1.0); // transparent planes dont work well together with texture volume. Use 1.0
568  }
569  else
570  {
571  mPolyData->SetPolys(NULL);
572  }
573 }
574 
576 {
577  if (mRenderer)
578  mRenderer->RemoveActor(actor);
579 }
580 
581 void Rect3D::setColor(QColor color)
582 {
583  setColorAndOpacity(actor->GetProperty(), color);
584 }
585 
587 {
588  mPoints = vtkPointsPtr::New();
589  mPoints->InsertPoint(0, M.coord(bb.corner(0,0,0)).begin());
590  mPoints->InsertPoint(1, M.coord(bb.corner(0,1,0)).begin());
591  mPoints->InsertPoint(2, M.coord(bb.corner(1,1,0)).begin());
592  mPoints->InsertPoint(3, M.coord(bb.corner(1,0,0)).begin());
593  mPolyData->SetPoints(mPoints);
594 }
595 
596 //--------------------------------------------------------
597 //--------------------------------------------------------
598 //--------------------------------------------------------
599 
601 {
602  mText = vtkVectorTextPtr::New();
603  vtkPolyDataMapperPtr mapper = vtkPolyDataMapperPtr::New();
604  mapper->SetInputConnection(mText->GetOutputPort());
605  mFollower = vtkFollowerPtr::New();
606  mFollower->SetMapper(mapper);
607  Vector3D mTextScale(2,2,2);
608  mFollower->SetScale(mTextScale.begin());
609 
610  this->setSizeInNormalizedViewport(true, 0.025);
611  this->setRenderer(renderer);
612 }
613 
615 {
616  if (mRenderer)
617  {
618  mRenderer->RemoveActor(mFollower);
619  mViewportListener->stopListen();
620  }
621 
622  mRenderer = renderer;
623 
624  if (mRenderer)
625  {
626  mRenderer->AddActor(mFollower);
627  mFollower->SetCamera(mRenderer->GetActiveCamera());
628  if (mViewportListener)
629  mViewportListener->startListen(mRenderer);
630  }
631 }
632 
634 {
635  if (mRenderer)
636  mRenderer->RemoveActor(mFollower);
637 }
638 
639 void FollowerText3D::setSize(double val)
640 {
641  mSize = val;
642  this->scaleText();
643 }
644 
646 {
647  if (on)
648  {
649  if (!mViewportListener)
650  {
651  mViewportListener.reset(new ViewportListener);
652  mViewportListener->setCallback(boost::bind(&FollowerText3D::scaleText, this));
653  }
654  }
655  else
656  {
657  mViewportListener.reset();
658  }
659 
660  this->setSize(size);
661 }
662 
663 void FollowerText3D::setColor(QColor color)
664 {
665  setColorAndOpacity(mFollower->GetProperty(), color);
666 }
667 
668 void FollowerText3D::setText(QString text)
669 {
670  mText->SetText(cstring_cast(text));
671 }
672 
674 {
675  mFollower->SetPosition(pos.begin());
676 }
677 
679 {
680  return mFollower;
681 }
682 
690 {
691  if (!mViewportListener || !mViewportListener->isListening())
692  {
693  mFollower->SetScale(Vector3D(mSize,mSize,mSize).begin());
694  return;
695  }
696 
697  double size = mViewportListener->getVpnZoom();
698 
699  double scale = mSize/size;
700 // std::cout << "s= " << size << " ,scale= " << scale << std::endl;
701  Vector3D mTextScale(scale,scale,scale);
702  if (mFollower)
703  mFollower->SetScale(mTextScale.begin());
704 }
705 
706 //--------------------------------------------------------
707 //--------------------------------------------------------
708 //--------------------------------------------------------
709 
711 {
712  mText = vtkCaptionActor2DPtr::New();
713  mText->BorderOff();
714  mText->LeaderOff();
715 
716  mText->GetCaptionTextProperty()->BoldOff();
717  mText->GetCaptionTextProperty()->ItalicOff();
718  mText->GetCaptionTextProperty()->ShadowOff();
719  mText->SetWidth(10);
720  mText->SetHeight(0.03);
721 
722  this->setRenderer(renderer);
723 }
724 
726 {
727  if (mRenderer)
728  {
729  mRenderer->RemoveActor(mText);
730  }
731 
732  mRenderer = renderer;
733 
734  if (mRenderer)
735  {
736  mRenderer->AddActor(mText);
737  }
738 }
739 
741 {
742  if (mRenderer)
743  mRenderer->RemoveActor(mText);
744 }
745 
746 void CaptionText3D::setSize(double val)
747 {
748  mText->SetHeight(val);
749 }
750 
751 void CaptionText3D::setColor(QColor color)
752 {
753  mText->GetCaptionTextProperty()->SetColor(getColorAsVector3D(color).begin());
754 }
755 
756 void CaptionText3D::setText(QString text)
757 {
758  mText->SetCaption(cstring_cast(text));
759 }
760 
762 {
763  mText->SetAttachmentPoint(pos.begin());
764 }
765 
767 {
768  return mText;
769 }
770 
771 //--------------------------------------------------------
772 //--------------------------------------------------------
773 //--------------------------------------------------------
774 
775 }
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)