Solid modeling

Creating Basic Shapes

Basic shapes include boxes, cylinders, cones/frustums, spheres, and tori.

Box

AMCAX::MakeBox provides functionality to create boxes.

Construct a box using three dimensions dx, dy, and dz.

double dx = 1.;
double dy = 1.;
double dz = 1.;
AMCAX::TopoShape box = AMCAX::MakeBox(dx, dy, dz);

Construct a box using a corner point and three dimensions dx, dy, and dz.

AMCAX::Point3 p(0., 0., 0.);// The corner point
double dx = 1.;
double dy = 2.;
double dz = 3.;
AMCAX::TopoShape box = AMCAX::MakeBox(p, dx, dy, dz);

Construct a box using two diagonal points.

AMCAX::Point3 p1(-5.0, -5.0, 0.0);// diagonal corner points
AMCAX::Point3 p2(5.0, 5.0, 3.0);// diagonal corner points
AMCAX::TopoShape box = AMCAX::MakeBox(p1, p2);

Construct a box using a local coordinate system and three dimensions dx, dy, and dz.

AMCAX::Frame3 frame;// The local coordinate system
double dx = 2.;
double dy = 3.;
double dz = 4.;
AMCAX::TopoShape box = AMCAX::MakeBox(frame, dx, dy, dz);

Cylinder

AMCAX::MakeCylinder provides functionality to create cylinders.

double r = 3.;// The radius
double h = 5.;// The height
AMCAX::TopoShape cylinder = AMCAX::MakeCylinder(r, h);

Cone/Frustum

AMCAX::MakeCone provides functionality to create cones/frustums.

double r1 = 4.;// The bottom radius
double r2 = 2.;// The top radius
double h = 4.;// The height
AMCAX::TopoShape cone = AMCAX::MakeCone(r1, r2, h);

Sphere

AMCAX::MakeSphere provides functionality to create spheres.

Construct a complete sphere using radius.

double r = 1.;
AMCAX::TopoShape sphere = AMCAX::MakeSphere(r);

Construct a partial sphere (crescent shape) using radius and rotation angle. The rotation angle should be in range (0, 2pi].

double r = 1.;
double angle = AMCAX::Constants::half_pi / 2;// The rotation angle (longitude)
AMCAX::TopoShape sphere = AMCAX::MakeSphere(r, angle);

Construct a segmented sphere using radius and angle range. angle1 should be less than angle2, and angles should be in [-pi/2, pi/2] range.

double r = 1.;
double angle1 = -AMCAX::Constants::quarter_pi;// The start angle (latitude)
double angle2 = AMCAX::Constants::quarter_pi;// The end angle (latitude)
AMCAX::TopoShape sphere = AMCAX::MakeSphere(r, angle1, angle2);

Construct a partial segmented sphere using radius, angle range, and rotation angle.

double r = 1.;
double angle1 = -AMCAX::Constants::quarter_pi;// The start angle (latitude)
double angle2 = AMCAX::Constants::quarter_pi;// The end angle (latitude)
double angle3 = AMCAX::Constants::half_pi;// The rotation angle (longitude)
AMCAX::TopoShape sphere = AMCAX::MakeSphere(r, angle1, angle2, angle3);

Torus

AMCAX::MakeTorus provides functionality to create tori.

Construct a complete torus using major and minor radii.

double r1 = 4.;// The major radius
double r2 = 2.;// The minor radius
AMCAX::TopoShape torus = AMCAX::MakeTorus(r1, r2);

Construct a partial torus using major radius, minor radius, and rotation angle.

double r1 = 4.;// The major radius
double r2 = 2.;// The minor radius
double angle = AMCAX::Constants::half_pi;// The rotation angle
AMCAX::TopoShape torus = AMCAX::MakeTorus(r1, r2, angle);

Construct a segmented torus using major radius, minor radius, and angle range.

double r1 = 4.;// The major radius
double r2 = 2.;// The minor radius
double angle1 = AMCAX::Constants::half_pi;// The start angle
double angle2 = AMCAX::Constants::pi;// The end angle
AMCAX::TopoShape torus = AMCAX::MakeTorus(r1, r2, angle1, angle2);

Construct a segmented torus using major radius, minor radius, angle range, and rotation angle.

