T Mesh Spline Modeling

Basic Body Construction

Basic bodies include planar rectangles, cubes, cylindrical bodies, conical bodies, frustums, spheres, tori, etc.

Planar Rectangle

The AMCAX::TMS::TMSplineMakeRectangle class is used to construct a planar rectangle.

AMCAX::Frame3 frame;
double dx = 3.; // The size in x direction
double dy = 3.; // The size in y direction
size_t useg = 3; // The number of segments in x direction
size_t vseg = 3; // The number of segments in y direction
 
// Construct a rectangle
AMCAX::TMS::TMSplineMakeRectangle mkRect(frame, dx, dy, useg, vseg);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkRect.BuildSpline();

Cube

The AMCAX::TMS::TMSplineMakeCube class is used to construct a cube.

AMCAX::Point3 Pmin(0., 0., 0.); // The min corner point
AMCAX::Point3 Pmax(12., 12., 12.); // The max corner point
size_t segX = 3; // The number of segments in x direction
size_t segY = 3; // The number of segments in y direction
size_t segZ = 3; // The number of segments in z direction
 
// Construct a cube
AMCAX::TMS::TMSplineMakeCube mkCube(Pmin, Pmax, segX, segY, segZ);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();

Cylinder

The AMCAX::TMS::TMSplineMakeCylinder class is used to construct a cylindrical body.

AMCAX::Frame3 frame;
double radius = 1.;
double height = 4.;
size_t rseg = 8; // The number of segments in rotation
size_t vseg = 4; // The number of segments in vertical
bool isTop = true;
bool isBottom = true;
 
// Construct a cylinder
AMCAX::TMS::TMSplineMakeCylinder mkCylinder(frame, radius, height, isTop, isBottom, rseg, vseg);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkCylinder.BuildSpline();

Cone

The AMCAX::TMS::TMSplineMakeCone class is used to construct a conical body.

double radius = 1.;
double height = 2.;
bool isBottom = true;
size_t rseg = 8; // The number of segments in rotation
size_t vseg = 4; // The number of segments in vertical
 
// Construct a cone
AMCAX::TMS::TMSplineMakeCone mkCone(radius, height, isBottom, rseg, vseg);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkCone.BuildSpline();

Frustum

The AMCAX::TMS::TMSplineMakeCone class is used to construct a frustum.

AMCAX::Frame3 frame;
double radius1 = 2.;// The bottom radius
double radius2 = 1.;// The top radius
double height = 2.;
bool isTop = true;
bool isBottom = true;
size_t rseg = 8;// The number of segments in rotation
size_t vseg = 4;// The number of segments in vertical
 
// Construct a cone frustum
AMCAX::TMS::TMSplineMakeCone mkCone(frame, radius1, radius2, height, isTop, isBottom, rseg, vseg);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkCone.BuildSpline();

Sphere

The AMCAX::TMS::TMSplineMakeSphere class is used to construct a sphere.

double radius = 10.;
size_t rseg = 8; // The number of segments in rotation
size_t vseg = 8; // The number of segments in vertical
 
// Construct a sphere
AMCAX::TMS::TMSplineMakeSphere mkSphere(radius, rseg, vseg);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkSphere.BuildSpline();

Torus

The AMCAX::TMS::TMSplineMakeTorus class is used to construct a torus.

double majorRadius = 20.;
double minorRadius = 10.;
size_t majorSeg = 8; // The number of segments in major rotation
size_t minorSeg = 16; // The number of segments in minor rotation
 
// Construct a torus
AMCAX::TMS::TMSplineMakeTorus mkTorus(majorRadius, minorRadius, majorSeg, minorSeg);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkTorus.BuildSpline();

Basic Editing Functions

Basic editing functions include traversal, adding faces, refinement, deletion, separation, welding, etc.

Traversal

The AMCAX::TMS::TMSplineTool class provides traversal functions, as follows:

Get all vertex indices of a specified face in TMSpline

