static Standard_Boolean myFirstCompute;
Standard_Real AIS_Shape::GetDeflection(const TopoDS_Shape& aShape,
- const Handle(Prs3d_Drawer)& aDrawer)
+ const Handle(Prs3d_Drawer)& aDrawer)
{
// WARNING: this same piece of code appears several times in Prs3d classes
- Standard_Real aDeflection;
+ Standard_Real aDeflection = aDrawer->MaximalChordialDeviation();
if (aDrawer->TypeOfDeflection() == Aspect_TOD_RELATIVE) {
Bnd_Box B;
- BRepBndLib::Add(aShape, B);
+ BRepBndLib::Add(aShape, B, Standard_False);
if ( ! B.IsVoid() )
{
Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax;
aDeflection = Max( aXmax-aXmin, Max(aYmax-aYmin, aZmax-aZmin)) *
aDrawer->DeviationCoefficient() * 4;
}
- else
- aDeflection = aDrawer->MaximalChordialDeviation();
}
- else
- aDeflection = aDrawer->MaximalChordialDeviation();
return aDeflection;
}
void AIS_Shape::DisplayBox(const Handle(Prs3d_Presentation)& aPrs,
- const Bnd_Box& B,
- const Handle(Prs3d_Drawer)& aDrawer)
+ const Bnd_Box& B,
+ const Handle(Prs3d_Drawer)& aDrawer)
{
Standard_Real X[2],Y[2],Z[2];
Standard_Integer Indx [16] ;
for(Standard_Integer k=0;k<=1;k++)
for(Standard_Integer j=0;j<=1;j++)
for(Standard_Integer i=0;i<=1;i++)
- V(++Rank) = Graphic3d_Vertex(X[i],Y[j],Z[k]);
+ V(++Rank) = Graphic3d_Vertex(X[i],Y[j],Z[k]);
Handle(Graphic3d_Group) G = Prs3d_Root::CurrentGroup(aPrs);
}
G->EndPrimitives();
}
-
+
static Standard_Boolean IsInList(const TColStd_ListOfInteger& LL, const Standard_Integer aMode)
{
TColStd_ListIteratorOfListOfInteger It(LL);
//purpose :
//=======================================================================
void AIS_Shape::Compute(const Handle(PrsMgr_PresentationManager3d)& /*aPresentationManager*/,
- const Handle(Prs3d_Presentation)& aPrs,
- const Standard_Integer aMode)
+ const Handle(Prs3d_Presentation)& aPrs,
+ const Standard_Integer aMode)
{
aPrs->Clear();
if(myshape.IsNull()) return;
if (OwnDeviationAngle(newangle,prevangle) ||
- OwnDeviationCoefficient(newcoeff,prevcoeff))
- if (Abs (newangle - prevangle) > Precision::Angular() ||
- Abs (newcoeff - prevcoeff) > Precision::Confusion() ) {
+ OwnDeviationCoefficient(newcoeff,prevcoeff))
+ if (Abs (newangle - prevangle) > Precision::Angular() ||
+ Abs (newcoeff - prevcoeff) > Precision::Confusion() ) {
#ifdef DEB
- cout << "AIS_Shape : compute"<<endl;
- cout << "newangl : " << newangle << " # de " << "prevangl : " << prevangle << " OU "<<endl;
- cout << "newcoeff : " << newcoeff << " # de " << "prevcoeff : " << prevcoeff << endl;
+ cout << "AIS_Shape : compute"<<endl;
+ cout << "newangl : " << newangle << " # de " << "prevangl : " << prevangle << " OU "<<endl;
+ cout << "newcoeff : " << newcoeff << " # de " << "prevcoeff : " << prevcoeff << endl;
#endif
- BRepTools::Clean(myshape);
- }
+ BRepTools::Clean(myshape);
+ }
//shading only on face...
if ((Standard_Integer) myshape.ShapeType()>4)
- StdPrs_WFDeflectionShape::Add(aPrs,myshape,myDrawer);
+ StdPrs_WFDeflectionShape::Add(aPrs,myshape,myDrawer);
else {
- myDrawer->SetShadingAspectGlobal(Standard_False);
- if (IsInfinite()) StdPrs_WFDeflectionShape::Add(aPrs,myshape,myDrawer);
- else {
- {
- try {
- OCC_CATCH_SIGNALS
- StdPrs_ShadedShape::Add(aPrs,myshape,myDrawer);
- }
- catch (Standard_Failure) {
+ myDrawer->SetShadingAspectGlobal(Standard_False);
+ if (IsInfinite()) StdPrs_WFDeflectionShape::Add(aPrs,myshape,myDrawer);
+ else {
+ {
+ try {
+ OCC_CATCH_SIGNALS
+ StdPrs_ShadedShape::Add(aPrs,myshape,myDrawer);
+ }
+ catch (Standard_Failure) {
#ifdef DEB
- cout << "AIS_Shape::Compute() in ShadingMode failed"<< endl;
+ cout << "AIS_Shape::Compute() in ShadingMode failed"<< endl;
#endif
- StdPrs_WFShape::Add(aPrs,myshape,myDrawer);
- }
- }
- }
+ StdPrs_WFShape::Add(aPrs,myshape,myDrawer);
+ }
+ }
+ }
}
#ifdef BUC60918
Standard_Real value = Transparency() ;
if( value > 0. ) {
- SetTransparency( value );
+ SetTransparency( value );
}
#endif
break;
//=======================================================================
void AIS_Shape::Compute(const Handle(PrsMgr_PresentationManager2d)& /*aPresentationManager*/,
- const Handle(Graphic2d_GraphicObject)& /*aGRO*/,
- const Standard_Integer /*aMode*/)
+ const Handle(Graphic2d_GraphicObject)& /*aGRO*/,
+ const Standard_Integer /*aMode*/)
{
}
//purpose : Hidden Line Removal
//=======================================================================
void AIS_Shape::Compute(const Handle(Prs3d_Projector)& aProjector,
- const Handle(Prs3d_Presentation)& aPresentation)
+ const Handle(Prs3d_Presentation)& aPresentation)
{
Compute(aProjector,aPresentation,myshape);
}
//=======================================================================
void AIS_Shape::Compute(const Handle(Prs3d_Projector)& aProjector,
- const Handle(Geom_Transformation)& TheTrsf,
- const Handle(Prs3d_Presentation)& aPresentation)
+ const Handle(Geom_Transformation)& TheTrsf,
+ const Handle(Prs3d_Presentation)& aPresentation)
{
const TopLoc_Location& loc = myshape.Location();
TopoDS_Shape shbis = myshape.Located(TopLoc_Location(TheTrsf->Trsf())*loc);
//=======================================================================
void AIS_Shape::Compute(const Handle(Prs3d_Projector)& aProjector,
- const Handle(Prs3d_Presentation)& aPresentation,
- const TopoDS_Shape& SH)
+ const Handle(Prs3d_Presentation)& aPresentation,
+ const TopoDS_Shape& SH)
{
if (SH.ShapeType() == TopAbs_COMPOUND) {
#ifdef BUC60547
if (OwnHLRDeviationAngle(newangle,prevangle) || OwnHLRDeviationCoefficient(newcoeff, prevcoeff))
if (Abs (newangle - prevangle) > Precision::Angular() ||
- Abs (newcoeff - prevcoeff) > Precision::Confusion() ) {
+ Abs (newcoeff - prevcoeff) > Precision::Confusion() ) {
#ifdef DEB
cout << "AIS_Shape : compute"<<endl;
cout << "newangle : " << newangle << " # de " << "prevangl : " << prevangle << " OU "<<endl;
//=======================================================================
void AIS_Shape::ComputeSelection(const Handle(SelectMgr_Selection)& aSelection,
- const Standard_Integer aMode)
+ const Standard_Integer aMode)
{
if(myshape.IsNull()) return;
if (myshape.ShapeType() == TopAbs_COMPOUND) {
// POP protection against crash in low layers
- Standard_Real aDeflection = myDrawer->MaximalChordialDeviation();
- if (myDrawer->TypeOfDeflection() == Aspect_TOD_RELATIVE)
- {
- // Vector is calculated depending on global min max of the part:
- Bnd_Box aBndBox; //= BoundingBox(); ?
- BRepBndLib::Add (shape, aBndBox);
- if (!aBndBox.IsVoid())
- {
- Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax;
- aBndBox.Get (aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
- aDeflection = Max (aXmax - aXmin, Max (aYmax - aYmin, aZmax - aZmin)) * myDrawer->DeviationCoefficient();
- }
- }
-
+ Standard_Real aDeflection = GetDeflection(shape, myDrawer);
Standard_Boolean autoTriangulation = Standard_True;
try {
OCC_CATCH_SIGNALS
shape,
TypOfSel,
aDeflection,
- myDrawer->DeviationAngle(),
+ myDrawer->HLRAngle(),
autoTriangulation);
} catch ( Standard_Failure ) {
// cout << "a Shape should be incorrect : A Selection on the Bnd is activated "<<endl;
hasOwnColor = Standard_True;
#ifdef GER61351
if( !HasColor() && !IsTransparent() && !HasMaterial() ) {
- myDrawer->SetShadingAspect(new Prs3d_ShadingAspect());
+ myDrawer->SetShadingAspect(new Prs3d_ShadingAspect());
}
#else
myOwnColor = aCol;
{
#ifdef GER61351
if( !HasColor() && !IsTransparent() && !HasMaterial() ) {
- myDrawer->SetShadingAspect(new Prs3d_ShadingAspect());
+ myDrawer->SetShadingAspect(new Prs3d_ShadingAspect());
}
myDrawer->ShadingAspect()->SetMaterial(aMat,myCurrentFacingModel);
hasOwnMaterial = Standard_True;
{
#ifdef GER61351
if( !HasColor() && !IsTransparent() && !HasMaterial() ) {
- myDrawer->SetShadingAspect(new Prs3d_ShadingAspect());
+ myDrawer->SetShadingAspect(new Prs3d_ShadingAspect());
}
myDrawer->ShadingAspect()->SetMaterial(aMat,myCurrentFacingModel);
hasOwnMaterial = Standard_True;
if( HasColor() || IsTransparent()) {
Graphic3d_MaterialAspect mat = AIS_GraphicTool::GetMaterial(myDrawer->Link());
if( HasColor() ) {
- Quantity_Color color = myDrawer->ShadingAspect()->Color(myCurrentFacingModel);
+ Quantity_Color color = myDrawer->ShadingAspect()->Color(myCurrentFacingModel);
mat.SetColor(color);
}
if( IsTransparent() ) {
- Standard_Real trans = myDrawer->ShadingAspect()->Transparency(myCurrentFacingModel);
+ Standard_Real trans = myDrawer->ShadingAspect()->Transparency(myCurrentFacingModel);
mat.SetTransparency(trans);
}
myDrawer->ShadingAspect()->SetMaterial(mat,myCurrentFacingModel);
Handle(Graphic3d_AspectFillArea3d) a4bis = myDrawer->ShadingAspect()->Aspect();
P->SetPrimitivesAspect(a4bis);
-#ifdef BUC60918 //force highest priority for transparent objects
- P->SetDisplayPriority(10);
+#ifdef BUC60918 //force highest priority for transparent objects
+ P->SetDisplayPriority(10);
#endif
G->SetGroupPrimitivesAspect(a4bis);
}
Handle(Graphic3d_AspectFillArea3d) a4bis = myDrawer->ShadingAspect()->Aspect();
P->SetPrimitivesAspect(a4bis);
G->SetGroupPrimitivesAspect(a4bis);
-#ifdef BUC60918
+#ifdef BUC60918
P->ResetDisplayPriority();
#endif
}
//=======================================================================
Standard_Boolean AIS_Shape::OwnDeviationCoefficient ( Standard_Real & aCoefficient,
- Standard_Real & aPreviousCoefficient ) const
+ Standard_Real & aPreviousCoefficient ) const
{
aCoefficient = myDrawer->DeviationCoefficient();
aPreviousCoefficient = myDrawer->PreviousDeviationCoefficient ();
//=======================================================================
Standard_Boolean AIS_Shape::OwnHLRDeviationCoefficient ( Standard_Real & aCoefficient,
- Standard_Real & aPreviousCoefficient ) const
+ Standard_Real & aPreviousCoefficient ) const
{
aCoefficient = myDrawer->HLRDeviationCoefficient();
aPreviousCoefficient = myDrawer->PreviousHLRDeviationCoefficient ();
//=======================================================================
Standard_Boolean AIS_Shape::OwnDeviationAngle ( Standard_Real & anAngle,
- Standard_Real & aPreviousAngle ) const
+ Standard_Real & aPreviousAngle ) const
{
anAngle = myDrawer->DeviationAngle();
aPreviousAngle = myDrawer->PreviousDeviationAngle ();
//=======================================================================
Standard_Boolean AIS_Shape::OwnHLRDeviationAngle ( Standard_Real & anAngle,
- Standard_Real & aPreviousAngle ) const
+ Standard_Real & aPreviousAngle ) const
{
anAngle = myDrawer->HLRAngle();
aPreviousAngle = myDrawer->PreviousHLRDeviationAngle ();
return myDrawer->IsOwnHLRDeviationAngle();
-
}
-- Package methods for shapes
--
- Add(S : Shape from TopoDS; B : in out Box from Bnd);
+ Add(S : Shape from TopoDS;
+ B : in out Box from Bnd;
+ useTriangulation: Boolean from Standard = Standard_True);
---Purpose:Adds the shape S to the bounding box B.
-- More precisely are successively added to B:
-- - each face of S; the triangulation of the face is used if it exists,
//purpose : Add a shape bounding to a box
//=======================================================================
-void BRepBndLib::Add(const TopoDS_Shape& S, Bnd_Box& B)
+void BRepBndLib::Add(const TopoDS_Shape& S, Bnd_Box& B, Standard_Boolean useTriangulation)
{
TopExp_Explorer ex;
// Add the faces
-
BRepAdaptor_Surface BS;
Handle(Geom_Surface) GS;
Handle(Poly_Triangulation) T;
for (ex.Init(S,TopAbs_FACE); ex.More(); ex.Next()) {
const TopoDS_Face& F = TopoDS::Face(ex.Current());
T = BRep_Tool::Triangulation(F, l);
- if (!T.IsNull()) {
+ if (useTriangulation && !T.IsNull())
+ {
nbNodes = T->NbNodes();
const TColgp_Array1OfPnt& Nodes = T->Nodes();
for (i = 1; i <= nbNodes; i++) {
- if (l.IsIdentity()) B.Add(Nodes(i));
- else B.Add(Nodes(i).Transformed(l));
+ if (l.IsIdentity()) B.Add(Nodes(i));
+ else B.Add(Nodes(i).Transformed(l));
}
// B.Enlarge(T->Deflection());
B.Enlarge(T->Deflection() + BRep_Tool::Tolerance(F));
- }
- else {
+ } else
+ {
GS = BRep_Tool::Surface(F, l);
if (!GS.IsNull()) {
- BS.Initialize(F, Standard_False);
- if (BS.GetType() != GeomAbs_Plane) {
- BS.Initialize(F);
- BndLib_AddSurface::Add(BS, BRep_Tool::Tolerance(F), B);
- }
- else {
- // on travaille directement sur les courbes 3d.
- TopExp_Explorer ex2(F, TopAbs_EDGE);
- if (!ex2.More()) {
- BS.Initialize(F);
- BndLib_AddSurface::Add(BS, BRep_Tool::Tolerance(F), B);
- }
- else {
- for (;ex2.More();ex2.Next()) {
- BC.Initialize(TopoDS::Edge(ex2.Current()));
- BndLib_Add3dCurve::Add(BC, BRep_Tool::Tolerance(F), B);
- }
- B.Enlarge(BRep_Tool::Tolerance(F));
- }
- }
+ BS.Initialize(F, Standard_False);
+ if (BS.GetType() != GeomAbs_Plane) {
+ BS.Initialize(F);
+ BndLib_AddSurface::Add(BS, BRep_Tool::Tolerance(F), B);
+ }
+ else {
+ // on travaille directement sur les courbes 3d.
+ TopExp_Explorer ex2(F, TopAbs_EDGE);
+ if (!ex2.More()) {
+ BS.Initialize(F);
+ BndLib_AddSurface::Add(BS, BRep_Tool::Tolerance(F), B);
+ }
+ else {
+ for (;ex2.More();ex2.Next()) {
+ BC.Initialize(TopoDS::Edge(ex2.Current()));
+ BndLib_Add3dCurve::Add(BC, BRep_Tool::Tolerance(F), B);
+ }
+ B.Enlarge(BRep_Tool::Tolerance(F));
+ }
+ }
}
}
}
// Add the edges not in faces
-
-
Handle(TColStd_HArray1OfInteger) HIndices;
Handle(Poly_PolygonOnTriangulation) Poly;
- for (ex.Init(S,TopAbs_EDGE,TopAbs_FACE); ex.More(); ex.Next()) {
+ for (ex.Init(S,TopAbs_EDGE,TopAbs_FACE); ex.More(); ex.Next())
+ {
const TopoDS_Edge& E = TopoDS::Edge(ex.Current());
Handle(Poly_Polygon3D) P3d = BRep_Tool::Polygon3D(E, l);
- if (!P3d.IsNull()) {
+ if (!P3d.IsNull())
+ {
const TColgp_Array1OfPnt& Nodes = P3d->Nodes();
nbNodes = P3d->NbNodes();
- for (i = 1; i <= nbNodes; i++) {
- if (l.IsIdentity()) B.Add(Nodes(i));
- else B.Add(Nodes(i).Transformed(l));
+ for (i = 1; i <= nbNodes; i++)
+ {
+ if (l.IsIdentity()) B.Add(Nodes(i));
+ else B.Add(Nodes(i).Transformed(l));
}
// B.Enlarge(P3d->Deflection());
B.Enlarge(P3d->Deflection() + BRep_Tool::Tolerance(E));
}
- else {
+ else
+ {
BRep_Tool::PolygonOnTriangulation(E, Poly, T, l);
- if (!Poly.IsNull()) {
- const TColStd_Array1OfInteger& Indices = Poly->Nodes();
- const TColgp_Array1OfPnt& Nodes = T->Nodes();
- nbNodes = Indices.Length();
- for (i = 1; i <= nbNodes; i++) {
- if (l.IsIdentity()) B.Add(Nodes(Indices(i)));
- else B.Add(Nodes(Indices(i)).Transformed(l));
- }
- // B.Enlarge(T->Deflection());
- B.Enlarge(Poly->Deflection() + BRep_Tool::Tolerance(E));
+ if (useTriangulation && !Poly.IsNull())
+ {
+ const TColStd_Array1OfInteger& Indices = Poly->Nodes();
+ const TColgp_Array1OfPnt& Nodes = T->Nodes();
+ nbNodes = Indices.Length();
+ for (i = 1; i <= nbNodes; i++)
+ {
+ if (l.IsIdentity()) B.Add(Nodes(Indices(i)));
+ else B.Add(Nodes(Indices(i)).Transformed(l));
+ }
+ // B.Enlarge(T->Deflection());
+ B.Enlarge(Poly->Deflection() + BRep_Tool::Tolerance(E));
}
else {
- if (BRep_Tool::IsGeometric(E)) {
- BC.Initialize(E);
- BndLib_Add3dCurve::Add(BC, BRep_Tool::Tolerance(E), B);
- }
+ if (BRep_Tool::IsGeometric(E))
+ {
+ BC.Initialize(E);
+ BndLib_Add3dCurve::Add(BC, BRep_Tool::Tolerance(E), B);
+ }
}
}
}
static Standard_Real GetDeflection(const anyShape& aShape,
- const Handle(Prs3d_Drawer)& aDrawer)
+ const Handle(Prs3d_Drawer)& aDrawer)
{
- Standard_Real aDeflection;
+ Standard_Real aDeflection = aDrawer->MaximalChordialDeviation();
if (aDrawer->TypeOfDeflection() == Aspect_TOD_RELATIVE) {
Bnd_Box B;
- BRepBndLib::Add(aShape, B);
+ BRepBndLib::Add(aShape, B, Standard_False);
if ( ! B.IsVoid() )
{
Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax;
B.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
aDeflection = MAX3( aXmax-aXmin , aYmax-aYmin , aZmax-aZmin)
- * aDrawer->DeviationCoefficient()*4;
+ * aDrawer->DeviationCoefficient()*4;
}
- else
- aDeflection = aDrawer->MaximalChordialDeviation();
}
- else
- aDeflection = aDrawer->MaximalChordialDeviation();
-
return aDeflection;
}
static Standard_Boolean ShadeFromShape(const anyShape& aShape,
- const Standard_Real /*defle*/,
- const Standard_Boolean /*share*/,
- const Handle (Prs3d_Presentation)& aPresentation,
- const Handle (Prs3d_Drawer)& aDrawer)
+ const Standard_Real /*defle*/,
+ const Standard_Boolean /*share*/,
+ const Handle (Prs3d_Presentation)& aPresentation,
+ const Handle (Prs3d_Drawer)& aDrawer)
{
+ anyShadedShapeTool SST;
+ Handle(Poly_Triangulation) T;
+ TopLoc_Location loc;
+ gp_Pnt p;
+ Standard_Integer i,j,k,decal ;
+ Standard_Integer t[3], n[3];
+ Standard_Integer nbTriangles = 0, nbVertices = 0;
- anyShadedShapeTool SST;
- Handle(Poly_Triangulation) T;
- TopLoc_Location loc;
- gp_Pnt p;
- Standard_Integer i,j,k,decal ;
- Standard_Integer t[3], n[3];
- Standard_Integer nbTriangles = 0, nbVertices = 0;
-
- // precision for compare square distances
- double dPreci = Precision::Confusion()*Precision::Confusion();
+ // precision for compare square distances
+ double dPreci = Precision::Confusion()*Precision::Confusion();
- if ( !aDrawer->ShadingAspectGlobal() ) {
+ if ( !aDrawer->ShadingAspectGlobal() ) {
- Handle(Graphic3d_AspectFillArea3d) Asp = aDrawer->ShadingAspect()->Aspect();
- if(anyShadedShapeTool::IsClosed(aShape)) {
- Asp->SuppressBackFace();
- } else {
- Asp->AllowBackFace();
- }
- Prs3d_Root::CurrentGroup(aPresentation)->SetPrimitivesAspect(Asp);
+ Handle(Graphic3d_AspectFillArea3d) Asp = aDrawer->ShadingAspect()->Aspect();
+ if(anyShadedShapeTool::IsClosed(aShape)) {
+ Asp->SuppressBackFace();
+ } else {
+ Asp->AllowBackFace();
}
+ Prs3d_Root::CurrentGroup(aPresentation)->SetPrimitivesAspect(Asp);
+ }
#ifdef G005
- if( Graphic3d_ArrayOfPrimitives::IsEnable() ) {
+ if( Graphic3d_ArrayOfPrimitives::IsEnable() ) {
+
+ for (SST.Init(aShape); SST.MoreFace(); SST.NextFace()) {
+ const anyTopFace& F = SST.CurrentFace();
+ T = SST.Triangulation(F, loc);
+ if (!T.IsNull()) {
+ nbTriangles += T->NbTriangles();
+ nbVertices += T->NbNodes();
+ }
+ }
+ if (nbVertices > 2 && nbTriangles > 0) {
+ Handle(Graphic3d_ArrayOfTriangles) parray =
+ new Graphic3d_ArrayOfTriangles(nbVertices,3*nbTriangles,
+ Standard_True,Standard_False,Standard_False,Standard_True);
for (SST.Init(aShape); SST.MoreFace(); SST.NextFace()) {
const anyTopFace& F = SST.CurrentFace();
T = SST.Triangulation(F, loc);
if (!T.IsNull()) {
- nbTriangles += T->NbTriangles();
- nbVertices += T->NbNodes();
- }
- }
+ const gp_Trsf& trsf = loc.Transformation();
+ Poly_Connect pc(T);
+ // Extracts vertices & normals from nodes
+ const TColgp_Array1OfPnt& Nodes = T->Nodes();
+ TColgp_Array1OfDir NORMAL(Nodes.Lower(), Nodes.Upper());
+ SST.Normal(F, pc, NORMAL);
- if (nbVertices > 2 && nbTriangles > 0) {
- Handle(Graphic3d_ArrayOfTriangles) parray =
- new Graphic3d_ArrayOfTriangles(nbVertices,3*nbTriangles,
- Standard_True,Standard_False,Standard_False,Standard_True);
- for (SST.Init(aShape); SST.MoreFace(); SST.NextFace()) {
- const anyTopFace& F = SST.CurrentFace();
- T = SST.Triangulation(F, loc);
- if (!T.IsNull()) {
- const gp_Trsf& trsf = loc.Transformation();
- Poly_Connect pc(T);
- // Extracts vertices & normals from nodes
- const TColgp_Array1OfPnt& Nodes = T->Nodes();
- TColgp_Array1OfDir NORMAL(Nodes.Lower(), Nodes.Upper());
- SST.Normal(F, pc, NORMAL);
+ decal = parray->VertexNumber();
+ for (i= Nodes.Lower(); i<= Nodes.Upper(); i++) {
+ p = Nodes(i);
+ if( !loc.IsIdentity() ) {
+ p.Transform(trsf);
+ NORMAL(i).Transform(trsf);
+ }
+ parray->AddVertex(p,NORMAL(i));
+ }
+
+ // Fill parray with vertex and edge visibillity info
+ const Poly_Array1OfTriangle& triangles = T->Triangles();
+ for (i = 1; i <= T->NbTriangles(); i++) {
+ pc.Triangles(i,t[0],t[1],t[2]);
+ if (SST.Orientation(F) == TopAbs_REVERSED)
+ triangles(i).Get(n[0],n[2],n[1]);
+ else
+ triangles(i).Get(n[0],n[1],n[2]);
+ gp_Pnt P1 = Nodes(n[0]);
+ gp_Pnt P2 = Nodes(n[1]);
+ gp_Pnt P3 = Nodes(n[2]);
+ gp_Vec V1(P1,P2);
+ if ( V1.SquareMagnitude() > dPreci ) {
+ gp_Vec V2(P2,P3);
+ if ( V2.SquareMagnitude() > dPreci ) {
+ gp_Vec V3(P3,P1);
+ if ( V3.SquareMagnitude() > dPreci ) {
+ V1.Normalize();
+ V2.Normalize();
+ V1.Cross(V2);
+ if ( V1.SquareMagnitude() > dPreci ) {
+ parray->AddEdge(n[0]+decal,t[0] == 0);
+ parray->AddEdge(n[1]+decal,t[1] == 0);
+ parray->AddEdge(n[2]+decal,t[2] == 0);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ Prs3d_Root::CurrentGroup(aPresentation)->BeginPrimitives();
+ Prs3d_Root::CurrentGroup(aPresentation)->AddPrimitiveArray(parray);
+ Prs3d_Root::CurrentGroup(aPresentation)->EndPrimitives();
+ }
+ return Standard_True;
+ }
+#endif
- decal = parray->VertexNumber();
- for (i= Nodes.Lower(); i<= Nodes.Upper(); i++) {
- p = Nodes(i);
- if( !loc.IsIdentity() ) {
- p.Transform(trsf);
- NORMAL(i).Transform(trsf);
- }
- parray->AddVertex(p,NORMAL(i));
- }
-
- // Fill parray with vertex and edge visibillity info
- const Poly_Array1OfTriangle& triangles = T->Triangles();
- for (i = 1; i <= T->NbTriangles(); i++) {
- pc.Triangles(i,t[0],t[1],t[2]);
- if (SST.Orientation(F) == TopAbs_REVERSED)
- triangles(i).Get(n[0],n[2],n[1]);
- else
- triangles(i).Get(n[0],n[1],n[2]);
- gp_Pnt P1 = Nodes(n[0]);
- gp_Pnt P2 = Nodes(n[1]);
- gp_Pnt P3 = Nodes(n[2]);
- gp_Vec V1(P1,P2);
- if ( V1.SquareMagnitude() > dPreci ) {
- gp_Vec V2(P2,P3);
- if ( V2.SquareMagnitude() > dPreci ) {
- gp_Vec V3(P3,P1);
- if ( V3.SquareMagnitude() > dPreci ) {
- V1.Normalize();
- V2.Normalize();
- V1.Cross(V2);
- if ( V1.SquareMagnitude() > dPreci ) {
- parray->AddEdge(n[0]+decal,t[0] == 0);
- parray->AddEdge(n[1]+decal,t[1] == 0);
- parray->AddEdge(n[2]+decal,t[2] == 0);
- }
- }
- }
- }
- }
+ // phase de comptage:
+ Standard_Integer nt, nnn, n1, n2, n3, nnv, EI;
+ static Standard_Integer plus1mod3[3] = {1, 2, 0};
+ for (SST.Init(aShape); SST.MoreFace(); SST.NextFace()) {
+ const anyTopFace& F = SST.CurrentFace();
+ T = SST.Triangulation(F, loc);
+ if (!T.IsNull()) {
+ nnn = T->NbTriangles();
+ const TColgp_Array1OfPnt& Nodes = T->Nodes();
+ const Poly_Array1OfTriangle& triangles = T->Triangles();
+ for (nt = 1; nt <= nnn; nt++) {
+ if (SST.Orientation(F) == TopAbs_REVERSED)
+ triangles(nt).Get(n1,n3,n2);
+ else
+ triangles(nt).Get(n1,n2,n3);
+ const gp_Pnt& P1 = Nodes(n1);
+ const gp_Pnt& P2 = Nodes(n2);
+ const gp_Pnt& P3 = Nodes(n3);
+ gp_Vec V1(P1,P2);
+ if ( V1.SquareMagnitude() > dPreci ) {
+ gp_Vec V2(P2,P3);
+ if (V2.SquareMagnitude() > dPreci ) {
+ gp_Vec V3(P3,P1);
+ if (V3.SquareMagnitude() > dPreci ) {
+ V1.Normalize();
+ V2.Normalize();
+ V1.Cross(V2);
+ if (V1.SquareMagnitude() > dPreci ) {
+ nbTriangles++;
+ }
+ }
}
- }
- Prs3d_Root::CurrentGroup(aPresentation)->BeginPrimitives();
- Prs3d_Root::CurrentGroup(aPresentation)->AddPrimitiveArray(parray);
- Prs3d_Root::CurrentGroup(aPresentation)->EndPrimitives();
+ }
}
- return Standard_True;
+ nbVertices += T->NbNodes();
}
-#endif
+ }
- // phase de comptage:
- Standard_Integer nt, nnn, n1, n2, n3, nnv, EI;
- static Standard_Integer plus1mod3[3] = {1, 2, 0};
+ if (nbVertices > 2 && nbTriangles > 0) {
+ Graphic3d_Array1OfVertexN AVN(1, nbVertices);
+ Aspect_Array1OfEdge AE(1, 3*nbTriangles);
+
+ EI = 1;
+ nnv = 1;
+
for (SST.Init(aShape); SST.MoreFace(); SST.NextFace()) {
const anyTopFace& F = SST.CurrentFace();
T = SST.Triangulation(F, loc);
if (!T.IsNull()) {
-
- nnn = T->NbTriangles();
- const TColgp_Array1OfPnt& Nodes = T->Nodes();
- const Poly_Array1OfTriangle& triangles = T->Triangles();
- for (nt = 1; nt <= nnn; nt++) {
- if (SST.Orientation(F) == TopAbs_REVERSED)
- triangles(nt).Get(n1,n3,n2);
- else
- triangles(nt).Get(n1,n2,n3);
- const gp_Pnt& P1 = Nodes(n1);
- const gp_Pnt& P2 = Nodes(n2);
- const gp_Pnt& P3 = Nodes(n3);
- gp_Vec V1(P1,P2);
- if ( V1.SquareMagnitude() > dPreci ) {
- gp_Vec V2(P2,P3);
- if (V2.SquareMagnitude() > dPreci ) {
- gp_Vec V3(P3,P1);
- if (V3.SquareMagnitude() > dPreci ) {
- V1.Normalize();
- V2.Normalize();
- V1.Cross(V2);
- if (V1.SquareMagnitude() > dPreci ) {
- nbTriangles++;
- }
- }
- }
- }
- }
- nbVertices += T->NbNodes();
- }
- }
-
- if (nbVertices > 2 && nbTriangles > 0) {
- Graphic3d_Array1OfVertexN AVN(1, nbVertices);
- Aspect_Array1OfEdge AE(1, 3*nbTriangles);
-
- EI = 1;
- nnv = 1;
-
- for (SST.Init(aShape); SST.MoreFace(); SST.NextFace()) {
- const anyTopFace& F = SST.CurrentFace();
- T = SST.Triangulation(F, loc);
- if (!T.IsNull()) {
- Poly_Connect pc(T);
- // 1- les noeuds.
- const TColgp_Array1OfPnt& Nodes = T->Nodes();
- TColgp_Array1OfDir NORMAL(Nodes.Lower(), Nodes.Upper());
- SST.Normal(F, pc, NORMAL);
- decal = nnv-1;
-
- for (j= Nodes.Lower(); j<= Nodes.Upper(); j++) {
- p = Nodes(j).Transformed(loc.Transformation());
- AVN(nnv).SetCoord(p.X(), p.Y(), p.Z());
- AVN(nnv).SetNormal(NORMAL(j).X(), NORMAL(j).Y(), NORMAL(j).Z());
- nnv++;
- }
- // 2- les edges.
- nbTriangles = T->NbTriangles();
- const Poly_Array1OfTriangle& triangles = T->Triangles();
-
- for (i = 1; i <= nbTriangles; i++) {
- pc.Triangles(i,t[0],t[1],t[2]);
- if (SST.Orientation(F) == TopAbs_REVERSED)
- triangles(i).Get(n[0],n[2],n[1]);
- else
- triangles(i).Get(n[0],n[1],n[2]);
- const gp_Pnt& P1 = Nodes(n[0]);
- const gp_Pnt& P2 = Nodes(n[1]);
- const gp_Pnt& P3 = Nodes(n[2]);
- gp_Vec V1(P1,P2);
- if (V1.SquareMagnitude() > 1.e-10) {
- gp_Vec V2(P2,P3);
- if (V2.SquareMagnitude() > 1.e-10) {
- gp_Vec V3(P3,P1);
- if (V3.SquareMagnitude() > 1.e-10) {
- V1.Normalize();
- V2.Normalize();
- V1.Cross(V2);
- if (V1.SquareMagnitude() > 1.e-10) {
- for (j = 0; j < 3; j++) {
- k = plus1mod3[j];
- if (t[j] == 0)
- AE(EI).SetValues(n[j]+decal, n[k]+decal, Aspect_TOE_VISIBLE);
- else
- AE(EI).SetValues(n[j]+decal, n[k]+decal, Aspect_TOE_INVISIBLE);
- EI++;
- }
- }
- }
- }
- }
- }
+ Poly_Connect pc(T);
+ // 1- les noeuds.
+ const TColgp_Array1OfPnt& Nodes = T->Nodes();
+ TColgp_Array1OfDir NORMAL(Nodes.Lower(), Nodes.Upper());
+ SST.Normal(F, pc, NORMAL);
+ decal = nnv-1;
+
+ for (j= Nodes.Lower(); j<= Nodes.Upper(); j++) {
+ p = Nodes(j).Transformed(loc.Transformation());
+ AVN(nnv).SetCoord(p.X(), p.Y(), p.Z());
+ AVN(nnv).SetNormal(NORMAL(j).X(), NORMAL(j).Y(), NORMAL(j).Z());
+ nnv++;
}
+ // 2- les edges.
+ nbTriangles = T->NbTriangles();
+ const Poly_Array1OfTriangle& triangles = T->Triangles();
+
+ for (i = 1; i <= nbTriangles; i++) {
+ pc.Triangles(i,t[0],t[1],t[2]);
+ if (SST.Orientation(F) == TopAbs_REVERSED)
+ triangles(i).Get(n[0],n[2],n[1]);
+ else
+ triangles(i).Get(n[0],n[1],n[2]);
+ const gp_Pnt& P1 = Nodes(n[0]);
+ const gp_Pnt& P2 = Nodes(n[1]);
+ const gp_Pnt& P3 = Nodes(n[2]);
+ gp_Vec V1(P1,P2);
+ if (V1.SquareMagnitude() > 1.e-10) {
+ gp_Vec V2(P2,P3);
+ if (V2.SquareMagnitude() > 1.e-10) {
+ gp_Vec V3(P3,P1);
+ if (V3.SquareMagnitude() > 1.e-10) {
+ V1.Normalize();
+ V2.Normalize();
+ V1.Cross(V2);
+ if (V1.SquareMagnitude() > 1.e-10) {
+ for (j = 0; j < 3; j++) {
+ k = plus1mod3[j];
+ if (t[j] == 0)
+ AE(EI).SetValues(n[j]+decal, n[k]+decal, Aspect_TOE_VISIBLE);
+ else
+ AE(EI).SetValues(n[j]+decal, n[k]+decal, Aspect_TOE_INVISIBLE);
+ EI++;
+ }
+ }
+ }
+ }
+ }
+ }
}
- Prs3d_Root::CurrentGroup(aPresentation)->TriangleSet(AVN, AE);
}
- return Standard_True;
+ Prs3d_Root::CurrentGroup(aPresentation)->TriangleSet(AVN, AE);
+ }
+ return Standard_True;
}
void Prs3d_ShadedShape::Add(const Handle (Prs3d_Presentation)& aPresentation,
- const anyShape& aShape,
- const Handle (Prs3d_Drawer)& aDrawer)
+ const anyShape& aShape,
+ const Handle (Prs3d_Drawer)& aDrawer)
{
if (aShape.IsNull()) return;
// il faut presenter les edges isoles.
for (ex.Init(aShape, TopAbs_EDGE, TopAbs_FACE); ex.More(); ex.Next()) {
- haselement = Standard_True;
- B.Add(CO, ex.Current());
+ haselement = Standard_True;
+ B.Add(CO, ex.Current());
}
// il faut presenter les vertex isoles.
for (ex.Init(aShape, TopAbs_VERTEX, TopAbs_EDGE); ex.More(); ex.Next()) {
- haselement = Standard_True;
- B.Add(CO, ex.Current());
+ haselement = Standard_True;
+ B.Add(CO, ex.Current());
}
if (haselement) StdPrs_WFShape::Add(aPresentation, CO, aDrawer);
}
}
Standard_Real aDeflection = GetDeflection(aShape, aDrawer);
//using of plugin
- BRepMesh_PDiscretRoot pAlgo;
- pAlgo=BRepMesh_DiscretFactory::Get().Discret(aShape,
- aDeflection,
- aDrawer->HLRAngle());
- if (pAlgo)
- pAlgo->Perform();
+ // Check if it is possible to avoid unnecessary recomputation
+ // of shape triangulation
+ if( !BRepTools::Triangulation(aShape, aDeflection) )
+ {
+ BRepTools::Clean(aShape);
+ BRepMesh_PDiscretRoot pAlgo;
+ pAlgo=BRepMesh_DiscretFactory::Get().Discret(aShape,
+ aDeflection,
+ aDrawer->HLRAngle());
+ if (pAlgo)
+ pAlgo->Perform();
+ }
ShadeFromShape(aShape, aDeflection, Standard_True, aPresentation, aDrawer);
}
-
-
Bnd_Box2d BoundBox;
BoundBox.Update(XMin-aTol,YMin-aTol,XMax+aTol,YMax+aTol);
- for(Standard_Integer j=0; j<mynbpoints-1; j++)
+ for(Standard_Integer j=0; j<mynbpoints; j++)
{
if(BoundBox.IsOut(((Select3D_Pnt2d*)mypolyg2d)[j])) return Standard_False;
}
const Standard_Real theMaxParam)
{
Standard_Integer aPriority = (thePriority == -1) ? GetStandardPriority (theShape, theType) : thePriority;
+
+ if( isAutoTriangulation && !BRepTools::Triangulation (theShape, Precision::Infinite()) )
+ {
+ BRepMesh_IncrementalMesh(theShape, theDeflection, Standard_False, theDeviationAngle);
+ }
+
Handle(StdSelect_BRepOwner) aBrepOwner;
switch (theType)
{
// check if there is triangulation of the face...
TopLoc_Location aLoc;
Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation (theFace, aLoc);
- if (aTriangulation.IsNull() && theAutoTriangulation)
- {
- Standard_Real aDefaultDefl = 0.2;
- Standard_Real aDefaultAng = 30 * PI / 180.0;
- BRepMesh_IncrementalMesh (theFace, aDefaultDefl, Standard_True, aDefaultAng);
- aTriangulation = BRep_Tool::Triangulation (theFace, aLoc);
- }
+
if (!aTriangulation.IsNull())
{
Handle(Select3D_SensitiveTriangulation) STG = new Select3D_SensitiveTriangulation (theOwner, aTriangulation, aLoc, theInteriorFlag);