double r1 = 4.;// The major radius
double r2 = 2.;// The minor radius
double angle1 = AMCAX::Constants::half_pi;// The start angle
double angle2 = AMCAX::Constants::pi;// The end angle
double angle3 = AMCAX::Constants::pi;// The rotation angle
AMCAX::TopoShape torus = AMCAX::MakeTorus(r1, r2, angle1, angle2, angle3);

Boolean Operations

Boolean operations include fuse, common, cut, split, and section computation.

Fuse

AMCAX::BoolBRepFuse provides fuse functionality.

// Make a box
double dx = 1.;
double dy = 1.;
double dz = 1.;
AMCAX::TopoShape box = AMCAX::MakeBox(dx, dy, dz);
 
// Make a torus
double r1 = 4.;// The major radius
double r2 = 2.;// The minor radius
AMCAX::TopoShape torus = AMCAX::MakeTorus(r1, r2);
 
// Compute the fuse of two shapes
AMCAX::TopoShape fuse = AMCAX::BoolBRepFuse(box, torus);

Common

AMCAX::BoolBRepCommon provides common functionality.

// Make a box
double dx = 5.;
double dy = 5.;
double dz = 5.;
AMCAX::TopoShape box = AMCAX::MakeBox(dx, dy, dz);
 
// Make a torus
double r1 = 4.;// The major radius
double r2 = 2.;// The minor radius
AMCAX::TopoShape torus = AMCAX::MakeTorus(r1, r2);
 
// Compute the common shape of two shapes
AMCAX::TopoShape common = AMCAX::BoolBRepCommon(box, torus);

Cut

AMCAX::BoolBRepCut provides cut functionality.

// Make a cone
double r1 = 4.;// The bottom radius
double r2 = 2.;// The top radius
double h = 4.;// The height
AMCAX::TopoShape cone = AMCAX::MakeCone(r1, r2, h);
 
// Make a sphere
double r = 4.;
AMCAX::TopoShape sphere = AMCAX::MakeSphere(r);
 
// Compute the cut operation of two shapes
AMCAX::TopoShape cut = AMCAX::BoolBRepCut(sphere, cone);

Split

AMCAX::BoolBRepSplitter provides split functionality.

// Make a box
double dx = 5.;
double dy = 5.;
double dz = 5.;
AMCAX::TopoShape box = AMCAX::MakeBox(dx, dy, dz);
 
// Make a torus
double r1 = 4.;// The major radius
double r2 = 2.;// The minor radius
AMCAX::TopoShape torus = AMCAX::MakeTorus(r1, r2);
 
// Split
AMCAX::BoolBRepSplitter splitter;
auto tool_shape = std::list{ box };
auto tool_argument = std::list{ torus };
splitter.SetTools(tool_shape);
splitter.SetArguments(tool_argument);
 
// Get the resulting shape
AMCAX::TopoShape split = splitter.Shape();

Section Computation

AMCAX::BoolBRepSection provides section computation functionality, with results saved as TopoCompound.

// Make a cone
double r1 = 4.;// The bottom radius
double r2 = 2.;// The top radius
double h = 4.;// The height
AMCAX::TopoShape cone = AMCAX::MakeCone(r1, r2, h);
 
// Make a sphere
double r = 4.;
AMCAX::TopoShape sphere = AMCAX::MakeSphere(r);
 
// Compute the section of two shapes
AMCAX::TopoShape section = AMCAX::BoolBRepSection(cone, sphere);

Directly calling the interface as above won't compute parameter curves in the shape. To compute parameter curves, you need to initialize first and then compute the section.

// Make a cone
double r1 = 4.;// The bottom radius
double r2 = 2.;// The top radius
double h = 4.;// The height
AMCAX::TopoShape cone = AMCAX::MakeCone(r1, r2, h);
 
// Make a sphere
double r = 4.;
AMCAX::TopoShape sphere = AMCAX::MakeSphere(r);
 
// Compute the section of two shapes
AMCAX::BoolBRepSection section;
section.Init1(cone);
section.ComputePCurveOn1(true);
section.Init2(sphere);
section.ComputePCurveOn2(true);
section.Build();
 
// Get the resulting shape
AMCAX::TopoShape result = section.Shape();

