Attributes of Topological Structures​

Orientation

There are 4 types of OrientationType: Forward, Reversed, Internal, and External, with Forward and Reversed being the most commonly used. Any level of TopoShape can set its Orientation using SetOrientation() or retrieve its Orientation using Orientation(). If you want to get a TopoShape that only differs in Orientation from the current TopoShape, you can use Orientated().Orientation is independent of geometry and Location, meaning that changing one will not affect any other members.

Vertex

For an Edge, the Orientation of the starting Vertex is Forward, and the Orientation of the ending Vertex is Reversed. For example, a line segment Edge with two different Vertices will have one with Forward Orientation and the other with Reversed Orientation. Similarly, an Edge formed by a circle with two identical Vertices will still have one Vertex with Forward Orientation and the other with Reversed Orientation.

auto c = std::make_shared<AMCAX::Geom3Circle>(AMCAX::Frame3(), 1.0);
//Make a vertex
AMCAX::TopoVertex v1 = AMCAX::MakeVertex(AMCAX::Point3(1.0, 0.0, 0.0));
AMCAX::TopoVertex v2 = AMCAX::MakeVertex(AMCAX::Point3(1.0, 0.0, 0.0));
//Set the orientation of v2 to Reversed  
v2.SetOrientation(AMCAX::OrientationType::Reversed);
 
//Make a edge
AMCAX::TopoEdge edge;
AMCAX::TopoBuilder builder;
builder.MakeEdge(edge, c, AMCAX::Precision::Confusion());
// Add different vertices
builder.Add(edge, v1);
builder.Add(edge, v2);
std::cout << AMCAX::TopoTool::IsClosed(edge) << std::endl;//0
//Make a edge2
AMCAX::TopoEdge edge2;
builder.MakeEdge(edge2, c, AMCAX::Precision::Confusion());
// Add same vertices
builder.Add(edge2, v1);
builder.Add(edge2, v1.Oriented(AMCAX::OrientationType::Reversed));
std::cout << AMCAX::TopoTool::IsClosed(edge2) << std::endl;//1

Note: In this example, because the Edge formed by a circle has two identical Vertices, only one vertex needs to be constructed. In this case, AMCAX::TopoTool::IsClosed(edge) will return true. If two vertices are constructed, AMCAX::TopoTool::IsClosed(edge) will return false.

Edge

The Forward direction of an Edge is the direction of curve3d. If there is no curve3d, it's the direction of the pcurve. The direction of a Reversed Edge is opposite to that of the curve.
For example, given three Edges formed using 3d curves on the xoy plane and a Geom3Plane constructed using the natural frame:

Since the direction of the Wire must be counterclockwise in the parameter domain, Reversed Edge0, Forward Edge2, and Forward Edge1 should form the Wire.

If a clockwise Wire is used, i.e., Forward Edge0, Reversed Edge1, and Reversed Edge2, the Face will define the region outside the Wire. Below are the counterclockwise and clockwise Wires:

If the Geom3Plane is constructed using Frame3(O, -OZ, OX), the Wire direction should be clockwise, i.e., Forward Edge0, Reversed Edge1, and Reversed Edge2, ensuring that the Face is correctly defined as the area enclosed by the Wire.

Wire

Reversing a Wire is equivalent to reversing the Orientation of each Edge in the Forward Wire.

//Make a box
AMCAX::MakeBox box(AMCAX::Point3(-5.0, -5.0, 0.0), AMCAX::Point3(5.0, 5.0, 3.0));
//Get the wire from box
AMCAX::IndexSet< AMCAX::TopoShape > wireSet;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Wire, wireSet);
AMCAX::TopoWire wire1 = AMCAX::TopoCast::Wire(wireSet[0]);
//Get the edge from wire1
AMCAX::IndexSet< AMCAX::TopoShape > edgeSet;
AMCAX::TopoExplorerTool::MapShapes(wire1, AMCAX::ShapeType::Edge, edgeSet);
AMCAX::TopoEdge edge1 = AMCAX::TopoCast::Edge(edgeSet[0]);
std::cout << int(edge1.Orientation()) << std::endl;//0
 
//Reverse the orientation of the wire1
AMCAX::TopoWire rewire = AMCAX::TopoCast::Wire(wire1.Reversed());
//Get the edge from rewire
AMCAX::IndexSet< AMCAX::TopoShape > edgeSet2;
AMCAX::TopoExplorerTool::MapShapes(rewire, AMCAX::ShapeType::Edge, edgeSet2);
AMCAX::TopoEdge reedge = AMCAX::TopoCast::Edge(edgeSet2[0]);
std::cout << int(reedge.Orientation()) << std::endl;//1

