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");
//Fuse
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");
//Common
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);
//Cut
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");
//Splitter
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

The AMCAX::BoolBRepSection class provides functionality to compute intersection curves, with the results stored as a TopoCompound.

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

Calling the interface directly as shown above will ​not​ compute the parametric curves within the shapes. To compute parametric curves, you must first initialize the operation and then compute the intersection.

AMCAX::TopoShape cone = AMCAX::MakeCone(4, 0, 4);
AMCAX::TopoShape sphere = AMCAX::MakeSphere(4.0);
 
AMCAX::BoolBRepSection section;
section.Init1(cone);
section.ComputePCurveOn1(true);
section.Init2(sphere);
section.ComputePCurveOn2(true);
section.Build();
AMCAX::TopoShape result = section.Shape();

​# ​Sweep Operation​

Extrude

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);
//Make an extrusion shape
AMCAX::TopoShape s = AMCAX::MakePrism(f, AMCAX::Vector3(0.0, 0.0, 1.0));

Rotation

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);
//Make a revolved shape
AMCAX::TopoShape revolshape = AMCAX::MakeRevol(e, AMCAX::CartesianCoordinateSystem::OZ());

Pipe

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.

//Makepipe
//Make a face
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);
//Make a curve
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);
//Make a wire
AMCAX::TopoEdge aSpineEdge = AMCAX::MakeEdge(aBSplineCurve);
AMCAX::TopoWire aSpineWire = AMCAX::MakeWire(aSpineEdge);
//Make a pipe
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.

//Make a polygon
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);
//Get the polygon wire
AMCAX::TopoWire bottomWire = aPolygon.Wire();
//Get the top wire 
AMCAX::Transformation3 aTransform;
aTransform.SetRotation(AMCAX::CartesianCoordinateSystem::OZ(), -AMCAX::Constants::pi / 6.0);
aTransform.SetTranslationPart(AMCAX::Vector3(0.0, 0.0, 3.0));
AMCAX::TopoWire topWire = AMCAX::TopoCast::Wire(AMCAX::TransformShape(bottomWire, aTransform));
//Make a lofting shape
AMCAX::MakeLoft aMakeLoft(true, true);
aMakeLoft.AddWire(bottomWire);
aMakeLoft.AddWire(topWire);
aMakeLoft.Build();
AMCAX::TopoShape loft = aMakeLoft.Shape();

Edge Processing

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));
//Get the edge in box
AMCAX::IndexSet<AMCAX::TopoShape> edges;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Edge, edges);
AMCAX::TopoShape e1 = edges[0];
//Make fillet
AMCAX::MakeFillet mf(box);
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));
//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 f1 = AMCAX::TopoCast::Face(f);
//Get the vertex in f1
AMCAX::IndexSet<AMCAX::TopoShape> vertex;
AMCAX::TopoExplorerTool::MapShapes(f1, AMCAX::ShapeType::Vertex, vertex);
AMCAX::TopoShape v1 = vertex[0];
//Make fillet2d
AMCAX::MakeFillet2d mf2d(AMCAX::TopoCast::Face(f1));
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));
//Get the edge in box
AMCAX::IndexSet<AMCAX::TopoShape> edges;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Edge, edges);
AMCAX::TopoShape e1 = edges[0];
//Perform chamfer on a given shape
AMCAX::MakeChamfer mc(box);
mc.Add(1.0, AMCAX::TopoCast::Edge(e1));
mc.Build();
AMCAX::TopoShape box_chamfer = mc.Shape();

Shape Deformation​​

Shape Offset

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));
//Get the face in box
AMCAX::IndexSet<AMCAX::TopoShape> faces;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Face, faces);
AMCAX::TopoShape f = faces[0];
//Get the wire of the f
AMCAX::IndexSet<AMCAX::TopoShape> wire;
AMCAX::TopoExplorerTool::MapShapes(f, AMCAX::ShapeType::Wire, wire);
AMCAX::TopoWire w = AMCAX::TopoCast::Wire(wire[0]);
 
//Make offset 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();
 
//Make offset face
AMCAX::TopoFace f1 = AMCAX::TopoCast::Face(f);
AMCAX::MakeOffset MakeOffset2(f1, theJoin, isOpenResult);
MakeOffset2.Perform(offset);
AMCAX::TopoShape offset2 = MakeOffset2.Shape();

MakeOffsetShape (Offset for 3D Shapes)

Offset the input face. If the input is a shell, offset the entire solid of it. Finally, return the offset face or solid. For the gaps caused by offsetting, you can choose to use extension to find intersections or fillets for connection. The self - intersecting parts caused by offsetting will be deleted. Additionally, modeling tracking can be performed through Modified and Generated.

AMCAX::TopoShape box = AMCAX::MakeBox(AMCAX::Point3(-5.0, -5.0, -5.0), AMCAX::Point3(5.0, 5.0, 5.0));
//Get the face in box
AMCAX::IndexSet<AMCAX::TopoShape> faces;
AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Face, faces);
AMCAX::TopoShape f = faces[0];
 
//Make offset 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");
 
//Make offset face
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();

MakeOffsetWire

This function also offsets a wire in a plane but supports topological changes. It allows for extending and intersecting at disconnected areas or creating arc transitions. It also supports tracking through the Generated function.

//Make a 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();
const auto& outerWire = mp1.Wire();
//Make a 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();
const auto& innerWire = mp2.Wire();
//Make a face
AMCAX::TopoBuilder b;
AMCAX::TopoFace f;
auto surf = std::make_shared<AMCAX::Geom3Plane>();
b.MakeFace(f, surf, AMCAX::Precision::Confusion());
b.Add(f, innerWire);
b.Add(f, outerWire);
//Make offset wire
double offset = 0.1;
{
    AMCAX::JoinType join = AMCAX::JoinType::Intersection;
    AMCAX::MakeOffsetWire mow(f, innerWire, join, offset);
    const auto& result = mow.Shape();
}
{
    AMCAX::JoinType join = AMCAX::JoinType::Intersection;
    AMCAX::MakeOffsetWire mow(f, innerWire, join, -offset);
    const auto& result = mow.Shape();
}
{
    AMCAX::JoinType join = AMCAX::JoinType::Arc;
    AMCAX::MakeOffsetWire mow(f, innerWire, join, offset);
    const auto& result = mow.Shape();
}
{
    AMCAX::JoinType join = AMCAX::JoinType::Arc;
    AMCAX::MakeOffsetWire mow(f, innerWire, join, -offset);
    const auto& result = mow.Shape();
}

Example of topological structure changes:​​ (Blue-black lines represent input geometry, Blue lines indicate the desired final result, Red lines show intermediate construction elements that require removal)

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));
 //Get the face in box
 AMCAX::IndexSet<AMCAX::TopoShape> faces;
 AMCAX::TopoExplorerTool::MapShapes(box, AMCAX::ShapeType::Face, faces);
 AMCAX::TopoShape f = faces[0];
//Make a thick solid
 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);
//Get the face in box
AMCAX::IndexSet<AMCAX::TopoShape> shapeFaces;
AMCAX::TopoExplorerTool::MapShapes(cylinder, AMCAX::ShapeType::Face, shapeFaces);
AMCAX::TopoFace upface = AMCAX::TopoCast::Face(shapeFaces[1]);
// Replace the feature faces in solid with surface
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();
}

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