Sweep Operations

Extrusion

AMCAX::MakePrism provides extrusion (sweep) functionality.

// Construct a 3D geometric ellipse
AMCAX::Frame3 frame;
double majorRadius = 3.;
double minorRadius = 1.;
AMCAX::MakeGeom3Ellipse mge(frame, majorRadius, minorRadius);
std::shared_ptr<AMCAX::Geom3Curve> curve = mge.Value();
 
// Make a face
AMCAX::TopoEdge e = AMCAX::MakeEdge(curve);
AMCAX::TopoWire w = AMCAX::MakeWire(e);
AMCAX::TopoFace f = AMCAX::MakeFace(w);
 
// Make an extrusion shape
AMCAX::Vector3 vec(0.0, 0.0, 1.0);// The extrusion vector
AMCAX::TopoShape s = AMCAX::MakePrism(f, vec);

Revolution

AMCAX::MakeRevol provides revolution (sweep) functionality.

// Construct a bezier curve
std::vector<AMCAX::Point3> poles
{ AMCAX::Point3(1.0, 0.0, 0.0),
    AMCAX::Point3(0.8, 0.0, 0.5),
    AMCAX::Point3(1.0, 0.0, 1.0)
};
auto bezier = std::make_shared<AMCAX::Geom3BezierCurve>(poles);
 
// Make an edge
AMCAX::TopoEdge e = AMCAX::MakeEdge(bezier);
 
// Make a revolved shape
AMCAX::Axis3 axis = AMCAX::CartesianCoordinateSystem::OZ();// The rotation axis
AMCAX::TopoShape revolshape = AMCAX::MakeRevol(e, axis);

Pipe

Create pipes by specifying spine (wire) and profile (shape). Can be implemented using AMCAX::MakePipe or AMCAX::MakePipeShell.

MakePipe

AMCAX::MakePipe class is a simple pipe algorithm, only suitable for single cross-section (planar shape) and smooth path.

// Make a face
AMCAX::Point3 point(0., 0., 0.);
AMCAX::Direction3 dir(-8.57143, 0., 4.);
AMCAX::Frame3 frame(point, dir);
double radius = 0.1;
AMCAX::Circle3 circle = AMCAX::Circle3(frame, radius);
AMCAX::TopoEdge Edge = AMCAX::MakeEdge(circle);
AMCAX::TopoWire Wire = AMCAX::MakeWire(Edge);
AMCAX::TopoFace Face = AMCAX::MakeFace(Wire);// The profile to be swept
 
// Compute the resulting curve by interpolating points
std::vector<AMCAX::Point3> points;
points.push_back(AMCAX::Point3(0., 0., 0.));
points.push_back(AMCAX::Point3(-1., 0., 1.));
points.push_back(AMCAX::Point3(0., 0., 2.));
points.push_back(AMCAX::Point3(1., 0., 3.));
points.push_back(AMCAX::Point3(0., 0., 4.));
int degree = 2.;
bool IsClosed = false;
std::shared_ptr<AMCAX::Geom3BSplineCurve> BSplineCurve = AMCAX::NURBSAPIInterpolate::InterpolatePoints(points, degree, IsClosed, AMCAX::ApproxParameterizationType::Centripetal);
 
// Make a wire
AMCAX::TopoEdge SpineEdge = AMCAX::MakeEdge(BSplineCurve);
AMCAX::TopoWire SpineWire = AMCAX::MakeWire(SpineEdge);// The spine
 
// Make a pipe
AMCAX::TopoShape Pipe = AMCAX::MakePipe(SpineWire, Face);

Results shown below:

MakePipeShell

AMCAX::MakePipeShell class is a more complete pipe algorithm, supporting multiple cross-sections (planar shapes) and non-smooth paths. However, the path (should not self-intersect) must intersect with the cross-section plane. Note: Add can only be TopoWire or TopoVertex.

// Construct two profiles
AMCAX::Point3 point1(0., 0., 0.);
AMCAX::Direction3 dir1(-8.57143, 0., 4.);
AMCAX::Frame3 frame1(point1, dir1);
double radius1 = 0.1;
AMCAX::Circle3 circle1 = AMCAX::Circle3(frame1, radius1);
AMCAX::TopoEdge Edge1 = AMCAX::MakeEdge(circle1);
AMCAX::TopoWire Wire1 = AMCAX::MakeWire(Edge1);
 