Face

Reversing a Face changes the direction of the region it encloses to the opposite of the surface normal. Reversing a Face is equivalent to reversing the Orientation of each Wire in the Forward Face.

//Make a box
AMCAX::TopoShape box = AMCAX::MakeBox(AMCAX::Point3(-5.0, -5.0, 0.0), AMCAX::Point3(5.0, 5.0, 3.0));
//Get the face from box
AMCAX::IndexSet< AMCAX::TopoShape > faceSet;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Face, faceSet);
AMCAX::TopoFace face1 = AMCAX::TopoCast::Face(faceSet[0]);
std::cout << int(face1.Orientation()) << std::endl;//1
//Get the wire from face1
AMCAX::IndexSet< AMCAX::TopoShape > wireSet;
AMCAX::TopoExplorerTool::MapShapes(face1, AMCAX::ShapeType::Wire, wireSet);
AMCAX::TopoWire wire1 = AMCAX::TopoCast::Wire(wireSet[0]);
std::cout << int(wire1.Orientation()) << std::endl;//1
 
//Reverse the orientation of the face1
AMCAX::TopoFace reface1 = AMCAX::TopoCast::Face(face1.Reversed());
std::cout << int(reface1.Orientation()) << std::endl;//0
//Get the wire from reface
AMCAX::IndexSet< AMCAX::TopoShape > rewireSet;
AMCAX::TopoExplorerTool::MapShapes(reface1, AMCAX::ShapeType::Wire, rewireSet);
AMCAX::TopoWire rewire1 = AMCAX::TopoCast::Wire(rewireSet[0]);
std::cout << int(rewire1.Orientation()) << std::endl;//0

The method to retrieve the normal of the surface where the Face lies is as follows:

AMCAX::TopoLocation location;
//Get the surface of face1
std::shared_ptr< AMCAX::Geom3Surface > surface = AMCAX::TopoTool::Surface(face1, location);
//Compute first derivatives at parametric coordinates (0.5, 0.5)
AMCAX::Point3 p;
AMCAX::Vector3 du, dv;
surface->D1(0.5, 0.5, p, du, dv);
//Calculate surface normal via cross product of derivatives
AMCAX::Vector3 normal = du.Cross(dv);
std::cout << "normal:" << normal << std::endl;//-1 0 0

Shell

Reversing a Shell changes the direction of the region it encloses to the opposite direction. Reversing a Shell is equivalent to reversing the Orientation of each Face in the Forward Shell.

//Make a box
AMCAX::MakeBox box(AMCAX::Point3(-5.0, -5.0, 0.0), AMCAX::Point3(5.0, 5.0, 3.0));
//Get the shell from box
AMCAX::TopoShell shell = box.Shell();
//Get the face from shell
AMCAX::IndexSet< AMCAX::TopoShape > faceSet;
AMCAX::TopoExplorerTool::MapShapes(shell, AMCAX::ShapeType::Face, faceSet);
AMCAX::TopoFace face1 = AMCAX::TopoCast::Face(faceSet[0]);
std::cout << int(face1.Orientation()) << std::endl;//1
 
//Reverse the orientation of the shell
AMCAX::TopoShell reshell = AMCAX::TopoCast::Shell(shell.Reversed());
//Get the face from reshell
AMCAX::IndexSet< AMCAX::TopoShape > refaceSet;
AMCAX::TopoExplorerTool::MapShapes(reshell, AMCAX::ShapeType::Face, refaceSet);
AMCAX::TopoFace reface1 = AMCAX::TopoCast::Face(refaceSet[0]);
std::cout << int(reface1.Orientation()) << std::endl;//0

Solid

Reversing a Solid changes the direction of the region it encloses to the opposite direction. Reversing a Solid is equivalent to reversing the Orientation of each Face in the Forward Solid.

//Make a box
AMCAX::MakeBox box(AMCAX::Point3(-5.0, -5.0, 0.0), AMCAX::Point3(5.0, 5.0, 3.0));
//Get the solid and shell from box
AMCAX::TopoSolid solid = box.Solid();
AMCAX::TopoShell shell = box.Shell();
std::cout << int(shell.Orientation()) << std::endl;//0
 
