const double& theSize,
std::vector<ControlPnt>& thePoints );
- std::vector<gp_Pnt> computePointsForSplitting( const gp_Pnt& p1,
- const gp_Pnt& p2,
- const gp_Pnt& p3 );
+ void computePointsForSplitting( const gp_Pnt& p1,
+ const gp_Pnt& p2,
+ const gp_Pnt& p3,
+ gp_Pnt midPoints[3]);
gp_Pnt tangencyPoint(const gp_Pnt& p1,
const gp_Pnt& p2,
const gp_Pnt& Center);
// Get triangles
int nbTriangles = aTri->NbTriangles();
- Poly_Array1OfTriangle triangles(1,nbTriangles);
- triangles=aTri->Triangles();
+ const Poly_Array1OfTriangle& triangles = aTri->Triangles();
// GetNodes
int nbNodes = aTri->NbNodes();
nodes = aTri->Nodes();
// Iterate on triangles and subdivide them
- for(int i=1; i<=nbTriangles; i++)
+ thePoints.reserve( thePoints.size() + nbTriangles );
+ for ( int i = 1; i <= nbTriangles; i++ )
{
- Poly_Triangle aTriangle = triangles.Value(i);
+ const Poly_Triangle& aTriangle = triangles.Value(i);
gp_Pnt p1 = nodes.Value(aTriangle.Value(1));
gp_Pnt p2 = nodes.Value(aTriangle.Value(2));
gp_Pnt p3 = nodes.Value(aTriangle.Value(3));
p2.Transform(aTrsf);
p3.Transform(aTrsf);
- subdivideTriangle(p1, p2, p3, theSize, thePoints);
+ subdivideTriangle( p1, p2, p3, theSize, thePoints );
}
}
// Step2 : for each face of theSolid:
std::set<double> intersections;
- std::set<double>::iterator it = intersections.begin();
- TopExp_Explorer Ex;
- for (Ex.Init(theSolid,TopAbs_FACE); Ex.More(); Ex.Next())
+ for ( TopExp_Explorer Ex( theSolid, TopAbs_FACE ); Ex.More(); Ex.Next() )
{
// check if there is an intersection
IntCurvesFace_Intersector anIntersector(TopoDS::Face(Ex.Current()), Precision::Confusion());
// get the intersection's parameter and store it
int nbPoints = anIntersector.NbPnt();
- for(int i = 0 ; i < nbPoints ; i++ )
+ for ( int i = 0 ; i < nbPoints; i++ )
{
- it = intersections.insert( it, anIntersector.WParameter(i+1) );
+ intersections.insert( anIntersector.WParameter(i+1) );
}
}
// Step3 : go through the line chunk by chunk
- if ( intersections.begin() != intersections.end() )
+ if ( intersections.size() > 1 )
{
std::set<double>::iterator intersectionsIterator=intersections.begin();
double first = *intersectionsIterator;
double localStep = (second -first) / ceil( (second - first) / step );
for ( double z = Zmin + first; z < Zmin + second; z = z + localStep )
{
- thePoints.push_back(ControlPnt( x, y, z, theSize ));
+ thePoints.emplace_back( x, y, z, theSize );
}
- thePoints.push_back(ControlPnt( x, y, Zmin + second, theSize ));
+ thePoints.emplace_back( x, y, Zmin + second, theSize );
}
first = second;
innerPoints = !innerPoints;
// and the distance between two mass centers of two neighbouring triangles
// sharing an edge is < 2 * 1/2 * S = S
// If the traingles share a Vertex and no Edge the distance of the mass centers
- // to the Vertices is 2*D < S so the mass centers are distant of less than 2*S
+ // to the Vertices is 2*D < S so the mass centers are distant of less than 2*S
double threshold = sqrt( 3. ) * theSize;
- if ( (p1.Distance(p2) > threshold ||
- p2.Distance(p3) > threshold ||
- p3.Distance(p1) > threshold))
- {
- std::vector<gp_Pnt> midPoints = computePointsForSplitting(p1, p2, p3);
-
- subdivideTriangle( midPoints[0], midPoints[1], midPoints[2], theSize, thePoints );
- subdivideTriangle( midPoints[0], p2, midPoints[1], theSize, thePoints );
- subdivideTriangle( midPoints[2], midPoints[1], p3, theSize, thePoints );
- subdivideTriangle( p1, midPoints[0], midPoints[2], theSize, thePoints );
- }
- else
- {
- double x = (p1.X() + p2.X() + p3.X()) / 3 ;
- double y = (p1.Y() + p2.Y() + p3.Y()) / 3 ;
- double z = (p1.Z() + p2.Z() + p3.Z()) / 3 ;
+ if ( p1.Distance(p2) > threshold ||
+ p2.Distance(p3) > threshold ||
+ p3.Distance(p1) > threshold )
+ try
+ {
+ gp_Pnt midPoints[3];
+ computePointsForSplitting( p1, p2, p3, midPoints );
+
+ subdivideTriangle( midPoints[0], midPoints[1], midPoints[2], theSize, thePoints );
+ subdivideTriangle( midPoints[0], p2, midPoints[1], theSize, thePoints );
+ subdivideTriangle( midPoints[2], midPoints[1], p3, theSize, thePoints );
+ subdivideTriangle( p1, midPoints[0], midPoints[2], theSize, thePoints );
+ return;
+ }
+ catch (...)
+ {
+ }
- ControlPnt massCenter( x ,y ,z, theSize );
- thePoints.push_back( massCenter );
- }
+ gp_Pnt massCenter = ( p1.XYZ() + p2.XYZ() + p3.XYZ() ) / 3.;
+ thePoints.emplace_back( massCenter, theSize );
}
//================================================================================
/*!
* \brief Returns the appropriate points for splitting a triangle
- * \brief the tangency points of the incircle are used in order to have mostly
- * \brief well-shaped sub-triangles
+ * the tangency points of the incircle are used in order to have mostly
+ * well-shaped sub-triangles
*/
//================================================================================
-std::vector<gp_Pnt> SMESHUtils::computePointsForSplitting( const gp_Pnt& p1,
- const gp_Pnt& p2,
- const gp_Pnt& p3 )
+void SMESHUtils::computePointsForSplitting( const gp_Pnt& p1,
+ const gp_Pnt& p2,
+ const gp_Pnt& p3,
+ gp_Pnt midPoints[3])
{
- std::vector<gp_Pnt> midPoints;
//Change coordinates
gp_Trsf Trsf_1; // Identity transformation
gp_Ax3 reference_system(gp::Origin(), gp::DZ(), gp::DX()); // OXY
gp_Pnt T2 = tangencyPoint( B, C, Center);
gp_Pnt T3 = tangencyPoint( C, A, Center);
- gp_Pnt p1_2 = T1.Transformed(Trsf_1.Inverted());
- gp_Pnt p2_3 = T2.Transformed(Trsf_1.Inverted());
- gp_Pnt p3_1 = T3.Transformed(Trsf_1.Inverted());
-
- midPoints.push_back(p1_2);
- midPoints.push_back(p2_3);
- midPoints.push_back(p3_1);
+ midPoints[0] = T1.Transformed(Trsf_1.Inverted());
+ midPoints[1] = T2.Transformed(Trsf_1.Inverted());
+ midPoints[2] = T3.Transformed(Trsf_1.Inverted());
- return midPoints;
+ return;
}
//================================================================================
{
ControlPnt()
: gp_Pnt(), size(0) {}
- ControlPnt( const gp_Pnt& aPnt, double theSize)
+ ControlPnt( const gp_Pnt& aPnt, double theSize=0)
: gp_Pnt( aPnt ), size( theSize ) {}
- ControlPnt(double theX,double theY,double theZ)
- : gp_Pnt(theX, theY, theZ), size(0) {}
- ControlPnt(double theX,double theY,double theZ, double theSize)
+ ControlPnt(double theX,double theY,double theZ, double theSize=0)
: gp_Pnt(theX, theY, theZ), size( theSize ) {}
double Size() const { return size; };
// Functions to get sample point from shapes
SMESHUtils_EXPORT void createControlPoints( const TopoDS_Shape& theShape,
- const double& theSize,
- std::vector< ControlPnt >& thePoints );
+ const double& theSize,
+ std::vector< ControlPnt >& thePoints );
- SMESHUtils_EXPORT void createPointsSampleFromEdge( const TopoDS_Edge& theEdge,
- const double& theSize,
- std::vector<ControlPnt>& thePoints );
+ SMESHUtils_EXPORT void createPointsSampleFromEdge( const TopoDS_Edge& theEdge,
+ const double& theSize,
+ std::vector<ControlPnt>& thePoints );
- SMESHUtils_EXPORT void createPointsSampleFromFace( const TopoDS_Face& theFace,
- const double& theSize,
- std::vector<ControlPnt>& thePoints );
+ SMESHUtils_EXPORT void createPointsSampleFromFace( const TopoDS_Face& theFace,
+ const double& theSize,
+ std::vector<ControlPnt>& thePoints );
- SMESHUtils_EXPORT void createPointsSampleFromSolid( const TopoDS_Solid& theSolid,
- const double& theSize,
- std::vector<ControlPnt>& thePoints );
+ SMESHUtils_EXPORT void createPointsSampleFromSolid( const TopoDS_Solid& theSolid,
+ const double& theSize,
+ std::vector<ControlPnt>& thePoints );
}
#endif
//! fields
int _dim; //!< a dimension the algo can build (concurrent dimension)
int _ownDim; //!< dimension of shape of _subMesh (>=_dim)
- TopTools_MapOfShape _shapeMap; //!< [sub-]shapes of dimension == _dim
- SMESH_subMesh* _subMesh;
+ TopTools_MapOfShape _shapeMap; //!< [sub-]shapes of dimension == _dim
+ const SMESH_subMesh* _subMesh;
list<const SMESHDS_Hypothesis*> _hypotheses; //!< algo is first, then its parameters
//-----------------------------------------------------------------------------
const int theDim,
const TopoDS_Shape& theShape)
{
- _subMesh = (SMESH_subMesh*)theSubMesh;
+ _subMesh = theSubMesh;
SetShape( theDim, theShape );
}
theAlgo->NeedLowerHyps( theDim )) // IPAL54678
return;
TDimHypList& listOfdimHyp = theDimHypListArr[theDim];
- if ( listOfdimHyp.empty() || listOfdimHyp.back()->_subMesh != theSubMesh ) {
+ if ( listOfdimHyp.empty() || listOfdimHyp.back()->_subMesh != theSubMesh )
+ {
SMESH_DimHyp* dimHyp = new SMESH_DimHyp( theSubMesh, theDim, theShape );
dimHyp->_hypotheses.push_front(theAlgo);
listOfdimHyp.push_back( dimHyp );
const int theIndx )
{
TListOfListOfInt::iterator it = theListOfListOfId.begin();
- for ( int i = 0; it != theListOfListOfId.end(); it++, i++ ) {
+ for ( int i = 0; it != theListOfListOfId.end(); it++, i++ )
+ {
if ( i < theIndx )
continue; //skip already treated lists
// check if other list has any same submesh object
{
TListOfListOfInt anOrder;
::SMESH_Mesh& mesh = GetImpl();
- {
- // collect submeshes and detect concurrent algorithms and hypothesises
- TDimHypList dimHypListArr[4]; // dimHyp list for each shape dimension
-
- map<int, ::SMESH_subMesh*>::iterator i_sm = _mapSubMesh.begin();
- for ( ; i_sm != _mapSubMesh.end(); i_sm++ ) {
- ::SMESH_subMesh* sm = (*i_sm).second;
- // shape of submesh
- const TopoDS_Shape& aSubMeshShape = sm->GetSubShape();
-
- // list of assigned hypothesises
- const list <const SMESHDS_Hypothesis*>& hypList = mesh.GetHypothesisList(aSubMeshShape);
- // Find out dimensions where the submesh can be concurrent.
- // We define the dimensions by algo of each of hypotheses in hypList
- list <const SMESHDS_Hypothesis*>::const_iterator hypIt = hypList.begin();
- for( ; hypIt != hypList.end(); hypIt++ ) {
- SMESH_Algo* anAlgo = 0;
- const SMESH_Hypothesis* hyp = dynamic_cast<const SMESH_Hypothesis*>(*hypIt);
- if ( hyp->GetType() != SMESHDS_Hypothesis::PARAM_ALGO )
- // hyp it-self is algo
- anAlgo = (SMESH_Algo*)dynamic_cast<const SMESH_Algo*>(hyp);
- else {
- // try to find algorithm with help of sub-shapes
- TopExp_Explorer anExp( aSubMeshShape, shapeTypeByDim(hyp->GetDim()) );
- for ( ; !anAlgo && anExp.More(); anExp.Next() )
- anAlgo = mesh.GetGen()->GetAlgo( mesh, anExp.Current() );
- }
- if (!anAlgo)
- continue; // no algorithm assigned to a current submesh
-
- int dim = anAlgo->GetDim(); // top concurrent dimension (see comment to SMESH_DimHyp)
- // the submesh can concurrent at <dim> (or lower dims if !anAlgo->NeedDiscreteBoundary()
- // and !anAlgo->NeedLowerHyps( dim ))
- // create instance of dimension-hypothesis for found concurrent dimension(s) and algorithm
- for ( int j = anAlgo->NeedDiscreteBoundary() ? dim : 1, jn = dim; j <= jn; j++ )
- addDimHypInstance( j, aSubMeshShape, anAlgo, sm, hypList, dimHypListArr );
+ // collect submeshes and detect concurrent algorithms and hypothesises
+ TDimHypList dimHypListArr[4]; // dimHyp list for each shape dimension
+
+ map<int, ::SMESH_subMesh*>::iterator i_sm = _mapSubMesh.begin();
+ for ( ; i_sm != _mapSubMesh.end(); i_sm++ ) {
+ ::SMESH_subMesh* sm = (*i_sm).second;
+ // shape of submesh
+ const TopoDS_Shape& aSubMeshShape = sm->GetSubShape();
+
+ // list of assigned hypothesises
+ const list <const SMESHDS_Hypothesis*>& hypList = mesh.GetHypothesisList(aSubMeshShape);
+ // Find out dimensions where the submesh can be concurrent.
+ // We define the dimensions by algo of each of hypotheses in hypList
+ list <const SMESHDS_Hypothesis*>::const_iterator hypIt = hypList.begin();
+ for( ; hypIt != hypList.end(); hypIt++ ) {
+ SMESH_Algo* anAlgo = 0;
+ const SMESH_Hypothesis* hyp = dynamic_cast<const SMESH_Hypothesis*>(*hypIt);
+ if ( hyp->GetType() != SMESHDS_Hypothesis::PARAM_ALGO )
+ // hyp it-self is algo
+ anAlgo = (SMESH_Algo*)dynamic_cast<const SMESH_Algo*>(hyp);
+ else {
+ // try to find algorithm with help of sub-shapes
+ TopExp_Explorer anExp( aSubMeshShape, shapeTypeByDim(hyp->GetDim()) );
+ for ( ; !anAlgo && anExp.More(); anExp.Next() )
+ anAlgo = mesh.GetGen()->GetAlgo( mesh, anExp.Current() );
}
- } // end iterations on submesh
+ if (!anAlgo)
+ continue; // no algorithm assigned to a current submesh
+
+ int dim = anAlgo->GetDim(); // top concurrent dimension (see comment to SMESH_DimHyp)
+ // the submesh can concurrent at <dim> (or lower dims if !anAlgo->NeedDiscreteBoundary()
+ // and !anAlgo->NeedLowerHyps( dim ))
+
+ // create instance of dimension-hypothesis for found concurrent dimension(s) and algorithm
+ for ( int j = anAlgo->NeedDiscreteBoundary() ? dim : 1, jn = dim; j <= jn; j++ )
+ addDimHypInstance( j, aSubMeshShape, anAlgo, sm, hypList, dimHypListArr );
+ }
+ } // end iterations on submesh
// iterate on created dimension-hypotheses and check for concurrents
- for ( int i = 0; i < 4; i++ ) {
- const TDimHypList& listOfDimHyp = dimHypListArr[i];
- // check for concurrents in own and other dimensions (step-by-step)
- TDimHypList::const_iterator dhIt = listOfDimHyp.begin();
- for ( ; dhIt != listOfDimHyp.end(); dhIt++ ) {
- const SMESH_DimHyp* dimHyp = *dhIt;
- TDimHypList listOfConcurr;
- set<int> setOfConcurrIds;
- // looking for concurrents and collect into own list
- for ( int j = i; j < 4; j++ )
- findConcurrents( dimHyp, dimHypListArr[j], listOfConcurr, setOfConcurrIds );
- // check if any concurrents found
- if ( listOfConcurr.size() > 0 ) {
- // add own submesh to list of concurrent
- addInOrderOfPriority( dimHyp, listOfConcurr );
- list<int> listOfConcurrIds;
- TDimHypList::iterator hypIt = listOfConcurr.begin();
- for ( ; hypIt != listOfConcurr.end(); ++hypIt )
- listOfConcurrIds.push_back( (*hypIt)->_subMesh->GetId() );
- anOrder.push_back( listOfConcurrIds );
- }
+ for ( int i = 0; i < 4; i++ )
+ {
+ const TDimHypList& listOfDimHyp = dimHypListArr[i];
+ // check for concurrents in own and other dimensions (step-by-step)
+ TDimHypList::const_iterator dhIt = listOfDimHyp.begin();
+ for ( ; dhIt != listOfDimHyp.end(); dhIt++ )
+ {
+ const SMESH_DimHyp* dimHyp = *dhIt;
+ TDimHypList listOfConcurr;
+ set<int> setOfConcurrIds;
+ // looking for concurrents and collect into own list
+ for ( int j = i; j < 4; j++ )
+ findConcurrents( dimHyp, dimHypListArr[j], listOfConcurr, setOfConcurrIds );
+ // check if any concurrents found
+ if ( listOfConcurr.size() > 0 )
+ {
+ // add own submesh to list of concurrent
+ addInOrderOfPriority( dimHyp, listOfConcurr );
+ list<int> listOfConcurrIds;
+ TDimHypList::iterator hypIt = listOfConcurr.begin();
+ for ( ; hypIt != listOfConcurr.end(); ++hypIt )
+ listOfConcurrIds.push_back( (*hypIt)->_subMesh->GetId() );
+ anOrder.push_back( listOfConcurrIds );
}
}
+ }
- removeDimHyps(dimHypListArr);
+ removeDimHyps(dimHypListArr);
- // now, minimize the number of concurrent groups
- // Here we assume that lists of submeshes can have same submesh
- // in case of multi-dimension algorithms, as result
- // list with common submesh has to be united into one list
- int listIndx = 0;
- TListOfListOfInt::iterator listIt = anOrder.begin();
- for(; listIt != anOrder.end(); listIt++, listIndx++ )
- unionLists( *listIt, anOrder, listIndx + 1 );
- }
+ // now, minimize the number of concurrent groups
+ // Here we assume that lists of submeshes can have same submesh
+ // in case of multi-dimension algorithms, as result
+ // list with common submesh has to be united into one list
+ int listIndx = 0;
+ TListOfListOfInt::iterator listIt = anOrder.begin();
+ for(; listIt != anOrder.end(); listIt++, listIndx++ )
+ unionLists( *listIt, anOrder, listIndx + 1 );
return anOrder;
}
theResOrder.length(nbSet);
TListOfListOfInt::const_iterator it = theIdsOrder.begin();
int listIndx = 0;
- for( ; it != theIdsOrder.end(); it++ ) {
+ for( ; it != theIdsOrder.end(); it++ )
+ {
// translate submesh identificators into submesh objects
// takeing into account real number of concurrent lists
const TListOfInt& aSubOrder = (*it);
aResSubSet->length(aSubOrder.size());
TListOfInt::const_iterator subIt = aSubOrder.begin();
int j;
- for( j = 0; subIt != aSubOrder.end(); subIt++ ) {
+ for( j = 0; subIt != aSubOrder.end(); subIt++ )
+ {
if ( _mapSubMeshIor.find(*subIt) == _mapSubMeshIor.end() )
continue;
SMESH::SMESH_subMesh_var subMesh =