AMCAX::Point3 point2(0., 0., 4.);
AMCAX::Direction3 dir2(-8.57143, 0., 4.);
AMCAX::Frame3 frame2(point2, dir2);
double radius2 = 0.5;
AMCAX::Circle3 circle2 = AMCAX::Circle3(frame2, radius2);
AMCAX::TopoEdge Edge2 = AMCAX::MakeEdge(circle2);
AMCAX::TopoWire Wire2 = AMCAX::MakeWire(Edge2);
 
// Compute the spline
std::vector<AMCAX::Point3> points;
points.push_back(AMCAX::Point3(0., 0., 0.));
points.push_back(AMCAX::Point3(-1., 0., 1.));
points.push_back(AMCAX::Point3(0., 0., 2.));
points.push_back(AMCAX::Point3(1., 0., 3.));
points.push_back(AMCAX::Point3(0., 0., 4.));
int degree = 2.;
bool IsClosed = false;
std::shared_ptr<AMCAX::Geom3BSplineCurve> BSplineCurve = AMCAX::NURBSAPIInterpolate::InterpolatePoints(points, degree, IsClosed, AMCAX::ApproxParameterizationType::Centripetal);
// Make a wire
AMCAX::TopoEdge SpineEdge = AMCAX::MakeEdge(BSplineCurve);
AMCAX::TopoWire SpineWire = AMCAX::MakeWire(SpineEdge);
 
// Make a pipe shell
AMCAX::MakePipeShell mkPipeShell(SpineWire);
mkPipeShell.SetMode(false);// Frenet method
mkPipeShell.SetTransitionMode(AMCAX::TransitionMode::Transformed);
 
// Add a profile and set parameters
bool withContact = false;
bool withCorrection = true;
mkPipeShell.Add(Wire1, withContact, withCorrection);
mkPipeShell.Add(Wire2, withContact, withCorrection);
 
// Get the resulting shape
mkPipeShell.Build();
AMCAX::TopoShape pipeshell = mkPipeShell.Shape();

Results shown below:

Lofting Operation

AMCAX::MakeLoft class provides lofting functionality. Add several wires to loft a shell or solid.

// Make a polygon
AMCAX::Point3 Point1(1., 0., 0.);
AMCAX::Point3 Point2(-0.5, std::sqrt(3.) * 0.5, 0.);
AMCAX::Point3 Point3(-0.5, -std::sqrt(3.) * 0.5, 0.);
bool isclosed = true;
AMCAX::MakePolygon aPolygon(Point1, Point2, Point3, isclosed);
 
// Get the polygon wire
AMCAX::TopoWire bottomWire = aPolygon.Wire();
 
// Get the top wire 
AMCAX::Transformation3 Transform;
AMCAX::Axis3 axis = AMCAX::CartesianCoordinateSystem::OZ();// The rotation axis
double angle = -AMCAX::Constants::pi / 6.0;// The rotation angle
AMCAX::Vector3 vec(0., 0., 3.);
Transform.SetRotation(axis, angle);// The translation vector
Transform.SetTranslationPart(vec);
AMCAX::TopoShape transform = AMCAX::TransformShape(bottomWire, Transform);
AMCAX::TopoWire topWire = AMCAX::TopoCast::Wire(transform);
 
// Make a lofting shape
bool isSolid = true;
bool ruled = true;
AMCAX::MakeLoft MakeLoft(isSolid, ruled);
// Add wire
MakeLoft.AddWire(bottomWire);
MakeLoft.AddWire(topWire);
// Get the resulting shape
MakeLoft.Build();
AMCAX::TopoShape loft = MakeLoft.Shape();

Edge Processing

Fillet

Filleting is an operation that replaces sharp edges with smooth surfaces. AMCAX::MakeFillet and AMCAX::MakeFillet2d classes can be used for filleting geometric shapes.

Fillet

Constant Radius

// Make a box
AMCAX::Point3 p1(-5.0, -5.0, 0.0);// diagonal corner points
AMCAX::Point3 p2(5.0, 5.0, 3.0);// diagonal corner points
AMCAX::TopoShape box = AMCAX::MakeBox(p1, p2);
 