//Reverse the orientation of the solid
AMCAX::TopoSolid resolid = AMCAX::TopoCast::Solid(solid.Reversed());
//Get the shell from resolid
AMCAX::IndexSet< AMCAX::TopoShape > reshellSet;
AMCAX::TopoExplorerTool::MapShapes(resolid, AMCAX::ShapeType::Shell, reshellSet);
AMCAX::TopoShell reshell1 = AMCAX::TopoCast::Shell(reshellSet[0]);
std::cout << int(reshell1.Orientation()) << std::endl;//1

Tolerance

Tolerance represents the amount of error in a TopoShape. For example, a vertex on the curve of Edge1 is at Point3(0.0, 0.0, 0.0), and the same vertex on the curve of Edge2 is at Point3(1.0, 0.0, 0.0). With a tolerance of 2.0, these two points can be considered as the same point. In other words, although the geometric points of this vertex on different edges are different, it is still valid as a topological structure.
To obtain the Tolerance of a TopoShape, the method is: AMCAX::TopoTool::Tolerance(). Only structures containing geometric information, such as Vertex, Edge, and Face, have Tolerance. To change the Tolerance, the methods are: AMCAX::TopoBuilder::UpdateVertex(), AMCAX::TopoBuilder::UpdateEdge(), AMCAX::TopoBuilder::UpdateFace().

Next, we will introduce the Tolerance for Vertex, Edge, and Face in turn:

Vertex

The Tolerance of a Vertex is a predefined value. Its significance is that when the distance from a Point to the Vertex (i.e., the distance from the Point to the Point within the Vertex) is less than or equal to the Tolerance, the Point is considered to lie on the Vertex. The Point in a Vertex can come from various sources: the Point3 itself, the value of a Curve at a certain parameter, or the value of a Surface at certain u,v parameters. The Tolerance of the Vertex must be no less than the maximum distance between these points.

AMCAX::Point3 p1(0., 0., 0.);
auto circle = std::make_shared<AMCAX::Geom3Circle>(AMCAX::Frame3(), 1.0);
//Get the first parameter
double fp = circle->FirstParameter();
//Get the first point
AMCAX::Point3 p2 = circle->Value(fp);
 
//Make a vertex , and the tolerance is 2.0
AMCAX::TopoVertex v1;
AMCAX::TopoBuilder builder;
builder.MakeVertex(v1, p1, 2.0);
AMCAX::TopoVertex v2;
builder.MakeVertex(v2, p2, 2.0);
std::cout << AMCAX::TopoTool::Tolerance(v1);//2.0
std::cout << AMCAX::TopoTool::Tolerance(v2);//2.0
 
//Update the tolerance
double tol = 2.5;
builder.UpdateVertex(v1, p1, tol);
builder.UpdateVertex(v2, p2, tol);
std::cout << AMCAX::TopoTool::Tolerance(v1);//2.5
std::cout << AMCAX::TopoTool::Tolerance(v2);//2.5

Edge

The Tolerance of an Edge is a predefined value. Its significance is that when the distance from a Point to the Edge is less than or equal to the Tolerance, the Point is considered to lie on the Edge. Additionally, an Edge has a curve3d and a pcurve, where the pcurve can be used to construct an equivalent curve3d through a Surface. The maximum distance between multiple curve3d samples must not exceed the Tolerance of the Edge. If this condition is not met, the Tolerance of the Edge must be increased. Furthermore, the Tolerance of a Vertex must be greater than or equal to the Tolerance of the Edge it lies on.

AMCAX::Point3 p1(0., 0., 0.);
auto circle = std::make_shared<AMCAX::Geom3Circle>(AMCAX::Frame3(), 1.0);
//Get the first parameter
double fp = circle->FirstParameter();
//Get the first point
AMCAX::Point3 p2 = circle->Value(fp);
 
//Make a vertex , and the tolerance is 2.0
AMCAX::TopoVertex v1;
AMCAX::TopoBuilder builder;
builder.MakeVertex(v1, p1, 2.0);
AMCAX::TopoVertex v2;
builder.MakeVertex(v2, p2, 2.0);
//Make a edge
AMCAX::MakeEdge e(v1, v2);
AMCAX::TopoEdge edge = e.Edge();
std::cout << AMCAX::TopoTool::Tolerance(edge);//1e-7
//Update the tolerance
builder.UpdateEdge(edge, 1.0);
std::cout << AMCAX::TopoTool::Tolerance(edge);//1.0

Face

The Tolerance of a Face is a predefined value. Its significance is that when the distance from a Point to the Face is less than or equal to the Tolerance, the Point is considered to lie on the Face. This is often used in Boolean operations. Additionally, the Tolerance of a Vertex or Edge must be greater than or equal to the Tolerance of the Face they lie on.

