Solid modeling

Create Basic Shape

Basic shape include box, cylinder, cone/frustum, sphere, and torus.

Box

AMCAX::MakeBox class provides functionality to create a box.

AMCAX::TopoShape box = AMCAX::MakeBox(AMCAX::Point3(-5.0, -5.0, 0.0), AMCAX::Point3(5.0, 5.0, 3.0));

Cylinder

AMCAX::MakeCylinder class provides functionality to create a cylinder.

AMCAX::TopoShape cylinder = AMCAX::MakeCylinder(AMCAX::Frame3(AMCAX::Point3(0.0, 0.0, 0.0), AMCAX::Direction3(0.0, 0.0, 1.0)), 3.0, 5.0);

Cone/Frustum

AMCAX::MakeCone class provides functionality to create a cone or frustum.

AMCAX::TopoShape cone = AMCAX::MakeCone(4.0, 0.0, 4.0);

Sphere

AMCAX::MakeSphere class provides functionality to create a sphere.

AMCAX::TopoShape sphere = AMCAX::MakeSphere(AMCAX::Point3(-3.0, 0.0, 0.0), 1.0);

Torus

AMCAX::MakeTorus class provides functionality to create a torus.

AMCAX::TopoShape torus = AMCAX::MakeTorus(AMCAX::Frame3(AMCAX::Point3(0.0, 0.0, 2.0), AMCAX::Direction3(1.0, 0.0, 0.0)), 4.0, 2.0);

Boolean Operation

Boolean operation functionalities include union, intersection, cut, split, and section.

Union

AMCAX::BoolBRepFuse class provides the union functionality.

AMCAX::TopoShape shape1, shape2;
AMCAX::OCCTIO::OCCTTool::Read(shape1, "./data/part.brep");
AMCAX::OCCTIO::OCCTTool::Read(shape2, "./data/box.brep");
AMCAX::TopoShape fuse = AMCAX::BoolBRepFuse(shape1, shape2);

Intersection

AMCAX::BoolBRepCommon class provides the intersection functionality.

AMCAX::TopoShape shape1, shape2;
AMCAX::OCCTIO::OCCTTool::Read(shape1, "./data/part.brep");
AMCAX::OCCTIO::OCCTTool::Read(shape2, "./data/box.brep");
AMCAX::TopoShape common = AMCAX::BoolBRepCommon(shape1, shape2);

Cut

AMCAX::BoolBRepCut class provides the cut functionality.

AMCAX::TopoShape cone = AMCAX::MakeCone(4, 0, 4);
AMCAX::TopoShape sphere = AMCAX::MakeSphere(4.0);
AMCAX::TopoShape cut = AMCAX::BoolBRepCut(sphere, cone);

Split

AMCAX::BoolBRepSplitter class provides the split functionality.

AMCAX::TopoShape shape1, shape2;
AMCAX::OCCTIO::OCCTTool::Read(shape1, "./data/part.brep");
AMCAX::OCCTIO::OCCTTool::Read(shape2, "./data/box.brep");
AMCAX::BoolBRepSplitter splitter;
auto tool_shape = std::list{ shape1 };
auto tool_argument = std::list{ shape2 };
splitter.SetTools(tool_shape);
splitter.SetArguments(tool_argument);
AMCAX::TopoShape split = splitter.Shape();

Section

AMCAX::BoolBRepSection provides functionality to calculate the section line.

AMCAX::TopoShape cone = AMCAX::MakeCone(4, 0, 4);
AMCAX::TopoShape sphere = AMCAX::MakeSphere(4.0);
AMCAX::TopoShape section = AMCAX::BoolBRepSection(cone, sphere);

Extrude (Sweep) Creation Functionality

AMCAX::MakePrism provides the extrude (sweep) functionality.