AMCAX::Point3 Pmin(0., 0., 0.); // The min corner point
AMCAX::Point3 Pmax(12., 12., 12.); // The max corner point
size_t segX = 3; // The number of segments in x direction
size_t segY = 3; // The number of segments in y direction
size_t segZ = 3; // The number of segments in z direction
 
// Construct a cube
AMCAX::TMS::TMSplineMakeCube mkCube(Pmin, Pmax, segX, segY, segZ);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
 
// Get the vertices of the face in TMSpline
int face = 0; // The index of face
std::vector<int> index_v = AMCAX::TMS::TMSplineTool::FaceVertexIndexs(tsp, face);

Get vertex indices of a specified edge in TMSpline

AMCAX::Point3 Pmin(0., 0., 0.); // The min corner point
AMCAX::Point3 Pmax(12., 12., 12.); // The max corner point
size_t segX = 3; // The number of segments in x direction
size_t segY = 3; // The number of segments in y direction
size_t segZ = 3; // The number of segments in z direction
 
// Construct a cube
AMCAX::TMS::TMSplineMakeCube mkCube(Pmin, Pmax, segX, segY, segZ);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
 
// Get the vertices of the edge in TMSpline
int edge = 0; // The index of edge
int vfirst, vlast;
AMCAX::TMS::TMSplineTool::EdgeVertexIndexs(tsp, edge, vfirst, vlast);

Get all edge indices of a specified face in TMSpline

AMCAX::Point3 Pmin(0., 0., 0.); // The min corner point
AMCAX::Point3 Pmax(12., 12., 12.); // The max corner point
size_t segX = 3; // The number of segments in x direction
size_t segY = 3; // The number of segments in y direction
size_t segZ = 3; // The number of segments in z direction
 
// Construct a cube
AMCAX::TMS::TMSplineMakeCube mkCube(Pmin, Pmax, segX, segY, segZ);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
 
// Get the edge of the face in TMSpline
int face = 0; // The index of face
std::vector<int> index_e = AMCAX::TMS::TMSplineTool::FaceEdgeIndexs(tsp, face);

Get indices of faces adjacent to a specified edge in TMSpline

AMCAX::Point3 Pmin(0., 0., 0.); // The min corner point
AMCAX::Point3 Pmax(12., 12., 12.); // The max corner point
size_t segX = 3; // The number of segments in x direction
size_t segY = 3; // The number of segments in y direction
size_t segZ = 3; // The number of segments in z direction
 
// Construct a cube
AMCAX::TMS::TMSplineMakeCube mkCube(Pmin, Pmax, segX, segY, segZ);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
 
// Get the faces adjacent to edge in TMSpline
int edge = 0; // The index of edge
std::vector<int> index_f = AMCAX::TMS::TMSplineTool::EdgeFaceIndexs(tsp, edge);

Adding Faces

The AMCAX::TMS::TMSplineAddFace class provides the function for adding faces.

Add a single face composed of a set of points to TMSpline

AMCAX::Frame3 frame;
double dx = 10.; // The size in x direction
double dy = 10.; // The size in y direction
size_t useg = 2; // The number of segments in x direction
size_t vseg = 2; // The number of segments in y direction
 
// Construct a rectangle
AMCAX::TMS::TMSplineMakeRectangle mkRect(frame, dx, dy, useg, vseg);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkRect.BuildSpline();
 
// Add a single face to a TMSpline
AMCAX::Point3 p1(12., 15., 15.);
AMCAX::Point3 p2(16., 13., 11.);
AMCAX::Point3 p3(20., 18., 13.);
std::vector<AMCAX::Point3> vlist = { p1, p2, p3 }; // The points for constructing face
AMCAX::TMS::TMSplineAddFace addface;
if (addface.CanAddSingleFace(tsp, vlist))
{
    addface.AddSingleFace(tsp, vlist);
}
else
    std::cout << "error" << std::endl;

Add a single face composed of two edges to TMSpline

AMCAX::Frame3 frame;
double dx = 10.; // The size in x direction
double dy = 10.; // The size in y direction
size_t useg = 2; // The number of segments in x direction
size_t vseg = 2; // The number of segments in y direction
 