AMCAX::TopoBuilder builder;
AMCAX::Frame3 frame;
AMCAX::Geom3Plane plane(frame);
//Make a face
AMCAX::TopoFace face = AMCAX::MakeFace(plane.GetPlane(), 0., 2., 0., 2.);
std::cout << AMCAX::TopoTool::Tolerance(face);//1e-7
//Update the tolerance
builder.UpdateFace(face, 0.5);
std::cout << AMCAX::TopoTool::Tolerance(face);//0.5

Note: When there is a dependency relationship, the Tolerance of a Vertex must be greater than or equal to the Tolerance of an Edge, and the Tolerance of an Edge must be greater than or equal to the Tolerance of a Face.

Closed

Whether a TopoShape is closed is a crucial flag. We can use AMCAX::TopoTool::IsClosed() to determine if a TopoShape is closed. This should be distinguished from AMCAX::TopoShape::Closed(), which returns a boolean flag that can be arbitrarily defined by the user. For example, even if a line segment is constructed into an Edge that is not closed, it can still be set as closed using AMCAX::TopoShape::Closed(true).

AMCAX::Point3 p0;
AMCAX::Point3 p1(1.0, 0.0, 0.0);
AMCAX::TopoEdge edge = AMCAX::MakeEdge(p0, p1);
edge.Closed(true);
std::cout << edge.Closed() << std::endl;//1
std::cout << AMCAX::TopoTool::IsClosed(edge) << std::endl;//0

On the other hand, AMCAX::TopoTool::IsClosed() performs a topological check on certain types of TopoShape. Below is an explanation of how AMCAX::TopoTool::IsClosed() works for different ShapeType inputs.

Edge

AMCAX::TopoTool::IsClosed() is used to determine whether the FirstVertex and LastVertex of an Edge are the same (IsSame).

auto c = std::make_shared<AMCAX::Geom3Circle>(AMCAX::Frame3(), 1.0);
AMCAX::TopoVertex v1 = AMCAX::MakeVertex(AMCAX::Point3(1.0, 0.0, 0.0));
AMCAX::TopoEdge edge1 = AMCAX::MakeEdge(c, v1, v1);
std::cout << AMCAX::TopoTool::IsClosed(edge1) << std::endl;//1

Wire

AMCAX::TopoTool::IsClosed() is used to determine whether a Wire has no boundary Vertex, meaning that each Vertex in the Wire appears an even number of times.

AMCAX::MakePolygon polygon(AMCAX::Point3(-1., -1., 0.), AMCAX::Point3(1., -1., 0.), AMCAX::Point3(1., 1., 0.), AMCAX::Point3(-1., 1., 0.),true);
AMCAX::TopoWire w = polygon.Wire();
std::cout << AMCAX::TopoTool::IsClosed(w) << std::endl;//1

Shell

AMCAX::TopoTool::IsClosed() is used to determine whether a Shell has no boundary Edge (free Edge), meaning that each Edge in the Shell (excluding degenerate edges) appears an even number of times.

AMCAX::MakeBox box(2., 2., 2.);
AMCAX::TopoShell shell = box.Shell();
std::cout << AMCAX::TopoTool::IsClosed(shell) << std::endl;//1

Others

For TopoShape types other than Edge, Wire, and Shell, the result of AMCAX::TopoTool::IsClosed() is the same as the result of AMCAX::TopoShape::Closed().

//Make a box
AMCAX::MakeBox box(2., 2., 2.);
 
//1. Solid
AMCAX::TopoSolid solid = box.Solid();
//Set open
solid.Closed(false);
std::cout << solid.Closed() << std::endl;//0
std::cout << AMCAX::TopoTool::IsClosed(solid) << std::endl;//0
//Set closed
solid.Closed(true);
std::cout << solid.Closed() << std::endl;//1
std::cout << AMCAX::TopoTool::IsClosed(solid) << std::endl;//1
 
//2. Face
AMCAX::IndexSet< AMCAX::TopoShape > FaceSet;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Face, FaceSet);
AMCAX::TopoFace face1 = AMCAX::TopoCast::Face(FaceSet[0]);
//Set open
face1.Closed(false);
std::cout << face1.Closed() << std::endl;//0
std::cout << AMCAX::TopoTool::IsClosed(face1) << std::endl;//0
//Set closed
face1.Closed(true);
std::cout << face1.Closed() << std::endl;//1
std::cout << AMCAX::TopoTool::IsClosed(face1) << std::endl;//1