AMCAX::MakeGeom3Ellipse makeEllipse(AMCAX::Frame3(), 3.0, 1.0);
std::shared_ptr<AMCAX::Geom3Curve> curve = makeEllipse.Value();
AMCAX::TopoEdge e = AMCAX::MakeEdge(curve);
AMCAX::TopoWire w = AMCAX::MakeWire(e);
AMCAX::TopoFace f = AMCAX::MakeFace(w);
AMCAX::TopoShape s = AMCAX::MakePrism(f, AMCAX::Vector3(0.0, 0.0, 1.0));

Rotation (Sweep) Creation Functionality

AMCAX::MakeRevol class provides the rotation (sweep) functionality.

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 bz = std::make_shared<AMCAX::Geom3BezierCurve>(poles);
AMCAX::TopoEdge e = AMCAX::MakeEdge(bz);
AMCAX::TopoShape revolshape = AMCAX::MakeRevol(e, AMCAX::CartesianCoordinateSystem::OZ());

Pipe Functionality

The pipe is created by specifying the spine (wire) and profile (shape). This can be done using AMCAX::MakePipe or AMCAX::MakePipeShell. MakePipe is for simpler pipe algorithms, suitable for a single section (planar shape) and a smooth path. MakePipeShell is a more complete pipe algorithm, supporting multiple sections and non-smooth paths, but the path must intersect with the section plane. Note that Add can only be TopoWire or TopoVertex.

double radius = 0.1;  
AMCAX::Frame3 aFrame(AMCAX::Point3(0., 0., 0.), AMCAX::Direction3(-8.57143, 0., 4.));
AMCAX::Circle3 aCircle = AMCAX::Circle3(aFrame, radius);
AMCAX::TopoEdge aEdge = AMCAX::MakeEdge(aCircle);
AMCAX::TopoWire aWire = AMCAX::MakeWire(aEdge);
AMCAX::TopoFace aFace = AMCAX::MakeFace(aWire);
 
std::vector<AMCAX::Point3> pointSet;
pointSet.push_back(AMCAX::Point3(0., 0., 0.));
pointSet.push_back(AMCAX::Point3(-1., 0., 1.));
pointSet.push_back(AMCAX::Point3(0., 0., 2.));
pointSet.push_back(AMCAX::Point3(1., 0., 3.));
pointSet.push_back(AMCAX::Point3(0., 0., 4.));
std::shared_ptr<AMCAX::Geom3BSplineCurve> aBSplineCurve = AMCAX::NURBSAPIInterpolate::InterpolatePoints(pointSet,
    2, false, AMCAX::ApproxParameterizationType::Centripetal);
AMCAX::TopoEdge aSpineEdge = AMCAX::MakeEdge(aBSplineCurve);
AMCAX::TopoWire aSpineWire = AMCAX::MakeWire(aSpineEdge);
AMCAX::TopoShape aPipe = AMCAX::MakePipe(aSpineWire, aFace);
 
//MakePipeShell
AMCAX::MakePipeShell ps(aSpineWire);
ps.Add(aWire,false,false);
ps.Build();

Loft Operation

AMCAX::MakeLoft class provides loft functionality. By adding multiple wires, a shell or solid can be lofted.

AMCAX::Point3 aPoint1(1.0, 0.0, 0.0);
AMCAX::Point3 aPoint2(-0.5, std::sqrt(3.0) * 0.5, 0.0);
AMCAX::Point3 aPoint3(-0.5, -std::sqrt(3.0) * 0.5, 0.0);
AMCAX::MakePolygon aPolygon(aPoint1, aPoint2, aPoint3, true);
AMCAX::TopoWire bottomWire = aPolygon.Wire();
 
AMCAX::Transformation3 aTransform;
aTransform.SetRotation(AMCAX::CartesianCoordinateSystem::OZ(), -M_PI / 6.0);
aTransform.SetTranslationPart(AMCAX::Vector3(0.0, 0.0, 3.0));
AMCAX::TopoWire topWire = AMCAX::TopoCast::Wire(AMCAX::TransformShape(bottomWire, aTransform));
 