// Construct a rectangle
AMCAX::TMS::TMSplineMakeRectangle mkRect(frame, dx, dy, useg, vseg);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkRect.BuildSpline();
 
// Add a single face to a TMSpline
int e1index = 0; // The first edge
int e2index = 3; // The second edge
AMCAX::TMS::TMSplineAddFace addface;
if (addface.CanAddFaceByEdge(tsp, e1index, e2index))
{
    addface.AddFaceByEdge(tsp, e1index, e2index);
}
else
    std::cout << "error" << std::endl;

Split

The AMCAX::TMS::TMSplineSplit class provides refinement functions, as follows:

Split a toroidal face

AMCAX::Point2 p0(1., 1.); // The min corner point
AMCAX::Point2 p1(10., 10.); // The max corner point
size_t useg = 3; // The number of segments in x direction
size_t vseg = 3; // The number of segments in y direction
 
// Construct a rectangle
AMCAX::TMS::TMSplineMakeRectangle mkRect(p0, p1, useg, vseg);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkRect.BuildSpline();
 
// Split a loop faces generated from edge
size_t eid = 4;
double t = 0.5;
AMCAX::TMS::TMSplineSplit split;
if (split.CanSplitFaceLoop(tsp, eid, t))
{
    split.SplitFaceLoop(tsp, eid, t);
}
else
    std::cout << "error" << std::endl;

1-4 split method to split faces

AMCAX::Point2 p0(1., 1.); // The min corner point
AMCAX::Point2 p1(10., 10.); // The max corner point
size_t useg = 3; // The number of segments in x direction
size_t vseg = 3; // The number of segments in y direction
 
// Construct a rectangle
AMCAX::TMS::TMSplineMakeRectangle mkRect(p0, p1, useg, vseg);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkRect.BuildSpline();
 
// Split faces by 1-4 split method
std::vector<int> flist = { 3, 8 }; // The faces that need to be split
AMCAX::TMS::TMSplineSplit split;
if (split.CanSplitFacesCross(tsp, flist))
{
    split.SplitFacesCross(tsp, flist);
}
else
    std::cout << "error" << std::endl;

Split face along an edge

AMCAX::Point2 p0(1., 1.); // The min corner point
AMCAX::Point2 p1(10., 10.); // The max corner point
size_t useg = 3; // The number of segments in x direction
size_t vseg = 3; // The number of segments in y direction
 
// Construct a rectangle
AMCAX::TMS::TMSplineMakeRectangle mkRect(p0, p1, useg, vseg);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkRect.BuildSpline();
 
// Split faces by sequentially crossing the point of the edges in TMSpline
std::vector<int> elist = { 0 }; // The edges that need to be sequentially crossed
std::vector<AMCAX::Point3> newControl = { AMCAX::Point3(2.0, 1.0, 0.0) };
 
AMCAX::TMS::TMSplineSplit split;
if (split.CanSplitFaceWithEdge(tsp, elist, newControl))
{
    split.SplitFaceWithEdge(tsp, elist, newControl);
}
else
    std::cout << "error" << std::endl;

Split face along vertices

AMCAX::Point2 p0(1., 1.); // The min corner point
AMCAX::Point2 p1(10., 10.); // The max corner point
size_t useg = 3; // The number of segments in x direction
size_t vseg = 3; // The number of segments in y direction
 
// Construct a rectangle
AMCAX::TMS::TMSplineMakeRectangle mkRect(p0, p1, useg, vseg);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkRect.BuildSpline();
 
// Split faces by sequentially crossing vertices in TMSpline
std::vector<int> vlist = { 5, 10 }; // The vertices that need to be sequentially crossed
AMCAX::TMS::TMSplineSplit split;
if (split.CanSplitFaceWithVertex(tsp, vlist))
{
    split.SplitFaceWithVertex(tsp, vlist);
}
else
    std::cout << "error" << std::endl;

Deletion

