void CreateFacesAndEdges(TopoDS_Shape shape, CFaceList* faces, CEdgeList* edges, CVertexList* vertices)
{
// create index maps
TopTools_IndexedMapOfShape faceMap;
TopTools_IndexedMapOfShape edgeMap;
TopTools_IndexedMapOfShape vertexMap;
for (TopExp_Explorer explorer(shape, TopAbs_FACE); explorer.More(); explorer.Next())
{
faceMap.Add(explorer.Current());
}
for (TopExp_Explorer explorer(shape, TopAbs_EDGE); explorer.More(); explorer.Next())
{
edgeMap.Add(explorer.Current());
}
for (TopExp_Explorer explorer(shape, TopAbs_VERTEX); explorer.More(); explorer.Next())
{
vertexMap.Add(explorer.Current());
}
std::vector<CFace*> face_array;
face_array.resize(faceMap.Extent() + 1);
std::vector<CEdge*> edge_array;
edge_array.resize(edgeMap.Extent() + 1);
std::vector<CVertex*> vertex_array;
vertex_array.resize(vertexMap.Extent() + 1);
// create the edge objects
for(int i = 1;i<=edgeMap.Extent();i++)
{
const TopoDS_Shape &s = edgeMap(i);
CEdge* new_object = new CEdge(TopoDS::Edge(s));
edge_array[i] = new_object;
}
// create the vertex objects
for(int i = 1;i<=vertexMap.Extent();i++)
{
const TopoDS_Shape &s = vertexMap(i);
CVertex* new_object = new CVertex(TopoDS::Vertex(s));
vertex_array[i] = new_object;
}
// add the edges in their face loop order
std::set<CEdge*> edges_added;
std::set<CVertex*> vertices_added;
// create the face objects
for(int i = 1;i<=faceMap.Extent();i++)
{
const TopoDS_Shape &s = faceMap(i);
CFace* new_face_object = new CFace(TopoDS::Face(s));
faces->Add(new_face_object, NULL);
face_array[i] = new_face_object;
// create the loop objects
TopTools_IndexedMapOfShape loopMap;
for (TopExp_Explorer explorer(s, TopAbs_WIRE); explorer.More(); explorer.Next())
{
loopMap.Add(explorer.Current());
}
TopoDS_Wire outerWire=BRepTools::OuterWire(new_face_object->Face());
int outer_index = loopMap.FindIndex(outerWire);
for(int i = 1;i<=loopMap.Extent();i++)
{
const TopoDS_Shape &s = loopMap(i);
CLoop* new_loop_object = new CLoop(TopoDS::Wire(s));
new_face_object->m_loops.push_back(new_loop_object);
if(outer_index == i)new_loop_object->m_is_outer = true;
new_loop_object->m_pface = new_face_object;
// find the loop's edges
for(BRepTools_WireExplorer explorer(TopoDS::Wire(s)); explorer.More(); explorer.Next())
{
CEdge* e = edge_array[edgeMap.FindIndex(explorer.Current())];
new_loop_object->m_edges.push_back(e);
// add the edge
if(edges_added.find(e) == edges_added.end())
{
edges->Add(e, NULL);
edges_added.insert(e);
}
// add the vertex
CVertex* v = vertex_array[vertexMap.FindIndex(explorer.CurrentVertex())];
if(vertices_added.find(v) == vertices_added.end())
{
vertices->Add(v, NULL);
vertices_added.insert(v);
}
}
}
}
// find the vertices' edges
for(unsigned int i = 1; i<vertex_array.size(); i++)
{
CVertex* v = vertex_array[i];
TopTools_IndexedMapOfShape vertexEdgeMap;
for (TopExp_Explorer expEdge(v->Vertex(), TopAbs_EDGE); expEdge.More(); expEdge.Next())
{
vertexEdgeMap.Add(expEdge.Current());
}
for(int i = 1; i<=vertexEdgeMap.Extent(); i++)
{
const TopoDS_Shape &s = vertexEdgeMap(i);
CEdge* e = edge_array[edgeMap.FindIndex(s)];
v->m_edges.push_back(e);
}
}
// find the faces' edges
for(unsigned int i = 1; i<face_array.size(); i++)
{
CFace* face = face_array[i];
TopTools_IndexedMapOfShape faceEdgeMap;
for (TopExp_Explorer expEdge(face->Face(), TopAbs_EDGE); expEdge.More(); expEdge.Next())
{
faceEdgeMap.Add(expEdge.Current());
}
for(int i = 1; i<=faceEdgeMap.Extent(); i++)
{
const TopoDS_Shape &s = faceEdgeMap(i);
CEdge* e = edge_array[edgeMap.FindIndex(s)];
face->m_edges.push_back(e);
e->m_faces.push_back(face);
bool sense = (s.IsEqual(e->Edge()) == Standard_True);
e->m_face_senses.push_back(sense);
}
}
}
TopoDS_Shape BlockFix_UnionEdges::Perform(const TopoDS_Shape& Shape,
const Standard_Real Tol)
{
myContext = new ShapeBuild_ReShape;
myTolerance = Tol;
TopoDS_Shape aResult = myContext->Apply(Shape);
// processing each solid
TopAbs_ShapeEnum aType = TopAbs_SOLID;
TopExp_Explorer exps (Shape, aType);
if (!exps.More()) {
aType = TopAbs_SHELL;
exps.Init(Shape, aType);
}
for (; exps.More(); exps.Next()) {
//TopoDS_Solid aSolid = TopoDS::Solid(exps.Current());
TopoDS_Shape aSolid = exps.Current();
TopTools_IndexedMapOfShape ChangedFaces;
// creating map of edge faces
TopTools_IndexedDataMapOfShapeListOfShape aMapEdgeFaces;
TopExp::MapShapesAndAncestors(aSolid, TopAbs_EDGE, TopAbs_FACE, aMapEdgeFaces);
Handle(ShapeBuild_ReShape) aContext = new ShapeBuild_ReShape;
TopoDS_Shape aRes = aSolid;
aRes = aContext->Apply(aSolid);
// processing each face
TopExp_Explorer exp;
for (exp.Init(aRes, TopAbs_FACE); exp.More(); exp.Next()) {
TopoDS_Face aFace =
TopoDS::Face(aContext->Apply(exp.Current().Oriented(TopAbs_FORWARD)));
TopTools_IndexedDataMapOfShapeListOfShape aMapFacesEdges;
for (TopExp_Explorer expe(aFace,TopAbs_EDGE); expe.More(); expe.Next()) {
TopoDS_Edge edge = TopoDS::Edge(expe.Current());
if (!aMapEdgeFaces.Contains(edge)) continue;
const TopTools_ListOfShape& aList = aMapEdgeFaces.FindFromKey(edge);
TopTools_ListIteratorOfListOfShape anIter(aList);
for ( ; anIter.More(); anIter.Next()) {
TopoDS_Face face = TopoDS::Face(anIter.Value());
TopoDS_Face face1 = TopoDS::Face(aContext->Apply(anIter.Value()));
if (face1.IsSame(aFace)) continue;
if (aMapFacesEdges.Contains(face)) {
aMapFacesEdges.ChangeFromKey(face).Append(edge);
}
else {
TopTools_ListOfShape ListEdges;
ListEdges.Append(edge);
aMapFacesEdges.Add(face,ListEdges);
}
}
}
for (Standard_Integer i=1; i<=aMapFacesEdges.Extent(); i++) {
const TopTools_ListOfShape& ListEdges = aMapFacesEdges.FindFromIndex(i);
TopTools_SequenceOfShape SeqEdges;
TopTools_ListIteratorOfListOfShape anIter(ListEdges);
for ( ; anIter.More(); anIter.Next()) {
SeqEdges.Append(anIter.Value());
}
if (SeqEdges.Length()==1) continue;
TopoDS_Edge E;
if ( MergeEdges(SeqEdges,aFace,Tol,E) ) {
// now we have only one edge - aChain.Value(1)
// we have to replace old ListEdges with this new edge
aContext->Replace(SeqEdges(1),E);
for (Standard_Integer j=2; j<=SeqEdges.Length(); j++) {
aContext->Remove(SeqEdges(j));
}
TopoDS_Face tmpF = TopoDS::Face(exp.Current());
if ( !ChangedFaces.Contains(tmpF) )
ChangedFaces.Add(tmpF);
tmpF = TopoDS::Face(aMapFacesEdges.FindKey(i));
if ( !ChangedFaces.Contains(tmpF) )
ChangedFaces.Add(tmpF);
}
}
} // end processing each face
// fix changed faces and replace them in the local context
for (Standard_Integer i=1; i<=ChangedFaces.Extent(); i++) {
TopoDS_Face aFace = TopoDS::Face(aContext->Apply(ChangedFaces.FindKey(i)));
Handle(ShapeFix_Face) sff = new ShapeFix_Face(aFace);
sff->SetContext(myContext);
sff->SetPrecision(myTolerance);
sff->SetMinTolerance(myTolerance);
sff->SetMaxTolerance(Max(1.,myTolerance*1000.));
sff->Perform();
aContext->Replace(aFace,sff->Face());
}
if (ChangedFaces.Extent() > 0) {
// fix changed shell and replace it in the local context
TopoDS_Shape aRes1 = aContext->Apply(aRes);
TopExp_Explorer expsh;
for (expsh.Init(aRes1, TopAbs_SHELL); expsh.More(); expsh.Next()) {
TopoDS_Shell aShell = TopoDS::Shell(expsh.Current());
Handle(ShapeFix_Shell) sfsh = new ShapeFix_Shell;
sfsh->FixFaceOrientation(aShell);
aContext->Replace(aShell,sfsh->Shell());
}
TopoDS_Shape aRes2 = aContext->Apply(aRes1);
// put new solid into global context
myContext->Replace(aSolid,aRes2);
}
} // end processing each solid
aResult = myContext->Apply(Shape);
return aResult;
}
//=======================================================================
//function : Execute
//purpose :
//=======================================================================
Standard_Integer GEOMImpl_MeasureDriver::Execute(TFunction_Logbook& log) const
{
if (Label().IsNull()) return 0;
Handle(GEOM_Function) aFunction = GEOM_Function::GetFunction(Label());
GEOMImpl_IMeasure aCI (aFunction);
Standard_Integer aType = aFunction->GetType();
TopoDS_Shape aShape;
if (aType == CDG_MEASURE)
{
Handle(GEOM_Function) aRefBase = aCI.GetBase();
TopoDS_Shape aShapeBase = aRefBase->GetValue();
if (aShapeBase.IsNull()) {
Standard_NullObject::Raise("Shape for centre of mass calculation is null");
}
gp_Ax3 aPos = GEOMImpl_IMeasureOperations::GetPosition(aShapeBase);
gp_Pnt aCenterMass = aPos.Location();
aShape = BRepBuilderAPI_MakeVertex(aCenterMass).Shape();
}
else if (aType == VERTEX_BY_INDEX)
{
Handle(GEOM_Function) aRefBase = aCI.GetBase();
TopoDS_Shape aShapeBase = aRefBase->GetValue();
if (aShapeBase.IsNull()) {
Standard_NullObject::Raise("Shape for centre of mass calculation is null");
}
int index = aCI.GetIndex();
gp_Pnt aVertex;
if (aShapeBase.ShapeType() == TopAbs_VERTEX) {
if ( index != 1 )
Standard_NullObject::Raise("Vertex index is out of range");
else
aVertex = BRep_Tool::Pnt(TopoDS::Vertex(aShapeBase));
} else if (aShapeBase.ShapeType() == TopAbs_EDGE) {
TopoDS_Vertex aV1, aV2;
TopoDS_Edge anEdgeE = TopoDS::Edge(aShapeBase);
TopExp::Vertices(anEdgeE, aV1, aV2);
gp_Pnt aP1 = BRep_Tool::Pnt(aV1);
gp_Pnt aP2 = BRep_Tool::Pnt(aV2);
if (index < 0 || index > 1)
Standard_NullObject::Raise("Vertex index is out of range");
if ( ( anEdgeE.Orientation() == TopAbs_FORWARD && index == 0 ) ||
( anEdgeE.Orientation() == TopAbs_REVERSED && index == 1 ) )
aVertex = aP1;
else
aVertex = aP2;
} else if (aShapeBase.ShapeType() == TopAbs_WIRE) {
TopTools_IndexedMapOfShape anEdgeShapes;
TopTools_IndexedMapOfShape aVertexShapes;
TopoDS_Vertex aV1, aV2;
TopoDS_Wire aWire = TopoDS::Wire(aShapeBase);
TopExp_Explorer exp (aWire, TopAbs_EDGE);
for (; exp.More(); exp.Next()) {
anEdgeShapes.Add(exp.Current());
TopoDS_Edge E = TopoDS::Edge(exp.Current());
TopExp::Vertices(E, aV1, aV2);
if ( aVertexShapes.Extent() == 0)
aVertexShapes.Add(aV1);
if ( !aV1.IsSame( aVertexShapes(aVertexShapes.Extent()) ) )
aVertexShapes.Add(aV1);
if ( !aV2.IsSame( aVertexShapes(aVertexShapes.Extent()) ) )
aVertexShapes.Add(aV2);
}
if (index < 0 || index > aVertexShapes.Extent())
Standard_NullObject::Raise("Vertex index is out of range");
if (aWire.Orientation() == TopAbs_FORWARD)
aVertex = BRep_Tool::Pnt(TopoDS::Vertex(aVertexShapes(index+1)));
else
aVertex = BRep_Tool::Pnt(TopoDS::Vertex(aVertexShapes(aVertexShapes.Extent() - index)));
} else {
Standard_NullObject::Raise("Shape for vertex calculation is not an edge or wire");
}
aShape = BRepBuilderAPI_MakeVertex(aVertex).Shape();
}
else if (aType == VECTOR_FACE_NORMALE)
{
// Face
Handle(GEOM_Function) aRefBase = aCI.GetBase();
TopoDS_Shape aShapeBase = aRefBase->GetValue();
if (aShapeBase.IsNull()) {
Standard_NullObject::Raise("Face for normale calculation is null");
}
if (aShapeBase.ShapeType() != TopAbs_FACE) {
Standard_NullObject::Raise("Shape for normale calculation is not a face");
}
TopoDS_Face aFace = TopoDS::Face(aShapeBase);
// Point
gp_Pnt p1 (0,0,0);
Handle(GEOM_Function) aPntFunc = aCI.GetPoint();
if (!aPntFunc.IsNull())
{
TopoDS_Shape anOptPnt = aPntFunc->GetValue();
if (anOptPnt.IsNull())
Standard_NullObject::Raise("Invalid shape given for point argument");
p1 = BRep_Tool::Pnt(TopoDS::Vertex(anOptPnt));
}
else
{
gp_Ax3 aPos = GEOMImpl_IMeasureOperations::GetPosition(aFace);
p1 = aPos.Location();
}
// Point parameters on surface
Handle(Geom_Surface) aSurf = BRep_Tool::Surface(aFace);
Handle(ShapeAnalysis_Surface) aSurfAna = new ShapeAnalysis_Surface (aSurf);
gp_Pnt2d pUV = aSurfAna->ValueOfUV(p1, Precision::Confusion());
// Normal direction
gp_Vec Vec1,Vec2;
BRepAdaptor_Surface SF (aFace);
SF.D1(pUV.X(), pUV.Y(), p1, Vec1, Vec2);
if (Vec1.Magnitude() < Precision::Confusion()) {
gp_Vec tmpV;
gp_Pnt tmpP;
SF.D1(pUV.X(), pUV.Y()-0.1, tmpP, Vec1, tmpV);
}
else if (Vec2.Magnitude() < Precision::Confusion()) {
gp_Vec tmpV;
gp_Pnt tmpP;
SF.D1(pUV.X()-0.1, pUV.Y(), tmpP, tmpV, Vec2);
}
gp_Vec V = Vec1.Crossed(Vec2);
Standard_Real mod = V.Magnitude();
if (mod < Precision::Confusion())
Standard_NullObject::Raise("Normal vector of a face has null magnitude");
// Set length of normal vector to average radius of curvature
Standard_Real radius = 0.0;
GeomLProp_SLProps aProperties (aSurf, pUV.X(), pUV.Y(), 2, Precision::Confusion());
if (aProperties.IsCurvatureDefined()) {
Standard_Real radius1 = Abs(aProperties.MinCurvature());
Standard_Real radius2 = Abs(aProperties.MaxCurvature());
if (Abs(radius1) > Precision::Confusion()) {
radius = 1.0 / radius1;
if (Abs(radius2) > Precision::Confusion()) {
radius = (radius + 1.0 / radius2) / 2.0;
}
}
else {
if (Abs(radius2) > Precision::Confusion()) {
radius = 1.0 / radius2;
}
}
}
// Set length of normal vector to average dimension of the face
// (only if average radius of curvature is not appropriate)
if (radius < Precision::Confusion()) {
Bnd_Box B;
Standard_Real Xmin, Xmax, Ymin, Ymax, Zmin, Zmax;
BRepBndLib::Add(aFace, B);
B.Get(Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
radius = ((Xmax - Xmin) + (Ymax - Ymin) + (Zmax - Zmin)) / 3.0;
}
if (radius < Precision::Confusion())
radius = 1.0;
V *= radius / mod;
// consider the face orientation
if (aFace.Orientation() == TopAbs_REVERSED ||
aFace.Orientation() == TopAbs_INTERNAL) {
V = - V;
}
// Edge
gp_Pnt p2 = p1.Translated(V);
BRepBuilderAPI_MakeEdge aBuilder (p1, p2);
if (!aBuilder.IsDone())
Standard_NullObject::Raise("Vector construction failed");
aShape = aBuilder.Shape();
}
else {
}
if (aShape.IsNull()) return 0;
aFunction->SetValue(aShape);
log.SetTouched(Label());
return 1;
}