AMCAX::MakeLoft aMakeLoft(true, true);
aMakeLoft.AddWire(bottomWire);
aMakeLoft.AddWire(topWire);
aMakeLoft.Build();
AMCAX::TopoShape loft = aMakeLoft.Shape();

Fillet and Chamfer Features (Support Variable Radius)

Fillet

Fillet replaces sharp edges with smooth surfaces. The AMCAX::MakeFillet class and the AMCAX::MakeFillet2d class provide fillet functionality.

MakeFillet

AMCAX::TopoShape box = AMCAX::MakeBox(AMCAX::Point3(-5.0, -5.0, -5.0), AMCAX::Point3(5.0, 5.0, 5.0));
AMCAX::MakeFillet mf(box);
 
AMCAX::IndexSet<AMCAX::TopoShape> edges;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Edge, edges);
AMCAX::TopoShape e1 = edges[0];
mf.Add(1.0, AMCAX::TopoCast::Edge(e1));
mf.Build();
AMCAX::TopoShape box_fillet = mf.Shape();

MakeFillet2d

AMCAX::TopoShape box = AMCAX::MakeBox(AMCAX::Point3(-5.0, -5.0, -5.0), AMCAX::Point3(5.0, 5.0, 5.0));
AMCAX::IndexSet<AMCAX::TopoShape> faces;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Face, faces);
AMCAX::TopoShape f = faces[0];
AMCAX::TopoFace f1 = AMCAX::TopoCast::Face(f);
AMCAX::MakeFillet2d mf2d(AMCAX::TopoCast::Face(f1));
 
AMCAX::IndexSet<AMCAX::TopoShape> vertex;
AMCAX::TopoExplorerTool::MapShapes(f1, AMCAX::ShapeType::Vertex, vertex);
AMCAX::TopoShape v1 = vertex[0];
mf2d.AddFillet(AMCAX::TopoCast::Vertex(v1), 1.0);
mf2d.Build();
AMCAX::TopoShape box_fillet2d = mf2d.Shape();

Chamfer

AMCAX::MakeChamfer class provides the chamfer functionality.

AMCAX::TopoShape box = AMCAX::MakeBox(AMCAX::Point3(-5.0, -5.0, -5.0), AMCAX::Point3(5.0, 5.0, 5.0));
AMCAX::IndexSet<AMCAX::TopoShape> edges;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Edge, edges);
AMCAX::TopoShape e1 = edges[0];
AMCAX::MakeChamfer mc(box);
mc.Add(1.0, AMCAX::TopoCast::Edge(e1));
mc.Build(); 
AMCAX::TopoShape box_chamfer = mc.Shape();

Shape Offset Function

The AMCAX::MakeOffset class and AMCAX::MakeOffsetShape class provide the functionality for shape offset.

MakeOffset (Offset for 2D Shapes)

The input is a wire for offset, and for a face, the boundary of the face is offset, returning the wire after offset.

AMCAX::TopoShape box = AMCAX::MakeBox(AMCAX::Point3(-5.0, -5.0, -5.0), AMCAX::Point3(5.0, 5.0, 5.0));
AMCAX::IndexSet<AMCAX::TopoShape> faces;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Face, faces);
AMCAX::TopoShape f = faces[0];
AMCAX::IndexSet<AMCAX::TopoShape> wire;
AMCAX::TopoExplorerTool::MapShapes(f, AMCAX::ShapeType::Wire, wire);
AMCAX::TopoWire w = AMCAX::TopoCast::Wire(wire[0]);
 
//wire
double offset = 1.5;
AMCAX::JoinType theJoin = AMCAX::JoinType::Arc;
bool isOpenResult = false;
AMCAX::MakeOffset MakeOffset(w, theJoin, isOpenResult);
MakeOffset.Perform(offset);
AMCAX::TopoShape offset1 = MakeOffset.Shape();
 