The AMCAX::TMS::TMSplineReduce class provides deletion functions, as follows:

Remove vertices from TMSpline

AMCAX::Point3 Pmin(0., 0., 0.); // The min corner point
AMCAX::Point3 Pmax(12., 12., 12.); // The max corner point
size_t segX = 2; // The number of segments in x direction
size_t segY = 2; // The number of segments in y direction
size_t segZ = 2; // The number of segments in z direction
 
// Construct a cube
AMCAX::TMS::TMSplineMakeCube mkCube(Pmin, Pmax, segX, segY, segZ);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
 
// Remove vertices in a TMSpline
AMCAX::TMS::TMSplineReduce reduce;
std::vector<int> vlist = { 0, 1 }; // The vertices that need to be removed
if (reduce.CanRemoveVertices(tsp, vlist))
{
    reduce.RemoveVertices(tsp, vlist);
}
else
    std::cout << "error" << std::endl;

Remove edges from TMSpline

AMCAX::Point3 Pmin(0., 0., 0.); // The min corner point
AMCAX::Point3 Pmax(12., 12., 12.); // The max corner point
size_t segX = 2; // The number of segments in x direction
size_t segY = 2; // The number of segments in y direction
size_t segZ = 2; // The number of segments in z direction
 
// Construct a cube
AMCAX::TMS::TMSplineMakeCube mkCube(Pmin, Pmax, segX, segY, segZ);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
 
// Remove edges in a TMSpline
AMCAX::TMS::TMSplineReduce reduce;
const std::vector<int> elist = { 10, 15 }; // The edges that need to be removed
if (reduce.CanRemoveEdges(tsp, elist))
{
    reduce.RemoveEdges(tsp, elist);
}
else
    std::cout << "error" << std::endl;

Delete faces from TMSpline

AMCAX::Point3 Pmin(0., 0., 0.); // The min corner point
AMCAX::Point3 Pmax(12., 12., 12.); // The max corner point
size_t segX = 2; // The number of segments in x direction
size_t segY = 2; // The number of segments in y direction
size_t segZ = 2; // The number of segments in z direction
 
// Construct a cube
AMCAX::TMS::TMSplineMakeCube mkCube(Pmin, Pmax, segX, segY, segZ);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
 
// Delete faces in a TMSpline
AMCAX::TMS::TMSplineReduce reduce;
const std::vector<int> flist = { 2, 6 }; // The faces that need to be deleted
if (reduce.CanDeleteFaces(tsp, flist))
{
    reduce.DeleteFaces(tsp, flist);
}
else
    std::cout << "error" << std::endl;

Separation

The AMCAX::TMS::TMSplineSeparate class provides separation functions.

AMCAX::Point3 Pmin(0., 0., 0.); // The min corner point
AMCAX::Point3 Pmax(12., 12., 12.); // The max corner point
size_t segX = 3; // The number of segments in x direction
size_t segY = 3; // The number of segments in y direction
size_t segZ = 3; // The number of segments in z direction
 
// Construct a cube
AMCAX::TMS::TMSplineMakeCube mkCube(Pmin, Pmax, segX, segY, segZ);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
 
// Separate
AMCAX::TMS::TMSplineSeparate separate;
std::vector<int> elist = { 11, 17 }; // The edges that need to separate
separate.SeparateEdges(tsp, elist);

Welding

The AMCAX::TMS::TMSplineWeld class provides welding functions.

Weld two specified edges

AMCAX::Point3 Pmin(0., 0., 0.); // The min corner point
AMCAX::Point3 Pmax(12., 12., 12.); // The max corner point
size_t segX = 3; // The number of segments in x direction
size_t segY = 3; // The number of segments in y direction
size_t segZ = 3; // The number of segments in z direction
 
// Construct a cube
AMCAX::TMS::TMSplineMakeCube mkCube(Pmin, Pmax, segX, segY, segZ);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
 
// Separate
AMCAX::TMS::TMSplineSeparate separate;
std::vector<int> elist = { 11, 17 }; // The edges that need to separate
separate.SeparateEdges(tsp, elist);
 