// Get the edge in box
AMCAX::IndexSet<AMCAX::TopoShape> edges;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Edge, edges);
AMCAX::TopoShape e1 = edges[0];
AMCAX::TopoEdge edge = AMCAX::TopoCast::Edge(e1);
 
// Perform fillet on the edge
AMCAX::MakeFillet mf(box);
double radius = 1.;
mf.Add(radius, edge);// Add an edge with a radius to the fillet
mf.Build();
 
// Get the resulting shape
AMCAX::TopoShape box_fillet = mf.Shape();

Varying Radius

// Make a box
AMCAX::Point3 p1(-5.0, -5.0, 0.0);// diagonal corner points
AMCAX::Point3 p2(5.0, 5.0, 3.0);// diagonal corner points
AMCAX::TopoShape box = AMCAX::MakeBox(p1, p2);
 
// Get the edge in box
AMCAX::IndexSet<AMCAX::TopoShape> edges;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Edge, edges);
AMCAX::TopoShape e1 = edges[0];
AMCAX::TopoEdge edge = AMCAX::TopoCast::Edge(e1);
 
// Perform fillet on the edge
AMCAX::MakeFillet mf(box);
double r1 = 1.;// The start radius
double r2 = 3.;// The end radius
mf.Add(r1, r2, edge);// Add an edge with a linear varying radius
mf.Build();
 
// Get the resulting shape
AMCAX::TopoShape box_fillet = mf.Shape();

Planar Fillet

// Make a box
AMCAX::Point3 p1(-5.0, -5.0, 0.0);// diagonal corner points
AMCAX::Point3 p2(5.0, 5.0, 3.0);// diagonal corner points
AMCAX::TopoShape box = AMCAX::MakeBox(p1, p2);
 
// Get the face in box
AMCAX::IndexSet<AMCAX::TopoShape> faces;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Face, faces);
AMCAX::TopoShape f = faces[0];
AMCAX::TopoFace face = AMCAX::TopoCast::Face(f);
 
// Get the vertex in f1
AMCAX::IndexSet<AMCAX::TopoShape> vertexs;
AMCAX::TopoExplorerTool::MapShapes(face, AMCAX::ShapeType::Vertex, vertexs);
AMCAX::TopoShape v1 = vertexs[0];
AMCAX::TopoVertex vertex = AMCAX::TopoCast::Vertex(v1);
 
// Make fillet on a vertex of a planar face
AMCAX::MakeFillet2d mf2d(face);
double radius = 1.;
mf2d.AddFillet(vertex, radius);// Add a vertex for making fillet with a radius
mf2d.Build();
 
// Get the resulting shape
AMCAX::TopoShape box_fillet2d = mf2d.Shape();

Chamfer

Chamfering is an operation that replaces sharp vertices in a face with straight edges. AMCAX::MakeChamfer class can be used for chamfering geometric shapes.

// Make a box
AMCAX::Point3 p1(-5.0, -5.0, 0.0);// diagonal corner points
AMCAX::Point3 p2(5.0, 5.0, 3.0);// diagonal corner points
AMCAX::TopoShape box = AMCAX::MakeBox(p1, p2);
 
// Get the edge in box
AMCAX::IndexSet<AMCAX::TopoShape> edges;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Edge, edges);
AMCAX::TopoShape e1 = edges[0];
AMCAX::TopoEdge edge = AMCAX::TopoCast::Edge(e1);
 
// Perform chamfer on the edge
AMCAX::MakeChamfer mc(box);
double dis = 1.;// The distance parameter
mc.Add(dis, edge);// Add an edge used to build chamfers
mc.Build();
 
// Get the resulting shape
AMCAX::TopoShape box_chamfer = mc.Shape();

Shape Deformation

Shape Offset

MakeOffset

AMCAX::MakeOffset class is used to offset 2D Wires. If a Wire is input, it directly offsets it; if a Face is input, it offsets its boundary loop, finally returning the newly generated offset Wire.

// Make a box
AMCAX::Point3 p1(-5.0, -5.0, 0.0);// diagonal corner points
AMCAX::Point3 p2(5.0, 5.0, 3.0);// diagonal corner points
AMCAX::TopoShape box = AMCAX::MakeBox(p1, p2);
 
