SetModified();
}
-void
-GEOM_Actor::
-SetShape(const TopoDS_Shape& theShape,
- float theDeflection,
- bool theIsRelative)
-{
- myShape = theShape;
-
- myVertexSource->Clear();
- myIsolatedEdgeSource->Clear();
- myOneFaceEdgeSource->Clear();
- mySharedEdgeSource->Clear();
- myWireframeFaceSource->Clear();
- myShadingFaceSource->Clear();
-
- TopExp_Explorer aVertexExp(theShape,TopAbs_VERTEX);
- for(; aVertexExp.More(); aVertexExp.Next()){
+void GEOM_Actor::SetShape (const TopoDS_Shape& theShape,
+ float theDeflection,
+ bool theIsRelative,
+ bool theIsVector)
+{
+ myShape = theShape;
+
+ myVertexSource->Clear();
+ myIsolatedEdgeSource->Clear();
+ myOneFaceEdgeSource->Clear();
+ mySharedEdgeSource->Clear();
+ myWireframeFaceSource->Clear();
+ myShadingFaceSource->Clear();
+
+ TopExp_Explorer aVertexExp (theShape,TopAbs_VERTEX);
+ for (; aVertexExp.More(); aVertexExp.Next())
+ {
const TopoDS_Vertex& aVertex = TopoDS::Vertex(aVertexExp.Current());
myVertexSource->AddVertex(aVertex);
- }
- SetDeflection(theDeflection,theIsRelative);
-
- // look if edges are free or shared
+ }
+ SetDeflection(theDeflection, theIsRelative);
+
+ // look if edges are free or shared
TopTools_IndexedDataMapOfShapeListOfShape anEdgeMap;
TopExp::MapShapesAndAncestors(theShape,TopAbs_EDGE,TopAbs_FACE,anEdgeMap);
- SetShape(theShape,anEdgeMap);
+ SetShape(theShape,anEdgeMap,theIsVector);
}
-void
-GEOM_Actor::
-SetShape(const TopoDS_Shape& theShape,
- const TopTools_IndexedDataMapOfShapeListOfShape& theEdgeMap)
-{
- if(theShape.ShapeType() == TopAbs_COMPOUND) {
+void GEOM_Actor::SetShape (const TopoDS_Shape& theShape,
+ const TopTools_IndexedDataMapOfShapeListOfShape& theEdgeMap,
+ bool theIsVector)
+{
+ if (theShape.ShapeType() == TopAbs_COMPOUND) {
TopoDS_Iterator anItr(theShape);
- for(; anItr.More(); anItr.Next()) {
- SetShape(anItr.Value(),theEdgeMap);
+ for (; anItr.More(); anItr.Next()) {
+ SetShape(anItr.Value(),theEdgeMap,theIsVector);
}
}
- switch(theShape.ShapeType()){
+ switch (theShape.ShapeType()) {
case TopAbs_WIRE: {
TopExp_Explorer anEdgeExp(theShape,TopAbs_EDGE);
- for(; anEdgeExp.More(); anEdgeExp.Next()){
+ for (; anEdgeExp.More(); anEdgeExp.Next()){
const TopoDS_Edge& anEdge = TopoDS::Edge(anEdgeExp.Current());
- if(!BRep_Tool::Degenerated(anEdge))
- myIsolatedEdgeSource->AddEdge(anEdge);
+ if (!BRep_Tool::Degenerated(anEdge))
+ myIsolatedEdgeSource->AddEdge(anEdge,theIsVector);
}
break;
}
case TopAbs_EDGE: {
const TopoDS_Edge& anEdge = TopoDS::Edge(theShape);
- if(!BRep_Tool::Degenerated(anEdge))
- myIsolatedEdgeSource->AddEdge(anEdge);
+ if (!BRep_Tool::Degenerated(anEdge))
+ myIsolatedEdgeSource->AddEdge(anEdge,theIsVector);
break;
}
case TopAbs_VERTEX: {
break;
}
default: {
- TopExp_Explorer aFaceExp(theShape,TopAbs_FACE);
- for(; aFaceExp.More(); aFaceExp.Next()) {
+ TopExp_Explorer aFaceExp (theShape,TopAbs_FACE);
+ for(; aFaceExp.More(); aFaceExp.Next()) {
const TopoDS_Face& aFace = TopoDS::Face(aFaceExp.Current());
myWireframeFaceSource->AddFace(aFace);
myShadingFaceSource->AddFace(aFace);
TopExp_Explorer anEdgeExp(aFaceExp.Current(), TopAbs_EDGE);
for(; anEdgeExp.More(); anEdgeExp.Next()) {
- const TopoDS_Edge& anEdge = TopoDS::Edge(anEdgeExp.Current());
+ const TopoDS_Edge& anEdge = TopoDS::Edge(anEdgeExp.Current());
if(!BRep_Tool::Degenerated(anEdge)){
// compute the number of faces
int aNbOfFaces = theEdgeMap.FindFromKey(anEdge).Extent();
- switch(aNbOfFaces){
+ switch(aNbOfFaces){
case 0: // isolated edge
- myIsolatedEdgeSource->AddEdge(anEdge);
+ myIsolatedEdgeSource->AddEdge(anEdge,theIsVector);
break;
case 1: // edge in only one face
- myOneFaceEdgeSource->AddEdge(anEdge);
+ myOneFaceEdgeSource->AddEdge(anEdge,theIsVector);
break;
default: // edge shared by at least two faces
- mySharedEdgeSource->AddEdge(anEdge);
+ mySharedEdgeSource->AddEdge(anEdge,theIsVector);
}
}
- }
+ }
}
}
- }
-}
+ }
+}
// OLD METHODS
void GEOM_Actor::setDeflection(double adef) {
#include "GEOM_OBJECT_defs.hxx"
#include "SALOME_Actor.h"
-
+
#include <TopoDS_Shape.hxx>
-
+
#include "GEOM_SmartPtr.h"
#include <vtkSmartPointer.h>
-
-class GEOM_VertexSource;
-typedef GEOM_SmartPtr<GEOM_VertexSource> PVertexSource;
-
-class GEOM_EdgeSource;
-typedef GEOM_SmartPtr<GEOM_EdgeSource> PEdgeSource;
-
-class GEOM_WireframeFace;
-typedef GEOM_SmartPtr<GEOM_WireframeFace> PWFaceSource;
-
-class GEOM_ShadingFace;
-typedef GEOM_SmartPtr<GEOM_ShadingFace> PSFaceSource;
-
-#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
-class vtkRenderer;
-
-class vtkAppendPolyData;
-typedef GEOM_SmartPtr<vtkAppendPolyData> PAppendFilter;
+
+class GEOM_VertexSource;
+typedef GEOM_SmartPtr<GEOM_VertexSource> PVertexSource;
+
+class GEOM_EdgeSource;
+typedef GEOM_SmartPtr<GEOM_EdgeSource> PEdgeSource;
+
+class GEOM_WireframeFace;
+typedef GEOM_SmartPtr<GEOM_WireframeFace> PWFaceSource;
+
+class GEOM_ShadingFace;
+typedef GEOM_SmartPtr<GEOM_ShadingFace> PSFaceSource;
+
+#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
+class vtkRenderer;
+
+class vtkAppendPolyData;
+typedef GEOM_SmartPtr<vtkAppendPolyData> PAppendFilter;
class GEOM_OBJECT_EXPORT GEOM_Actor: public SALOME_Actor
-{
-public:
- vtkTypeMacro(GEOM_Actor,SALOME_Actor);
- static GEOM_Actor* New();
-
- void SetShape(const TopoDS_Shape& theShape,
- float theDeflection,
- bool theIsRelative);
-
- void SetDeflection(float theDeflection, bool theIsRelative);
- float GetDeflection() const{ return myDeflection;}
- bool GetIsRelative() const{ return myIsRelative;}
-
- void AddToRender(vtkRenderer* theRenderer);
+{
+public:
+ vtkTypeMacro(GEOM_Actor,SALOME_Actor);
+ static GEOM_Actor* New();
+
+ void SetShape(const TopoDS_Shape& theShape,
+ float theDeflection,
+ bool theIsRelative,
+ bool theIsVector = false);
+
+ void SetDeflection(float theDeflection, bool theIsRelative);
+ float GetDeflection() const{ return myDeflection;}
+ bool GetIsRelative() const{ return myIsRelative;}
+
+ void AddToRender(vtkRenderer* theRenderer);
void RemoveFromRender(vtkRenderer* theRenderer);
enum EDisplayMode{ eWireframe, eShading};
-
+
/* void SetDisplayMode(EDisplayMode theMode); */
/* EDisplayMode GetDisplayMode() const { return myDisplayMode;} */
-
- void SetSelected(bool theIsSelected);
- bool IsSelected() const { return myIsSelected;}
+
+ void SetSelected(bool theIsSelected);
+ bool IsSelected() const { return myIsSelected;}
// OLD METHODS
// Properties
// SubShape
void SubShapeOn();
void SubShapeOff();
-
+
// Highlight
virtual void highlight(bool theHighlight);
virtual bool hasHighlight() { return true; }
virtual
void
Highlight(bool theHighlight);
-
+
//----------------------------------------------------------------------------
//! To process prehighlight (called from #SVTK_InteractorStyle)
virtual
bool
- PreHighlight(vtkInteractorStyle* theInteractorStyle,
+ PreHighlight(vtkInteractorStyle* theInteractorStyle,
SVTK_SelectionEvent* theSelectionEvent,
bool theIsHighlight);
//! To process highlight (called from #SVTK_InteractorStyle)
- virtual
+ virtual
bool
- Highlight(vtkInteractorStyle* theInteractorStyle,
+ Highlight(vtkInteractorStyle* theInteractorStyle,
SVTK_SelectionEvent* theSelectionEvent,
bool theIsHighlight);
virtual
void
SetNbIsos(const int theNb[2]);
-
+
virtual
void
GetNbIsos(int &theNbU,int &theNbV);
-
-protected:
- void SetShape(const TopoDS_Shape& theShape,
- const TopTools_IndexedDataMapOfShapeListOfShape& theEdgeMap);
-
- void SetModified();
+
+protected:
+ void SetShape(const TopoDS_Shape& theShape,
+ const TopTools_IndexedDataMapOfShapeListOfShape& theEdgeMap,
+ bool theIsVector = false);
+
+ void SetModified();
void GetMatrix(vtkCamera* theCam, vtkMatrix4x4 *result);
-
- GEOM_Actor();
- ~GEOM_Actor();
-
-private:
+
+ GEOM_Actor();
+ ~GEOM_Actor();
+
+private:
TopoDS_Shape myShape;
int myNbIsos[2];
-
- float myDeflection;
- bool myIsRelative;
- bool myIsForced;
-
- // EDisplayMode myDisplayMode;
- bool myIsSelected;
-
- PDeviceActor myVertexActor;
- PVertexSource myVertexSource;
-
- PDeviceActor myIsolatedEdgeActor;
- PEdgeSource myIsolatedEdgeSource;
-
- PDeviceActor myOneFaceEdgeActor;
- PEdgeSource myOneFaceEdgeSource;
-
- PDeviceActor mySharedEdgeActor;
- PEdgeSource mySharedEdgeSource;
-
- PDeviceActor myWireframeFaceActor;
- PWFaceSource myWireframeFaceSource;
-
- PDeviceActor myShadingFaceActor;
- PSFaceSource myShadingFaceSource;
-
+
+ float myDeflection;
+ bool myIsRelative;
+ bool myIsForced;
+
+ // EDisplayMode myDisplayMode;
+ bool myIsSelected;
+
+ PDeviceActor myVertexActor;
+ PVertexSource myVertexSource;
+
+ PDeviceActor myIsolatedEdgeActor;
+ PEdgeSource myIsolatedEdgeSource;
+
+ PDeviceActor myOneFaceEdgeActor;
+ PEdgeSource myOneFaceEdgeSource;
+
+ PDeviceActor mySharedEdgeActor;
+ PEdgeSource mySharedEdgeSource;
+
+ PDeviceActor myWireframeFaceActor;
+ PWFaceSource myWireframeFaceSource;
+
+ PDeviceActor myShadingFaceActor;
+ PSFaceSource myShadingFaceSource;
+
PDeviceActor myHighlightActor;
vtkSmartPointer<vtkProperty> myHighlightProp;
vtkSmartPointer<vtkProperty> myPreHighlightProp;
vtkSmartPointer<vtkProperty> myShadingFaceProp;
-
- PAppendFilter myAppendFilter;
- PPolyDataMapper myPolyDataMapper;
-
- virtual void SetMapper(vtkMapper*);
-
- GEOM_Actor(const GEOM_Actor&);
- void operator=(const GEOM_Actor&);
-};
-
-#endif //GEOM_ACTOR_H
+
+ PAppendFilter myAppendFilter;
+ PPolyDataMapper myPolyDataMapper;
+
+ virtual void SetMapper(vtkMapper*);
+
+ GEOM_Actor(const GEOM_Actor&);
+ void operator=(const GEOM_Actor&);
+};
+
+#endif //GEOM_ACTOR_H
vtkActorCollection* AISActors = vtkActorCollection::New();
MeshShape(myShape,deflection,forced);
GEOM_Actor* aGeomActor = GEOM_Actor::New();
- aGeomActor->SetShape(myShape,(float)deflection,false);
+ aGeomActor->SetShape(myShape,(float)deflection,false,isVector);
AISActors->AddItem(aGeomActor);
aGeomActor->Delete();
GEOM_EdgeSource::~GEOM_EdgeSource()
{
}
-
-void
-GEOM_EdgeSource::
-AddEdge(const TopoDS_Edge& theEdge)
-{
- myEdgeSet.Add(theEdge);
-}
-
+
+void GEOM_EdgeSource::AddEdge (const TopoDS_Edge& theEdge,
+ bool theIsVector)
+{
+ myEdgeSet.Add(theEdge);
+ myIsVector = theIsVector;
+}
+
void
GEOM_EdgeSource::
Execute()
aPolyData->SetPoints(aPts);
aPts->Delete();
- TEdgeSet::Iterator anIter(myEdgeSet);
- for(; anIter.More(); anIter.Next()){
+ TEdgeSet::Iterator anIter (myEdgeSet);
+ for (; anIter.More(); anIter.Next()) {
const TopoDS_Edge& anEdge = anIter.Value();
- OCC2VTK(anEdge,aPolyData,aPts);
+ OCC2VTK(anEdge,aPolyData,aPts,myIsVector);
}
}
-void
-GEOM_EdgeSource::
-OCC2VTK(const TopoDS_Edge& theEdge,
- vtkPolyData* thePolyData,
- vtkPoints* thePts)
+void GEOM_EdgeSource::OCC2VTK (const TopoDS_Edge& theEdge,
+ vtkPolyData* thePolyData,
+ vtkPoints* thePts,
+ bool theIsVector)
{
Handle(Poly_PolygonOnTriangulation) aEdgePoly;
Standard_Integer i = 1;
Handle(Poly_Triangulation) T;
TopLoc_Location aEdgeLoc;
BRep_Tool::PolygonOnTriangulation(theEdge, aEdgePoly, T, aEdgeLoc, i);
-
+
Handle(Poly_Polygon3D) P;
if(aEdgePoly.IsNull())
P = BRep_Tool::Polygon3D(theEdge, aEdgeLoc);
edgeTransf = aEdgeLoc.Transformation();
}
+ gp_Pnt aP1, aP2;
+
if (aEdgePoly.IsNull()) {
Standard_Integer aNbNodes = P->NbNodes();
const TColgp_Array1OfPnt& aNodesP = P->Nodes();
- for(int j = 1; j < aNbNodes; j++){
+ aP1 = aNodesP(1);
+ aP2 = aNodesP(aNbNodes);
+
+ for (int j = 1; j < aNbNodes; j++) {
gp_Pnt pt1 = aNodesP(j);
gp_Pnt pt2 = aNodesP(j+1);
-
- if(!isidtrsf) {
- // apply edge transformation
- pt1.Transform(edgeTransf);
- pt2.Transform(edgeTransf);
+
+ if (!isidtrsf) {
+ // apply edge transformation
+ pt1.Transform(edgeTransf);
+ pt2.Transform(edgeTransf);
}
-
+
float aCoord1[3] = {pt1.X(), pt1.Y(), pt1.Z()};
vtkIdType anIds[2];
anIds[0] = thePts->InsertNextPoint(aCoord1);
-
+
float aCoord2[3] = {pt2.X(), pt2.Y(), pt2.Z()};
anIds[1] = thePts->InsertNextPoint(aCoord2);
const TColStd_Array1OfInteger& aNodeIds = aEdgePoly->Nodes();
const TColgp_Array1OfPnt& anId2Pnts = T->Nodes();
+ aP1 = anId2Pnts(1);
+ aP2 = anId2Pnts(aNbNodes);
+
for(int j = 1; j < aNbNodes; j++) {
Standard_Integer id1 = aNodeIds(j);
Standard_Integer id2 = aNodeIds(j+1);
if(!isidtrsf) {
// apply edge transformation
- pt1.Transform(edgeTransf);
- pt2.Transform(edgeTransf);
+ pt1.Transform(edgeTransf);
+ pt2.Transform(edgeTransf);
}
float aCoord1[3] = {pt1.X(), pt1.Y(), pt1.Z()};
vtkIdType anIds[2];
anIds[0] = thePts->InsertNextPoint(aCoord1);
-
+
float aCoord2[3] = {pt2.X(), pt2.Y(), pt2.Z()};
anIds[1] = thePts->InsertNextPoint(aCoord2);
thePolyData->InsertNextCell(VTK_LINE,2,anIds);
}
}
-}
\ No newline at end of file
+
+ // vector representation has an arrow on its end
+ if (theIsVector)
+ {
+ if (!isidtrsf) {
+ // apply edge transformation
+ aP1.Transform(edgeTransf);
+ aP2.Transform(edgeTransf);
+ }
+
+ // draw an arrow
+ gp_Vec aDirVec (aP1, aP2);
+ Standard_Real aDist = aDirVec.Magnitude();
+ if (aDist < gp::Resolution()) return;
+ gp_Dir aDirection (aDirVec);
+
+ Standard_Real anAngle = PI/180.*5.;
+ Standard_Real aLength = aDist/10.;
+
+ Standard_Real dx,dy,dz;
+ aDirection.Coord(dx,dy,dz);
+
+ // Pointe de la fleche
+ Standard_Real xo,yo,zo;
+ aP2.Coord(xo,yo,zo);
+
+ // Centre du cercle base de la fleche
+ gp_XYZ aPc = aP2.XYZ() - aDirection.XYZ() * aLength;
+
+ // Construction d'un repere i,j pour le cercle
+ gp_Dir aDirN;
+ if (Abs(dx) <= Abs(dy) && Abs(dx) <= Abs(dz)) aDirN = gp::DX();
+ else if (Abs(dy) <= Abs(dz) && Abs(dy) <= Abs(dx)) aDirN = gp::DY();
+ else aDirN = gp::DZ();
+
+ gp_Dir aDirI = aDirection ^ aDirN;
+ gp_Dir aDirJ = aDirection ^ aDirI;
+
+ // Add points and segments, composing the arrow
+ Standard_Real cosinus, sinus, Tg = tan(anAngle);
+
+ float coord[3] = {xo, yo, zo};
+
+ vtkIdType ptLoc = thePts->InsertNextPoint(coord);
+ vtkIdType ptFirst = 0;
+ vtkIdType ptPrev = 0;
+ vtkIdType ptCur = 0;
+
+ vtkIdType pts[2];
+
+ int NbPoints = 15;
+ for (int i = 1; i <= NbPoints; i++, ptPrev = ptCur)
+ {
+ cosinus = cos(2. * PI / NbPoints * (i-1));
+ sinus = sin(2. * PI / NbPoints * (i-1));
+
+ gp_XYZ aP = aPc + (aDirI.XYZ() * cosinus + aDirJ.XYZ() * sinus) * aLength * Tg;
+ coord[0] = aP.X();
+ coord[1] = aP.Y();
+ coord[2] = aP.Z();
+
+ // insert pts
+ ptCur = thePts->InsertNextPoint(coord);
+ pts[0] = ptCur;
+
+ if (i == 1) {
+ ptFirst = ptCur;
+ }
+ else {
+ // insert line (ptCur,ptPrev)
+ pts[1] = ptPrev;
+ thePolyData->InsertNextCell(VTK_LINE,2,pts);
+ }
+
+ // insert line (ptCur,ptLoc)
+ pts[1] = ptLoc;
+ thePolyData->InsertNextCell(VTK_LINE,2,pts);
+ }
+
+ // insert line (ptCur,ptFirst)
+ pts[0] = ptCur;
+ pts[1] = ptFirst;
+ thePolyData->InsertNextCell(VTK_LINE,2,pts);
+ }
+}
vtkTypeMacro(GEOM_EdgeSource,vtkPolyDataSource);
static GEOM_EdgeSource* New();
- void AddEdge(const TopoDS_Edge& theEdge);
+ void AddEdge (const TopoDS_Edge& theEdge,
+ bool theIsVector = false);
void Clear(){ myEdgeSet.Clear();}
static
void OCC2VTK(const TopoDS_Edge& theEdge,
vtkPolyData* thePolyData,
- vtkPoints* thePts);
+ vtkPoints* thePts,
+ bool theIsVector = false);
protected:
- TEdgeSet myEdgeSet;
+ TEdgeSet myEdgeSet;
+ // The <myIsVector> flag is common for all edges, because the shape,
+ // representing a vector, can have only one edge.
+ bool myIsVector;
void Execute();