// Weld two edges
AMCAX::TMS::TMSplineWeld weld;
int e1 = 17; // The first edge
int e2 = 109; // The second edge
if (weld.CanWeldTwoEdge(tsp, e1, e2))
{
    weld.WeldTwoEdge(tsp, e1, e2);
}
else
    std::cout << "error" << std::endl;

Weld edges within a tolerance range

AMCAX::Point3 Pmin(0., 0., 0.); // The min corner point
AMCAX::Point3 Pmax(12., 12., 12.); // The max corner point
size_t segX = 3; // The number of segments in x direction
size_t segY = 3; // The number of segments in y direction
size_t segZ = 3; // The number of segments in z direction
 
// Construct a cube
AMCAX::TMS::TMSplineMakeCube mkCube(Pmin, Pmax, segX, segY, segZ);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
 
// Separate
AMCAX::TMS::TMSplineSeparate separate;
std::vector<int> elist = { 11, 17 }; // The edges that need to separate
separate.SeparateEdges(tsp, elist);
 
// Weld edges
AMCAX::TMS::TMSplineWeld weld;
std::vector<int> elist_weld = { 11, 17, 108, 109 }; // The edges that need to be welded
double tolerance = 0.01;
if (weld.CanWeldEdges(tsp, elist_weld))
{
    weld.WeldEdges(tsp, elist_weld, tolerance);
}
else
    std::cout << "error" << std::endl;

Topological Modeling Functions

Topological modeling functions include transformation, extrusion, thickening, filling holes, etc.

Transformation

The AMCAX::TMS::TMSplineTransform class provides transformation functions. It supports transforming vertex lists, edge lists, and face lists in TMSpline.

AMCAX::Point3 Pmin(0., 0., 0.); // The min corner point
AMCAX::Point3 Pmax(12., 12., 12.); // The max corner point
size_t segX = 3; // The number of segments in x direction
size_t segY = 3; // The number of segments in y direction
size_t segZ = 3; // The number of segments in z direction
 
// Construct a cube
AMCAX::TMS::TMSplineMakeCube mkCube(Pmin, Pmax, segX, segY, segZ);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
 
// Set the transformation as the translation
AMCAX::Frame3 frame;
double h = 30;
AMCAX::Vector3 vec(frame.Direction().Coord() * h);
AMCAX::TMS::TMSplineTransform trsfV;
AMCAX::Transformation3 trsfMove;
trsfMove.SetTranslation(vec);
trsfV.SetTransformation(trsfMove);
 
// Apply transformations to vertex list in a TMSpline
std::vector<int> vlist = { 0, 1, 2 };
trsfV.TransformTMSplineVertices(tsp, vlist);
 
// Apply transformations to edge list in a TMSpline
std::vector<int> elist = { 14, 15, 16 };
trsfV.TransformTMSplineEdges(tsp, elist);
 
// Apply transformations to face list in a TMSpline
std::vector<int> flist = { 27, 28, 29 };
trsfV.TransformTMSplineFaces(tsp, flist);

Extrusion

The AMCAX::TMS::TMSplineExtrude class provides extrusion functions. It supports extruding edges and faces.

Extrude edges

Edges to be extruded must be boundary edges. You can check the input edges using AMCAX::TMS::TMSplineCheck::IsEdgeBoundary.

AMCAX::Frame3 frame;
double dx = 3.; // The size in x direction
double dy = 3.; // The size in y direction
size_t useg = 1; // The number of segments in x direction
size_t vseg = 1; // The number of segments in y direction
 
// Construct a rectangle
AMCAX::TMS::TMSplineMakeRectangle mkRect(frame, dx, dy, useg, vseg);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkRect.BuildSpline();
 
// Extrude the edges in TMSpline
AMCAX::TMS::TMSplineExtrude extrude;
std::vector<int> edgeid = { 0, 1, 2 };
std::vector<int> edgeid_new; // Indices of the edges after extrusion
if (extrude.CanExtrudeEdges(tsp, edgeid))
{
    extrude.ExtrudeEdges(tsp, edgeid, edgeid_new);
}
else
    std::cout << "error" << std::endl;