// Get the face in box
AMCAX::IndexSet<AMCAX::TopoShape> faces;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Face, faces);
AMCAX::TopoFace face = AMCAX::TopoCast::Face(faces[0]);
 
// Get the wire of the face
AMCAX::IndexSet<AMCAX::TopoShape> wires;
AMCAX::TopoExplorerTool::MapShapes(face, AMCAX::ShapeType::Wire, wires);
AMCAX::TopoWire wire = AMCAX::TopoCast::Wire(wires[0]);
 
// Method 1
// Compute the offset wire
double offset = 1.5;
AMCAX::JoinType join = AMCAX::JoinType::Arc;
bool isOpenResult = false;
AMCAX::MakeOffset moffset1(wire, join, isOpenResult);
moffset1.Perform(offset);
 
// Get the resulting shape
AMCAX::TopoShape offset_wire1 = moffset1.Shape();
 
// Method 2
// Compute the offset wire
AMCAX::MakeOffset moffset2(face, join, isOpenResult);
moffset2.Perform(offset);
AMCAX::TopoShape offset_wire2 = moffset2.Shape();

MakeOffsetShape

AMCAX::MakeOffsetShape class is used to offset 3D shapes, supporting input of Faces, Shells, Solids or Compounds composed of these three types. If a single Face is input, it directly offsets that face; if a Shell is input, it offsets the entire Solid it belongs to; if a Solid is input, it directly offsets that solid. If a Compound is input, it directly offsets that Compound.

Processing strategy:

• Gaps generated by offset can be handled by extension intersection or fillet connection
• Automatically removes self-intersecting parts generated during offset
• Supports modeling tracking through Modified and Generated

Input Face

Input Shell

// Make a box
AMCAX::Point3 p1(-5.0, -5.0, 0.0);// diagonal corner points
AMCAX::Point3 p2(5.0, 5.0, 3.0);// diagonal corner points
AMCAX::TopoShape box = AMCAX::MakeBox(p1, p2);
 
// Get the shell in box
AMCAX::IndexSet<AMCAX::TopoShape> shells;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Shell, shells);
AMCAX::TopoShape shell = shells[0];
 
// Get the face in box
AMCAX::IndexSet<AMCAX::TopoShape> faces;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Face, faces);
AMCAX::TopoFace face = AMCAX::TopoCast::Face(faces[0]);
 
// PerformBySimple
AMCAX::MakeOffsetShape moffset1;
double offsetvalue = 1.2;
moffset1.PerformBySimple(face, offsetvalue);
moffset1.Build();
// Get the resulting shape
AMCAX::TopoShape offsetshape1 = moffset1.Shape();
 
// PerformByJoin
AMCAX::MakeOffsetShape moffset2;
double tol = AMCAX::Precision::Confusion();
AMCAX::BRepOffsetMode mode = AMCAX::BRepOffsetMode::Skin;
AMCAX::JoinType join = AMCAX::JoinType::Arc;
bool removeIntEdges = false;
moffset2.PerformByJoin(shell, offsetvalue, tol, mode, false, false, join, removeIntEdges);
moffset2.Build();
// Get the resulting shape
AMCAX::TopoShape offsetshape2 = moffset2.Shape();

MakeOffsetWire

AMCAX::MakeOffsetWire class is used to offset wires on a plane. Compared with MakeOffset, MakeOffsetWire supports changes in topology; supports extension intersection transition or arc transition at unconnected places; supports tracking through Generated function.

// Make outerWire
std::vector<AMCAX::Point3> points1;
points1.push_back(AMCAX::Point3(-1.0, -1.0, 0.0));
points1.push_back(AMCAX::Point3(1.0, -1.0, 0.0));
points1.push_back(AMCAX::Point3(1.0, 1.0, 0.0));
points1.push_back(AMCAX::Point3(-1.0, 1.0, 0.0));
AMCAX::MakePolygon mp1;
for (const auto& p : points1)
{
    mp1.Add(p);
}
mp1.Close();
auto outerWire = mp1.Wire();
 