//face
AMCAX::TopoFace f1 = AMCAX::TopoCast::Face(f);
AMCAX::OCCTIO::OCCTTool::Write(f1, "face.brep");
AMCAX::MakeOffset MakeOffset2(f1, theJoin, isOpenResult);
MakeOffset2.Perform(offset);
AMCAX::TopoShape offset2 = MakeOffset2.Shape();

MakeOffsetShape (Offset for 3D Shapes)

Input face for offset, input shell for offset the entire solid, returning the offset face or solid.

AMCAX::TopoShape box = AMCAX::MakeBox(AMCAX::Point3(-5.0, -5.0, -5.0), AMCAX::Point3(5.0, 5.0, 5.0));
AMCAX::IndexSet<AMCAX::TopoShape> faces;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Face, faces);
AMCAX::TopoShape f = faces[0];
 
//face
AMCAX::MakeOffsetShape MakeOffsetShape;
double offsetvalue = 1.2;
MakeOffsetShape.PerformBySimple(f, offsetvalue);
MakeOffsetShape.Build();
AMCAX::TopoShape offsetshape1 = MakeOffsetShape.Shape();
AMCAX::OCCTIO::OCCTTool::Write(offsetshape1, "MakeOffsetShape-face.brep");
 
//shell
AMCAX::MakeOffsetShape MakeOffsetShape2;
AMCAX::IndexSet<AMCAX::TopoShape> shell;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Shell, shell);
AMCAX::TopoShape s = shell[0];
MakeOffsetShape2.PerformBySimple(s, offsetvalue);
MakeOffsetShape2.Build();
AMCAX::TopoShape offsetshape2 = MakeOffsetShape2.Shape();

Shape Thicken

AMCAX::MakeThickSolid class provides the functionality to thicken shape.

AMCAX::TopoShape box = AMCAX::MakeBox(AMCAX::Point3(-5.0, -5.0, -5.0), AMCAX::Point3(5.0, 5.0, 5.0));
AMCAX::IndexSet<AMCAX::TopoShape> faces;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Face, faces);
AMCAX::TopoShape f = faces[0];
 
double offsetvalue=1.5;
AMCAX::MakeThickSolid ts;
ts.MakeThickBySimple(f,offsetvalue);
ts.Build();
AMCAX::TopoShape thicksolid = ts.Shape();

Replace Face

The AMCAX::BoolBRepReplaceFace class provides the functionality to replace a face. This allows you to select a face from a solid and replace it with another surface. The basic logic involves extending the surrounding faces of the replaced face, intersecting them with the new surface, and reconstructing the topology. If the surface cannot cover the replaced face, the replacement will fail.

AMCAX::TopoShape cylinder= AMCAX::MakeCylinder(5, 10);
AMCAX::IndexSet<AMCAX::TopoShape> shapeFaces;
AMCAX::TopoExplorerTool::MapShapes(cylinder, AMCAX::ShapeType::Face, shapeFaces);
AMCAX::TopoFace upface = static_cast<const AMCAX::TopoFace&>(shapeFaces[1]); 
 
AMCAX::Plane plane(AMCAX::Point3(0., 0., 12.), AMCAX::Direction3(0.2, 0.2, 1.0));
std::shared_ptr<AMCAX::Geom3Plane> surf = std::make_shared<AMCAX::Geom3Plane>(plane);
 
AMCAX::BoolBRepReplaceFace rf;
rf.SetShape(cylinder);
rf.AddFaceToReplace(upface);
rf.SetReplaceSurface(surf);
rf.Build();
if (rf.IsDone())
{
    AMCAX::TopoShape result = rf.Shape();
    AMCAX::OCCTIO::OCCTTool::Write(result, "BoolBRepReplaceFace.brep");
}

Thin Plate Spline Interpolation of Curves

When interpolating, it is apparent that the curve passing through these points is not unique.

Generally speaking, the blue curve is more in line with the CAD design intent than the green one. To ensure the curve has a manageable length and the curvature changes smoothly, we use the thin-plate energy to measure the quality of the curve:

E1 controls the length of the curve, and E2 controls the rate of change of the curve. The larger the alpha, the shorter the curve. The larger the beta, the smoother the curve's shape. The AMCAX::NURBSAPIInterpolate class provides functionality for thin-plate spline interpolation. Details are as follows:
AMCAX::NURBSAPIInterpolate::InterpolatePointsThinPlate：Takes input data point coordinates, corresponding curve parameters (optional), and some information about the interpolation curve (periodicity, thin-plate energy weight), and constructs a NURBS curve passing through each data point while minimizing the thin-plate energy.
AMCAX::NURBSAPIInterpolate::InterpolateNodesThinPlate：Takes input data point coordinates, gradient orders (optional), corresponding curve parameters (optional), and some information about the interpolation curve (periodicity, thin-plate energy weight), and constructs a NURBS curve passing through each data point while minimizing the thin-plate energy.

AMCAX::LawConstant law;
std::vector<AMCAX::Point3> points;
points.push_back(AMCAX::Point3(0.0, 0.0, 0.0));
points.push_back(AMCAX::Point3(-0.1, 1.0, -0.2));
points.push_back(AMCAX::Point3(0.1, 2.0, -0.1));
points.push_back(AMCAX::Point3(0.2, 3.0, 0.1));
points.push_back(AMCAX::Point3(0.1, 4.0, 0.0));
points.push_back(AMCAX::Point3(0.0, 5.0, -0.1));
 
AMCAX::ApproxParameterizationType ptype = AMCAX::ApproxParameterizationType::ChordLength;
bool isClosed = false;
double alpha = 1e-2;
double beta = 1e-2;
std::vector< double > parameterization = { 0.0,0.1,0.2,0.3,0.4,0.5 };
std::vector<AMCAX::InterpolationNode> nodes;
AMCAX::Point3 p1(0., 0., 0.);
AMCAX::Point3 p2(1., 1., 1.);
AMCAX::Vector3 v1(2.,0.,0.), v2;
nodes.push_back({ p1,true,v1,false,v2 });
nodes.push_back({ p2,true,v1,false,v2 });
std::vector<double> parameterization1{ 0.0,0.5 };
 
auto thinplate1 = AMCAX::NURBSAPIInterpolate::InterpolatePointsThinPlate(points, isClosed, ptype, alpha, beta);
auto thinplate2 = AMCAX::NURBSAPIInterpolate::InterpolatePointsThinPlate(points, parameterization, isClosed, alpha, beta);
auto thinplate3 = AMCAX::NURBSAPIInterpolate::InterpolateNodesThinPlate(nodes, isClosed, ptype,alpha, beta);
auto thinplate4 = AMCAX::NURBSAPIInterpolate::InterpolateNodesThinPlate(nodes, parameterization1, isClosed, alpha, beta);
 
AMCAX::OCCTIO::OCCTTool::Write(AMCAX::MakeEdge(thinplate1), "InterpolatePointsThinPlate1.brep");
AMCAX::OCCTIO::OCCTTool::Write(AMCAX::MakeEdge(thinplate2), "InterpolatePointsThinPlate2.brep");
AMCAX::OCCTIO::OCCTTool::Write(AMCAX::MakeEdge(thinplate3), "InterpolatePointsThinPlate3.brep");
AMCAX::OCCTIO::OCCTTool::Write(AMCAX::MakeEdge(thinplate4), "InterpolatePointsThinPlate4.brep");

Convert Law Curve to 3D Geometric Curve

Using AMCAX::LawFunction::ToCurve() to convert a law curve to a 3D geometric curve.
For example, using a constant value function, r corresponds to the value of y, and pf and pl are the start and end parameters of x.

AMCAX::LawConstant law;
double r = 5.0;
double pr = 1.0;
double pl = 10.0;
law.Set(r, pr, pl);
auto e1 = law.ToCurve();
AMCAX::TopoShape edge = AMCAX::MakeEdge(e1);

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