Extrude faces

AMCAX::Point3 Pmin(0., 0., 0.); // The min corner point
AMCAX::Point3 Pmax(12., 12., 12.); // The max corner point
size_t segX = 3; // The number of segments in x direction
size_t segY = 3; // The number of segments in y direction
size_t segZ = 3; // The number of segments in z direction
 
// Construct a cube
AMCAX::TMS::TMSplineMakeCube mkCube(Pmin, Pmax, segX, segY, segZ);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
 
// Extrude the faces in TMSpline
AMCAX::TMS::TMSplineExtrude extrude;
std::vector<int> faceid = { 0, 2, 5 };
std::vector<int> faceid_new; // Indices of the faces after extrusion
if (extrude.CanExtrudeFaces(tsp, faceid))
{
    extrude.ExtrudeFaces(tsp, faceid, faceid_new);
}
else
    std::cout << "error" << std::endl;

Thickening and Offsetting

The AMCAX::TMS::TMSplineThicken class provides functions for thickening and offsetting.

Thickening

AMCAX::Frame3 frame;
double dx = 3.; // The size in x direction
double dy = 3.; // The size in y direction
size_t useg = 3; // The number of segments in x direction
size_t vseg = 3; // The number of segments in y direction
 
// Construct a rectangle
AMCAX::TMS::TMSplineMakeRectangle mkRect(frame, dx, dy, useg, vseg);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkRect.BuildSpline();
 
// Thicken a TMSpline
AMCAX::TMS::TMSplineThicken thicken;
double dist = 1.;
thicken.ThickenTMSpline(tsp, dist);

Offsetting

AMCAX::Frame3 frame;
double dx = 3.; // The size in x direction
double dy = 3.; // The size in y direction
size_t useg = 3; // The number of segments in x direction
size_t vseg = 3; // The number of segments in y direction
 
// Construct a rectangle
AMCAX::TMS::TMSplineMakeRectangle mkRect(frame, dx, dy, useg, vseg);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkRect.BuildSpline();
 
// Offset a TMSpline
AMCAX::TMS::TMSplineThicken offset;
double dist = 1.;
AMCAX::TMS::TMSpline* tsp_offset = offset.OffsetTMSpline(tsp, dist);

Filling Holes

The AMCAX::TMS::TMSplineFillHole class provides functions for filling holes. It supports filling holes containing specified edges or all holes in TMSpline. Note that for an open mesh, filling holes will also treat the boundary as a hole and fill it with a polygon.

Fill holes in TMSpline containing specified edges

AMCAX::Point2 p0(1., 1.); // The min corner point
AMCAX::Point2 p1(10., 10.); // The max corner point
size_t useg = 3; // The number of segments in x direction
size_t vseg = 3; // The number of segments in y direction
 
// Construct a rectangle
AMCAX::TMS::TMSplineMakeRectangle mkRect(p0, p1, useg, vseg);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkRect.BuildSpline();
 
// Delete faces in a TMSpline
std::vector<int> flist = { 4 };
AMCAX::TMS::TMSplineReduce reduce;
reduce.DeleteFaces(tsp, flist);
 
// Fill hole with input edge
AMCAX::TMS::TMSplineFillHole fillhole;
size_t edgeid = 6;
if (fillhole.CanFillSingleHole(tsp, edgeid))
{
    fillhole.FillSingleHole(tsp, edgeid);
}
else
    std::cout << "error" << std::endl;

Fill all holes in TMSpline

AMCAX::Point2 p0(1., 1.); // The min corner point
AMCAX::Point2 p1(10., 10.); // The max corner point
size_t useg = 3; // The number of segments in x direction
size_t vseg = 3; // The number of segments in y direction
 
// Construct a rectangle
AMCAX::TMS::TMSplineMakeRectangle mkRect(p0, p1, useg, vseg);
 