// Make innerWire
std::vector<AMCAX::Point3> points2;
points2.push_back(AMCAX::Point3(0.0, -0.5, 0.0));
points2.push_back(AMCAX::Point3(-0.5, 0.0, 0.0));
points2.push_back(AMCAX::Point3(0.0, 0.5, 0.0));
points2.push_back(AMCAX::Point3(0.5, 0.0, 0.0));
AMCAX::MakePolygon mp2;
for (const auto& p : points2)
{
    mp2.Add(p);
}
mp2.Close();
auto innerWire = mp2.Wire();
 
// Make a face
AMCAX::TopoBuilder builder;
AMCAX::TopoFace face;
auto surface = std::make_shared<AMCAX::Geom3Plane>();// xoy
builder.MakeFace(face, surface, AMCAX::Precision::Confusion());
builder.Add(face, innerWire);
builder.Add(face, outerWire);
 
// Make offset wire
double offset = 0.1;
{
    AMCAX::JoinType join = AMCAX::JoinType::Intersection;
    AMCAX::MakeOffsetWire moffset(face, innerWire, join, offset);
    auto result = moffset.Shape();
}
{
    AMCAX::JoinType join = AMCAX::JoinType::Intersection;
    AMCAX::MakeOffsetWire moffset(face, innerWire, join, -offset);
    auto result = moffset.Shape();
}
{
    AMCAX::JoinType join = AMCAX::JoinType::Arc;
    AMCAX::MakeOffsetWire moffset(face, innerWire, join, offset);
    auto result = moffset.Shape();
}
{
    AMCAX::JoinType join = AMCAX::JoinType::Arc;
    AMCAX::MakeOffsetWire moffset(face, innerWire, join, -offset);
    auto result = moffset.Shape();
}

Examples of topology changes: (Blue-black is input, blue is expected result, red is parts generated during construction that need to be deleted)

Shape Thickening

AMCAX::MakeThickSolid class provides shape thickening functionality.

Before thickening

After thickening

 // Make a box
 AMCAX::Point3 p1(-5.0, -5.0, 0.0);// diagonal corner points
 AMCAX::Point3 p2(5.0, 5.0, 3.0);// diagonal corner points
 AMCAX::TopoShape box = AMCAX::MakeBox(p1, p2);
 
 // Get the face in box
 AMCAX::IndexSet<AMCAX::TopoShape> faces;
 AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Face, faces);
 AMCAX::TopoShape face = AMCAX::TopoCast::Face(faces[0]);
 
// Make a thick solid
 double offsetvalue = 1.5;
 AMCAX::MakeThickSolid ts;
 ts.MakeThickBySimple(face, offsetvalue);
 ts.Build();
 
 // Get the resulting shape
 AMCAX::TopoShape thicksolid = ts.Shape();

Face Replacement

AMCAX::BoolBRepReplaceFace class provides face replacement functionality. That is, select a face in a solid and replace it with another surface. The basic logic is to extend the faces around the face to be replaced, intersect with the new surface and reconstruct the topology. However, if the surface cannot cover the face to be replaced, the replacement will fail.

Before replacement

After replacement

// Construct a cylinder
double radius = 5.;
double height = 10.;
AMCAX::TopoShape cylinder = AMCAX::MakeCylinder(radius, height);
 
// Get the face in box
AMCAX::IndexSet<AMCAX::TopoShape> faces;
AMCAX::TopoExplorerTool::MapShapes(cylinder, AMCAX::ShapeType::Face, faces);
AMCAX::TopoFace topface = AMCAX::TopoCast::Face(faces[1]);
 
// Replace the feature faces in solid with surface
AMCAX::Point3 point(0., 0., 12.);
AMCAX::Direction3 dir(0.2, 0.2, 1.0);
AMCAX::Plane plane(point, dir);
std::shared_ptr<AMCAX::Geom3Plane> surf = std::make_shared<AMCAX::Geom3Plane>(plane);
 
AMCAX::BoolBRepReplaceFace rf;
rf.SetShape(cylinder);
rf.AddFaceToReplace(topface);
rf.SetReplaceSurface(surf);
rf.Build();
if (rf.IsDone())
{   
    // Get the resulting shape
    AMCAX::TopoShape result = rf.Shape();
}

Some images are sourced from: https://dev.opencascade.org/doc/overview/html/index.html , the copyright belongs to its owner.