1 // GEOM OBJECT : interactive object for Geometry entities visualization
3 // Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
24 // File : GEOM_Actor.cxx
25 // Author : Christophe ATTANASIO
30 \class GEOM_Actor GEOM_Actor.h
31 \brief This class allows to display an OpenCASCADE CAD model in a VTK viewer.
33 #include "GEOM_Actor.h"
35 #include "GEOM_DeviceActor.h"
36 #include "GEOM_VertexSource.h"
37 #include "GEOM_EdgeSource.h"
38 #include "GEOM_WireframeFace.h"
39 #include "GEOM_ShadingFace.h"
40 #include "SVTK_Actor.h"
42 #include <vtkObjectFactory.h>
43 #include <vtkRenderer.h>
44 #include <vtkProperty.h>
45 #include <vtkPointPicker.h>
46 #include <vtkCellPicker.h>
48 #include <TopAbs_ShapeEnum.hxx>
49 #include <TopExp_Explorer.hxx>
50 #include <Poly_Triangulation.hxx>
51 #include <BRepMesh_IncrementalMesh.hxx>
52 #include <Bnd_Box.hxx>
54 #include <BRep_Tool.hxx>
55 #include <BRepBndLib.hxx>
56 #include <TopTools_ListOfShape.hxx>
57 #include <TopoDS_Iterator.hxx>
60 #include <vtkPolyDataWriter.h>
62 #include <vtkAppendPolyData.h>
63 #include <vtkPolyDataMapper.h>
64 #include <vtkPolyData.h>
65 #include <vtkTransform.h>
66 #include <vtkMatrix4x4.h>
68 #include <vtkCamera.h>
70 //vtkStandardNewMacro(GEOM_Actor);
76 GEOM_Actor::GEOM_Actor():
77 // myDisplayMode(eWireframe),
80 myVertexActor(GEOM_DeviceActor::New(),true),
81 myVertexSource(GEOM_VertexSource::New(),true),
83 myIsolatedEdgeActor(GEOM_DeviceActor::New(),true),
84 myIsolatedEdgeSource(GEOM_EdgeSource::New(),true),
86 myOneFaceEdgeActor(GEOM_DeviceActor::New(),true),
87 myOneFaceEdgeSource(GEOM_EdgeSource::New(),true),
89 mySharedEdgeActor(GEOM_DeviceActor::New(),true),
90 mySharedEdgeSource(GEOM_EdgeSource::New(),true),
92 myWireframeFaceActor(GEOM_DeviceActor::New(),true),
93 myWireframeFaceSource(GEOM_WireframeFace::New(),true),
95 myShadingFaceActor(GEOM_DeviceActor::New(),true),
96 myShadingFaceSource(GEOM_ShadingFace::New(),true),
98 myHighlightActor(GEOM_DeviceActor::New(),true),
99 myAppendFilter(vtkAppendPolyData::New(),true),
100 myPolyDataMapper(vtkPolyDataMapper::New(),true),
102 myHighlightProp(vtkProperty::New()),
103 myPreHighlightProp(vtkProperty::New()),
104 myShadingFaceProp(vtkProperty::New())
108 cout <<this<< " GEOM_Actor::GEOM_Actor"<<endl;
111 myPolyDataMapper->SetInput(myAppendFilter->GetOutput());
112 vtkProperty* aProperty;
114 myHighlightProp->SetAmbient(0.5);
115 myHighlightProp->SetDiffuse(0.3);
116 myHighlightProp->SetSpecular(0.2);
117 myHighlightProp->SetRepresentationToSurface();
118 myHighlightProp->SetAmbientColor(1, 1, 1);
119 myHighlightProp->SetDiffuseColor(1, 1, 1);
120 myHighlightProp->SetSpecularColor(0.5, 0.5, 0.5);
121 myHighlightActor->SetProperty(myHighlightProp.GetPointer());
123 this->myHighlightActor->SetInput(myAppendFilter->GetOutput(),false);
125 myPreHighlightProp->SetColor(0,1,1);
126 myPreHighlightProp->SetPointSize(SALOME_POINT_SIZE+2);
127 myPreHighlightProp->SetLineWidth(SALOME_LINE_WIDTH+1);
128 myPreHighlightProp->SetRepresentationToWireframe();
130 myAppendFilter->AddInput(myVertexSource->GetOutput());
131 myVertexActor->SetInput(myVertexSource->GetOutput(),false);
132 aProperty = myVertexActor->GetProperty();
133 aProperty->SetRepresentation(VTK_POINTS);
134 aProperty->SetPointSize(3);
135 aProperty->SetColor(1, 1, 0);
137 myAppendFilter->AddInput(myIsolatedEdgeSource->GetOutput());
138 myIsolatedEdgeActor->SetInput(myIsolatedEdgeSource->GetOutput(),false);
139 aProperty = myIsolatedEdgeActor->GetProperty();
140 aProperty->SetRepresentation(VTK_WIREFRAME);
141 aProperty->SetColor(1, 0, 0);
143 myAppendFilter->AddInput(myOneFaceEdgeSource->GetOutput());
144 myOneFaceEdgeActor->SetInput(myOneFaceEdgeSource->GetOutput(),false);
145 aProperty = myOneFaceEdgeActor->GetProperty();
146 aProperty->SetRepresentation(VTK_WIREFRAME);
147 aProperty->SetColor(0, 1, 0);
149 myAppendFilter->AddInput(mySharedEdgeSource->GetOutput());
150 mySharedEdgeActor->SetInput(mySharedEdgeSource->GetOutput(),false);
151 aProperty = mySharedEdgeActor->GetProperty();
152 aProperty->SetRepresentation(VTK_WIREFRAME);
153 aProperty->SetColor(1, 1, 0);
155 myAppendFilter->AddInput(myWireframeFaceSource->GetOutput());
156 myWireframeFaceActor->SetInput(myWireframeFaceSource->GetOutput(),false);
157 aProperty = myWireframeFaceActor->GetProperty();
158 aProperty->SetRepresentation(VTK_WIREFRAME);
159 aProperty->SetColor(0.5, 0.5, 0.5);
161 myShadingFaceActor->SetInput(myShadingFaceSource->GetOutput(),true);
163 myShadingFaceProp->SetRepresentation(VTK_SURFACE);
164 myShadingFaceProp->SetInterpolationToGouraud();
165 myShadingFaceProp->SetAmbient(1.0);
166 myShadingFaceProp->SetDiffuse(1.0);
167 myShadingFaceProp->SetSpecular(0.4);
168 myShadingFaceProp->SetAmbientColor(0.329412, 0.223529, 0.027451);
169 myShadingFaceProp->SetDiffuseColor(0.780392, 0.568627, 0.113725);
170 myShadingFaceProp->SetSpecularColor(0.992157, 0.941176, 0.807843);
172 myShadingFaceActor->SetProperty(myShadingFaceProp.GetPointer());
174 // Toggle display mode
175 setDisplayMode(0); // WIRE FRAME
180 GEOM_Actor::~GEOM_Actor()
183 cout <<this<< " ~GEOM_Actor::GEOM_Actor"<<endl;
185 myHighlightProp->Delete();
186 myPreHighlightProp->Delete();
187 myShadingFaceProp->Delete();
194 GEOM_Actor* anObject = new GEOM_Actor();
195 anObject->SetMapper(anObject->myPolyDataMapper.Get());
200 void Write(vtkPolyData* theDataSet, const char* theFileName){
201 vtkPolyDataWriter* aWriter = vtkPolyDataWriter::New();
202 cout<<"Write - "<<theFileName<<"' : "<<theDataSet->GetNumberOfPoints()<<"; "<<theDataSet->GetNumberOfCells()<<endl;
203 aWriter->SetInput(theDataSet);
204 aWriter->SetFileName(theFileName);
213 this->myVertexSource->Modified();
214 this->myIsolatedEdgeSource->Modified();
215 this->myOneFaceEdgeSource->Modified();
216 this->mySharedEdgeSource->Modified();
217 this->myWireframeFaceSource->Modified();
218 this->myShadingFaceSource->Modified();
223 SetMapper(vtkMapper* theMapper)
225 SALOME_Actor::SetMapper(theMapper);
230 AddToRender(vtkRenderer* theRenderer)
232 //SALOME_Actor::AddToRender(theRenderer);
234 theRenderer->AddActor(this);
236 this->myHighlightActor->AddToRender(theRenderer);
239 myShadingFaceActor->AddToRender(theRenderer);
240 myWireframeFaceActor->AddToRender(theRenderer);
242 mySharedEdgeActor->AddToRender(theRenderer);
243 myOneFaceEdgeActor->AddToRender(theRenderer);
244 myIsolatedEdgeActor->AddToRender(theRenderer);
246 myVertexActor->AddToRender(theRenderer);
251 RemoveFromRender(vtkRenderer* theRenderer)
253 //SALOME_Actor::RemoveFromRender(theRenderer);
256 theRenderer->RemoveActor(this);
258 myHighlightActor->RemoveFromRender(theRenderer);
259 myShadingFaceActor->RemoveFromRender(theRenderer);
260 myWireframeFaceActor->RemoveFromRender(theRenderer);
262 mySharedEdgeActor->RemoveFromRender(theRenderer);
263 myOneFaceEdgeActor->RemoveFromRender(theRenderer);
264 myIsolatedEdgeActor->RemoveFromRender(theRenderer);
266 myVertexActor->RemoveFromRender(theRenderer);
270 SetVisibility(false);
275 setDisplayMode(int theMode)
278 cout << "GEOM_Actor::SetDisplayMode = "<<theMode <<endl;
280 VTKViewer_Actor::setDisplayMode(theMode);
281 SetVisibility(GetVisibility());
286 SetSelected(bool theIsSelected)
289 cout << "GEOM_Actor::SetSelected = "<<theIsSelected <<endl;
292 myIsSelected = theIsSelected;
293 SetVisibility(GetVisibility());
298 SetVisibility(int theVisibility)
301 cout << "GEOM_Actor::SetVisibility = "<<theVisibility <<" myIsSelected="<< myIsSelected
302 << " theVisibility="<<theVisibility<<" myIsPreselected="<<myIsPreselected<<endl;
305 SALOME_Actor::SetVisibility(theVisibility);
307 this->myHighlightActor->SetVisibility(theVisibility && (myIsSelected || myIsPreselected));
309 // if(myDisplayMode == (int)eShading)
310 // this->myHighlightActor->SetInput(myShadingFaceSource->GetOutput(),false);
312 // this->myHighlightActor->SetInput(myAppendFilter->GetOutput(),false);
314 myShadingFaceActor->SetVisibility(theVisibility && (myDisplayMode == (int)eShading) && (!myIsSelected || !myIsPreselected));
315 myWireframeFaceActor->SetVisibility(theVisibility && (myDisplayMode ==(int)eWireframe) && !myIsSelected);
317 mySharedEdgeActor->SetVisibility(theVisibility && myDisplayMode == (int)eWireframe && !myIsSelected);
318 myOneFaceEdgeActor->SetVisibility(theVisibility && myDisplayMode == (int)eWireframe && !myIsSelected);
319 myIsolatedEdgeActor->SetVisibility(theVisibility && !myIsSelected);
321 myVertexActor->SetVisibility(false);// must be added new mode points
327 ::SetNbIsos(const int theNb[2])
329 myNbIsos[0] = theNb[0];
330 myNbIsos[1] = theNb[1];
335 ::GetNbIsos(int &theNbU,int &theNbV)
337 theNbU = myNbIsos[0];
338 theNbV = myNbIsos[1];
343 MeshShape(const TopoDS_Shape& theShape,
344 float& theDeflection,
347 static Standard_Real RELATIVE_DEFLECTION = 0.0001;
348 Standard_Real aDeflection = theDeflection;
350 if(theDeflection <= 0) { // Compute default theDeflection
352 BRepBndLib::Add(theShape, B);
353 Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax;
354 B.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
355 Standard_Real aDiagonal = (aXmax-aXmin)*(aXmax-aXmin) +
356 (aYmax-aYmin)*(aYmax-aYmin) +
357 (aZmax-aZmin)*(aZmax-aZmin);
358 aDiagonal = sqrt(aDiagonal);
359 aDeflection = aDiagonal*RELATIVE_DEFLECTION;
362 theDeflection = RELATIVE_DEFLECTION;
364 theDeflection = aDeflection;
367 BRepMesh_IncrementalMesh aMesh(theShape,aDeflection);
372 SetDeflection(float theDeflection, bool theIsRelative)
374 myDeflection = theDeflection;
375 myIsRelative = theIsRelative;
377 MeshShape(myShape,myDeflection,myIsRelative);
384 SetShape(const TopoDS_Shape& theShape,
390 myVertexSource->Clear();
391 myIsolatedEdgeSource->Clear();
392 myOneFaceEdgeSource->Clear();
393 mySharedEdgeSource->Clear();
394 myWireframeFaceSource->Clear();
395 myShadingFaceSource->Clear();
397 TopExp_Explorer aVertexExp(theShape,TopAbs_VERTEX);
398 for(; aVertexExp.More(); aVertexExp.Next()){
399 const TopoDS_Vertex& aVertex = TopoDS::Vertex(aVertexExp.Current());
400 myVertexSource->AddVertex(aVertex);
402 SetDeflection(theDeflection,theIsRelative);
404 // look if edges are free or shared
405 TopTools_IndexedDataMapOfShapeListOfShape anEdgeMap;
406 TopExp::MapShapesAndAncestors(theShape,TopAbs_EDGE,TopAbs_FACE,anEdgeMap);
408 SetShape(theShape,anEdgeMap);
413 SetShape(const TopoDS_Shape& theShape,
414 const TopTools_IndexedDataMapOfShapeListOfShape& theEdgeMap)
416 if(theShape.ShapeType() == TopAbs_COMPOUND) {
417 TopoDS_Iterator anItr(theShape);
418 for(; anItr.More(); anItr.Next()) {
419 SetShape(anItr.Value(),theEdgeMap);
423 switch(theShape.ShapeType()){
425 TopExp_Explorer anEdgeExp(theShape,TopAbs_EDGE);
426 for(; anEdgeExp.More(); anEdgeExp.Next()){
427 const TopoDS_Edge& anEdge = TopoDS::Edge(anEdgeExp.Current());
428 if(!BRep_Tool::Degenerated(anEdge))
429 myIsolatedEdgeSource->AddEdge(anEdge);
434 const TopoDS_Edge& anEdge = TopoDS::Edge(theShape);
435 if(!BRep_Tool::Degenerated(anEdge))
436 myIsolatedEdgeSource->AddEdge(anEdge);
439 case TopAbs_VERTEX: {
443 TopExp_Explorer aFaceExp(theShape,TopAbs_FACE);
444 for(; aFaceExp.More(); aFaceExp.Next()) {
445 const TopoDS_Face& aFace = TopoDS::Face(aFaceExp.Current());
446 myWireframeFaceSource->AddFace(aFace);
447 myShadingFaceSource->AddFace(aFace);
448 TopExp_Explorer anEdgeExp(aFaceExp.Current(), TopAbs_EDGE);
449 for(; anEdgeExp.More(); anEdgeExp.Next()) {
450 const TopoDS_Edge& anEdge = TopoDS::Edge(anEdgeExp.Current());
451 if(!BRep_Tool::Degenerated(anEdge)){
452 // compute the number of faces
453 int aNbOfFaces = theEdgeMap.FindFromKey(anEdge).Extent();
455 case 0: // isolated edge
456 myIsolatedEdgeSource->AddEdge(anEdge);
458 case 1: // edge in only one face
459 myOneFaceEdgeSource->AddEdge(anEdge);
461 default: // edge shared by at least two faces
462 mySharedEdgeSource->AddEdge(anEdge);
472 void GEOM_Actor::setDeflection(double adef) {
474 cout << "GEOM_Actor::setDeflection"<<endl;
476 SetDeflection((float)adef,GetIsRelative());
480 // warning! must be checked!
481 // SetHighlightProperty
482 // SetWireframeProperty
483 // SetShadingProperty
485 void GEOM_Actor::SetHighlightProperty(vtkProperty* Prop)
488 cout << "GEOM_Actor::SetHighlightProperty"<<endl;
490 this->myHighlightActor->GetProperty()->DeepCopy(Prop);
494 void GEOM_Actor::SetWireframeProperty(vtkProperty* Prop)
497 cout << this << " GEOM_Actor::SetWireframeProperty"<<endl;
500 myWireframeFaceActor->SetProperty(Prop);
503 void GEOM_Actor::SetShadingProperty(vtkProperty* Prop)
506 cout << "GEOM_Actor::SetShadingProperty"<<endl;
508 myShadingFaceProp->DeepCopy(Prop);
512 void GEOM_Actor::Render(vtkRenderer *ren, vtkMapper *Mapper)
515 cout << "GEOM_Actor::Render"<<endl;
521 /* render the property */
522 if (!this->Property) {
523 // force creation of a property
525 this->Property->SetInterpolation(1);
526 this->Property->SetRepresentationToSurface();
527 this->Property->SetAmbient(0.3);
528 this->Property->SetAmbientColor(0.88,0.86,0.2);
529 this->Property->SetDiffuseColor(0.99,0.7,0.21);
530 this->Property->SetSpecularColor(0.99,0.98,0.83);
533 switch(myDisplayMode){
535 myPreHighlightProp->SetRepresentationToWireframe();
536 myHighlightProp->SetRepresentationToWireframe();
539 myPreHighlightProp->SetRepresentationToSurface();
540 myHighlightProp->SetRepresentationToSurface();
546 this->myHighlightActor->SetProperty(myPreHighlightProp.GetPointer());
547 myShadingFaceActor->SetProperty(myPreHighlightProp.GetPointer());
549 this->myHighlightActor->SetProperty(myShadingFaceProp.GetPointer());
550 myShadingFaceActor->SetProperty(myShadingFaceProp.GetPointer());
554 this->myHighlightActor->SetProperty(myHighlightProp.GetPointer());
555 myShadingFaceActor->SetProperty(myHighlightProp.GetPointer());
558 this->Property->Render(this, ren);
559 if (this->BackfaceProperty) {
560 this->BackfaceProperty->BackfaceRender(this, ren);
561 this->Device->SetBackfaceProperty(this->BackfaceProperty);
563 this->Device->SetProperty(this->Property);
564 if(myShape.ShapeType() == TopAbs_VERTEX) {
566 //The parameter determine size of vertex actor relate to diagonal of RendererWindow
567 static vtkFloatingPointType delta = 0.01;
568 vtkFloatingPointType X1 = -1, Y1 = -1, Z1 = 0;
569 ren->ViewToWorld(X1,Y1,Z1);
570 vtkFloatingPointType X2 = +1, Y2 = +1, Z2 = 0;
571 ren->ViewToWorld(X2,Y2,Z2);
572 Z2 = sqrt((X2-X1)*(X2-X1) + (Y2-Y1)*(Y2-Y1) + (Z2-Z1)*(Z2-Z1));
573 this->SetScale(Z2*delta);
575 vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New();
576 this->GetMatrix(ren->GetActiveCamera(), aMatrix);
577 this->Device->SetUserMatrix(aMatrix);
578 this->Device->Render(ren,this->Mapper);
581 this->Device->Render(ren, this->Mapper);
584 void GEOM_Actor::ReleaseGraphicsResources(vtkWindow *)
587 cout << "GEOM_Actor::ReleaseGraphicsResources"<<endl;
593 void GEOM_Actor::ShallowCopy(vtkProp *prop)
596 cout << "GEOM_Actor::ShallowCopy"<<endl;
598 GEOM_Actor *f = GEOM_Actor::SafeDownCast(prop);
601 this->SetShape(f->getTopo(),f->GetDeflection(),f->GetIsRelative());
605 this->SALOME_Actor::ShallowCopy(prop);
608 const TopoDS_Shape& GEOM_Actor::getTopo() {
610 cout << "GEOM_Actor::getTopo"<<endl;
615 void GEOM_Actor::setInputShape(const TopoDS_Shape& ashape, double adef1,
616 int imode, bool isVector)
619 cout << "GEOM_Actor::setInputShape"<<endl;
623 double GEOM_Actor::getDeflection()
626 cout << "GEOM_Actor::getDeflection"<<endl;
628 return (double) GetDeflection();
632 double GEOM_Actor::isVector()
635 cout << "GEOM_Actor::isVector"<<endl;
640 void GEOM_Actor::SubShapeOn()
643 cout << "GEOM_Actor::SubShapeOn"<<endl;
647 void GEOM_Actor::SubShapeOff()
650 cout << "GEOM_Actor::SubShapeOff"<<endl;
654 void GEOM_Actor::highlight(bool highlight)
657 cout << "GEOM_Actor::highlight highlight="<<highlight<<endl;
659 SALOME_Actor::highlight(highlight);
662 void GEOM_Actor::SetOpacity(vtkFloatingPointType opa)
665 myShadingFaceProp->SetOpacity(opa);
666 myHighlightProp->SetOpacity(opa);
667 myPreHighlightProp->SetOpacity(opa);
670 vtkFloatingPointType GEOM_Actor::GetOpacity()
673 return myShadingFaceProp->GetOpacity();
676 void GEOM_Actor::SetColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b)
679 myShadingFaceProp->SetColor(r,g,b);
682 void GEOM_Actor::GetColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b)
685 vtkFloatingPointType aRGB[3];
686 myShadingFaceProp->GetColor(aRGB);
692 bool GEOM_Actor::IsInfinite()
694 return (bool)(myShape.Infinite());
698 To map current selection to VTK representation
702 ::Highlight(bool theIsHighlight)
704 myIsSelected = theIsHighlight;
706 cout << "GEOM_Actor::Highlight myIsSelected="<<myIsSelected<<endl;
709 SALOME_Actor::Highlight(theIsHighlight); // this method call ::highlight(theIsHighlight) in the end
710 SetVisibility(GetVisibility());
715 To process prehighlight (called from SVTK_InteractorStyle)
719 ::PreHighlight(vtkInteractorStyle *theInteractorStyle,
720 SVTK_SelectionEvent* theSelectionEvent,
724 cout << "this="<<this<<" GEOM_Actor::PreHighlight (3) theIsHighlight="<<theIsHighlight<<endl;
726 if ( !GetPickable() )
729 myPreHighlightActor->SetVisibility( false );
730 bool anIsPreselected = myIsPreselected;
732 Selection_Mode aSelectionMode = theSelectionEvent->mySelectionMode;
733 bool anIsChanged = (mySelectionMode != aSelectionMode);
735 if( !theIsHighlight ) {
736 SetPreSelected( false );
738 switch(aSelectionMode){
739 case ActorSelection :
741 if( !mySelector->IsSelected( myIO ) ) {
742 SetPreSelected( true );
750 mySelectionMode = aSelectionMode;
751 anIsChanged |= (anIsPreselected != myIsPreselected);
753 SetVisibility(GetVisibility());
758 To process highlight (called from SVTK_InteractorStyle)
762 ::Highlight(vtkInteractorStyle *theInteractorStyle,
763 SVTK_SelectionEvent* theSelectionEvent,
766 // define the selection of object
768 cout << endl << "GEOM_Actor::Highlight (3) myIsSelected="<<myIsSelected<<endl;
770 bool aRet = SALOME_Actor::Highlight(theInteractorStyle,theSelectionEvent,theIsHighlight);
771 SetSelected(theIsHighlight);
776 // Copy the follower's composite 4x4 matrix into the matrix provided.
777 void GEOM_Actor::GetMatrix(vtkCamera* theCam, vtkMatrix4x4 *result)
780 double Rx[3], Ry[3], Rz[3], p1[3];
781 vtkMatrix4x4 *matrix = vtkMatrix4x4::New();
785 this->GetOrientation();
786 this->Transform->Push();
787 this->Transform->PostMultiply();
788 this->Transform->Identity();
790 // apply user defined matrix last if there is one
791 if (this->UserMatrix)
793 this->Transform->Concatenate(this->UserMatrix);
796 this->Transform->Translate(-this->Origin[0],
800 this->Transform->Scale(this->Scale[0],
805 this->Transform->RotateY(this->Orientation[1]);
806 this->Transform->RotateX(this->Orientation[0]);
807 this->Transform->RotateZ(this->Orientation[2]);
813 pos = theCam->GetPosition();
814 vup = theCam->GetViewUp();
816 if (theCam->GetParallelProjection())
818 theCam->GetDirectionOfProjection(Rz);
823 (pos[0] - this->Position[0])*(pos[0] - this->Position[0]) +
824 (pos[1] - this->Position[1])*(pos[1] - this->Position[1]) +
825 (pos[2] - this->Position[2])*(pos[2] - this->Position[2]));
826 for (i = 0; i < 3; i++)
828 Rz[i] = (pos[i] - this->Position[i])/distance;
832 vtkMath::Cross(vup,Rz,Rx);
833 vtkMath::Normalize(Rx);
834 vtkMath::Cross(Rz,Rx,Ry);
836 matrix->Element[0][0] = Rx[0];
837 matrix->Element[1][0] = Rx[1];
838 matrix->Element[2][0] = Rx[2];
839 matrix->Element[0][1] = Ry[0];
840 matrix->Element[1][1] = Ry[1];
841 matrix->Element[2][1] = Ry[2];
842 matrix->Element[0][2] = Rz[0];
843 matrix->Element[1][2] = Rz[1];
844 matrix->Element[2][2] = Rz[2];
846 this->Transform->Concatenate(matrix);
849 // translate to projection reference point PRP
850 // this is the camera's position blasted through
851 // the current matrix
852 p1[0] = this->Origin[0] + this->Position[0];
853 p1[1] = this->Origin[1] + this->Position[1];
854 p1[2] = this->Origin[2] + this->Position[2];
856 this->Transform->Translate(p1[0],p1[1],p1[2]);
857 this->Transform->GetMatrix(result);
860 this->Transform->Pop();