// Build and get the result TMSpline
AMCAX::TMS::TMSpline* tsp = mkRect.BuildSpline();
 
// Delete faces in a TMSpline
std::vector<int> flist = { 0, 6 };
AMCAX::TMS::TMSplineReduce reduce;
reduce.DeleteFaces(tsp, flist);
 
// Fill all holes in TMSpline
AMCAX::TMS::TMSplineFillHole fillhole;
fillhole.FillAllHoles(tsp);

Conversion Function

The AMCAX::TMS::TMSplineToNURBS class is used to convert T-splines to NURBS.

// Construct a cube
AMCAX::Point3 Pmin(0., 0., 0.);// The min corner point
AMCAX::Point3 Pmax(12., 12., 12.);// The max corner point
size_t segX = 3;// The number of segments in x direction
size_t segY = 3;// The number of segments in y direction
size_t segZ = 3;// The number of segments in z direction
 
AMCAX::TMS::TMSplineMakeCube mkCube(Pmin, Pmax, segX, segY, segZ);
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
 
// Convert to NURBS surfaces
AMCAX::TMS::TMSplineToNURBS tonurbs(tsp);
std::vector<std::shared_ptr<TMBSplineSurface>> surfaces = tonurbs.GetGeom();
 
// Build faces and add to shell
TopoBuilder builder;
TopoShell shell;
builder.MakeShell(shell);
 
for (size_t i = 0; i < surfaces.size(); ++i)
{
    // Get all infomation of TMBSplineSurface
    const auto& surf = surfaces[i];
    Array2<Point3> pts;
    Array2<double> w;
    std::vector<double> uK, vK;
    std::vector<int> uM, vM;
    int uD, vD;
    bool uP, vP;
    surf->GetInfo(pts, w, uK, vK, uM, vM, uD, vD, uP, vP);
 
    // Construct a B spline face
    auto bsp_surf = std::make_shared<Geom3BSplineSurface>(pts, w, uK, vK, uM, vM, uD, vD, uP, vP);
    TopoFace face = MakeFace(bsp_surf, 1e-7);
 
    // Add to a shell
    builder.Add(shell, face);
}

Meshing

The AMCAX::TMS::TMSplineMeshing class is used to partition TMSpline into triangular meshes.

AMCAX::Point3 Pmin(0., 0., 0.); // The min corner point
AMCAX::Point3 Pmax(12., 12., 12.); // The max corner point
size_t segX = 3; // The number of segments in x direction
size_t segY = 3; // The number of segments in y direction
size_t segZ = 3; // The number of segments in z direction
 
// Construct a cube
AMCAX::TMS::TMSplineMakeCube mkCube(Pmin, Pmax, segX, segY, segZ);
 
// Meshing
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
AMCAX::TMS::TMSplineMeshing tspMesh(tsp, 4);
tspMesh.UpdateDrawMesh();

Exporting

The AMCAX::TMS::TMSplineMeshingIO class provides functionality for exporting files. It supports exporting to OBJ/STL files.

AMCAX::Point3 Pmin(0., 0., 0.); // The min corner point
AMCAX::Point3 Pmax(12., 12., 12.); // The max corner point
size_t segX = 3; // The number of segments in x direction
size_t segY = 3; // The number of segments in y direction
size_t segZ = 3; // The number of segments in z direction
 
// Construct a cube
AMCAX::TMS::TMSplineMakeCube mkCube(Pmin, Pmax, segX, segY, segZ);
 
// Meshing
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
AMCAX::TMS::TMSplineMeshing tspMesh(tsp, 4);
tspMesh.UpdateDrawMesh();
 
// Export
AMCAX::TMS::TMSplineMeshingIO meshIO;
std::string fileNameOBJ = "e_cube.obj";
std::string fileNameSTL = "e_cube.stl";
meshIO.ExportToOBJ(fileNameOBJ, tspMesh.GetDrawMesh());
meshIO.ExportToSTL(fileNameSTL, tspMesh.GetDrawMesh());