//--------------------------------------------------------------------------------------------------
public static Dictionary <TopoDS_Face, TopoDS_Edge> FindConnectedFaces(TopoDS_Shape shape, TopoDS_Face face)
{
var list = new Dictionary <TopoDS_Face, TopoDS_Edge>();
// Get map of all faces with their ancestors
var faceMap = new TopTools_IndexedDataMapOfShapeListOfShape(50);
TopExp.MapShapesAndAncestors(shape, TopAbs_ShapeEnum.TopAbs_EDGE, TopAbs_ShapeEnum.TopAbs_FACE, faceMap);
foreach (var edge in face.Edges())
{
var faceList = faceMap.FindFromKey(edge).ToList();
foreach (var connectedFace in faceList)
{
if (connectedFace.IsSame(face))
{
continue;
}
if (list.Keys.Any(f => connectedFace.IsSame(f)))
{
continue;
}
list.Add(connectedFace.ToFace(), edge);
}
}
return(list);
}
//--------------------------------------------------------------------------------------------------
public static TopoDS_Face FindConnectedFace(TopoDS_Shape shape, TopoDS_Face face, TopoDS_Edge sharedEdge)
{
// Get map of all faces with their ancestors
var faceMap = new TopTools_IndexedDataMapOfShapeListOfShape(50);
TopExp.MapShapesAndAncestors(shape, TopAbs_ShapeEnum.TopAbs_EDGE, TopAbs_ShapeEnum.TopAbs_FACE, faceMap);
foreach (var edge in face.Edges())
{
if (edge.IsSame(sharedEdge))
{
var faceList = faceMap.FindFromKey(edge).ToList();
foreach (var connectedFace in faceList)
{
if (connectedFace.IsSame(face))
{
continue;
}
return(connectedFace.ToFace());
}
}
}
return(null);
}
//--------------------------------------------------------------------------------------------------
protected TopoDS_Edge GetOperandEdge(int operandIndex, SubshapeReference edgeRef, TopoDS_Face forFace = null)
{
var operand = GetOperand(operandIndex);
if (operand == null)
{
return(null);
}
// Find target edge
var edges = operand.FindSubshape(edgeRef, GetCoordinateSystem());
if (edges == null || edges.Count == 0)
{
Messages.Error("The edge index is invalid and must be re-selected.");
return(null);
}
if (forFace == null)
{
return(edges[0].ToEdge());
}
// Find the proper oriented for the given face
return(forFace.Edges().Find(e => e.IsSame(edges[0])));
}
//--------------------------------------------------------------------------------------------------
bool _IsFaceOfBendSection(TopoDS_Face face, BendParameter bendParams)
{
if (bendParams == null)
{
bendParams = new BendParameter(); // Temporary usage
}
// Each face of a bend section has two circular edges
var edges = face.Edges();
var foundCircularEdges = 0;
foreach (var edge in edges)
{
var edgeAdaptor = new BRepAdaptor_Curve(edge);
if (edgeAdaptor.GetGeomType() == GeomAbs_CurveType.GeomAbs_Circle)
{
foundCircularEdges++;
if (bendParams.Edges[0] == null)
{
bendParams.Edges[0] = edge;
bendParams.Axes[0] = edgeAdaptor.Circle().Position();
bendParams.Radii[0] = edgeAdaptor.Circle().Radius();
bendParams.AngleRad = edgeAdaptor.LastParameter() - edgeAdaptor.FirstParameter();
}
else
{
if (!bendParams.Axes[0].Axis.IsCoaxial(edgeAdaptor.Circle().Axis(), 0.01f, 0.001f) ||
!bendParams.AngleRad.IsEqual(edgeAdaptor.LastParameter() - edgeAdaptor.FirstParameter(), 0.01))
{
return(false); // Circular edge with unproper parameters detected
}
if (bendParams.Edges[1] == null)
{
// Second edge of bend surface
bendParams.Edges[1] = edge;
bendParams.Axes[1] = edgeAdaptor.Circle().Position();
break;
}
// Additional edges, find free place
for (int edgeIndex = 0; edgeIndex < bendParams.Edges.Length; edgeIndex++)
{
if (bendParams.Edges[edgeIndex] == null)
{
bendParams.Edges[edgeIndex] = edge;
break;
}
if (bendParams.Edges[edgeIndex].IsSame(edge))
{
break;
}
}
if (!edgeAdaptor.Circle().Radius().IsEqual(bendParams.Radii[0], 0.000001))
{
bendParams.Radii[1] = edgeAdaptor.Circle().Radius();
}
}
}
}
// Coaxial circle edges not found, this is not a bend section
if (foundCircularEdges != 2)
{
return(false);
}
return(true);
}
//--------------------------------------------------------------------------------------------------
public static bool ComputeAxisFromVertex(TopoDS_Face face, TopoDS_Vertex vertex, out Ax1 axis)
{
// Get normal at point of vertex
var uv = BRep_Tool.Parameters(vertex, face);
Pnt centerPoint = Pnt.Origin;
Vec faceNormal = Vec.Zero;
new BRepGProp_Face(face).Normal(uv.X, uv.Y, ref centerPoint, ref faceNormal);
// Find edges
var edges = face.Edges(false).Where(edge => edge.Vertices().ContainsSame(vertex)).ToList();
if (edges.Count != 2)
{
axis = new Ax1();
return(false);
}
// Calc direction
bool order = false; // is false if face is on the left of edge1
var tangents = new Vec[2];
for (var edgeIndex = 0; edgeIndex < edges.Count; edgeIndex++)
{
var edge = edges[edgeIndex];
var edgeAdaptor = edge.Adaptor();
var parameter = BRep_Tool.Parameter(vertex, edge);
Pnt unusedPoint = Pnt.Origin;
Vec edgeTangent = Vec.Zero;
edgeAdaptor.D1(parameter, ref unusedPoint, ref edgeTangent);
var parameterReversed = parameter > (edgeAdaptor.FirstParameter() + edgeAdaptor.LastParameter()) * 0.5;
if (parameterReversed)
{
edgeTangent.Reverse();
}
if (edgeIndex == 0 && parameterReversed != (edge.Orientation() == TopAbs_Orientation.TopAbs_REVERSED))
{
order = true; // face is on the right of edge1
}
tangents[edgeIndex] = edgeTangent.Normalized();
}
var direction = tangents[0].Added(tangents[1]);
var angleBetweenTangents = tangents[0].AngleWithRef(tangents[1], faceNormal);
if (order)
{
angleBetweenTangents *= -1.0;
}
if (angleBetweenTangents < 0)
{
// Concave vertex
direction.Reverse();
}
axis = new Ax1(centerPoint, direction.ToDir());
return(true);
}
