T Mesh Spline Modeling

Basic Geometry Construction

Basic geometries include planar rectangle, cube, cylinder, cone, truncated cone, sphere, torus, and others.

TMSplineMakeRectangle（Planar Rectangle）

AMCAX::Frame3 frame;
AMCAX::TMS::TMSplineMakeRectangle mkRect(frame, 3, 3, 3, 3);
AMCAX::TMS::TMSpline* tsp1 = mkRect.BuildSpline();

TMSplineMakeCube（Cube）

AMCAX::Point3 min(0.00, 0.00, 0.00), max(12.00, 12.00, 12.00);
AMCAX::TMS::TMSplineMakeCube mkCube(min, max, 3, 3, 3);
AMCAX::TMS::TMSpline* tsp2 = mkCube.BuildSpline();

TMSplineMakeCylinder（Cylinder）

AMCAX::Frame3 frame;
AMCAX::TMS::TMSplineMakeCylinder mkCylinder(frame, 1.0, 4.0, true, true, 8, 4);
AMCAX::TMS::TMSpline* tsp3 = mkCylinder.BuildSpline();

TMSplineMakeCone（Cone）

AMCAX::TMS::TMSplineMakeCone mkCone(1.0, 2.0, true, 8, 4);
AMCAX::TMS::TMSpline* tsp4 = mkCone.BuildSpline();

TMSplineMakeCone（Truncated Cone）

AMCAX::Frame3 frame;
AMCAX::TMS::TMSplineMakeCone mkCone2(frame, 2.0, 1.0, 2.0, true, true, 8, 4);
AMCAX::TMS::TMSpline* tsp5 = mkCone2.BuildSpline();

TMSplineMakeSphere（Sphere）

AMCAX::TMS::TMSplineMakeSphere mkSphere(10.0, 8, 8);
AMCAX::TMS::TMSpline* tsp6 = mkSphere.BuildSpline();

TMSplineMakeTorus（Torus）

AMCAX::TMS::TMSplineMakeTorus mkTorus(20.0, 10.0, 8, 16);
AMCAX::TMS::TMSpline* tsp7 = mkTorus.BuildSpline();

Basic Edit Function

Basic edit function include traversal, add faces, split, deletion, separation, and weld.

Traversal

The AMCAX::TMS::TMSplineTool class provides traversal functions, as detailed below:
AMCAX::TMS::TMSplineTool::FaceVertexIndexs get all vertex indices of a specific face in the TMSpline;
AMCAX::TMS::TMSplineTool::EdgeVertexIndexs get vertex indices of a specific edge in the TMSpline;
AMCAX::TMS::TMSplineTool::FaceEdgeIndexs get all edge indices of a specific face in the TMSpline;
AMCAX::TMS::TMSplineTool::EdgeFaceIndexs get indices of faces adjacent to the specified edge in the TMSpline.

Get all vertex indices of a specific face in the TMSpline

AMCAX::Point3 bb_min(0.00, 0.00, 0.00), bb_max(12.00, 12.00, 12.00);
AMCAX::TMS::TMSplineMakeCube mkCube(bb_min, bb_max, 3, 3, 3);
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
 
int face = 0;
std::vector< int > index_v = AMCAX::TMS::TMSplineTool::FaceVertexIndexs(tsp, face);

Get vertex indices of a specific edge in the TMSpline

AMCAX::Point3 bb_min(0.00, 0.00, 0.00), bb_max(12.00, 12.00, 12.00);
AMCAX::TMS::TMSplineMakeCube mkCube(bb_min, bb_max, 3, 3, 3);
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
 
int edge = 0;
int vfirst, vlast;
AMCAX::TMS::TMSplineTool::EdgeVertexIndexs(tsp, edge, vfirst, vlast);

Get all edge indices of a specific face in the TMSpline

AMCAX::Point3 bb_min(0.00, 0.00, 0.00), bb_max(12.00, 12.00, 12.00);
AMCAX::TMS::TMSplineMakeCube mkCube(bb_min, bb_max, 3, 3, 3);
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
 
int face = 0;
std::vector< int > index_e = AMCAX::TMS::TMSplineTool::FaceEdgeIndexs(tsp, face);

Get indices of faces adjacent to a specified edge in the TMSpline

AMCAX::Point3 bb_min(0.00, 0.00, 0.00), bb_max(12.00, 12.00, 12.00);
AMCAX::TMS::TMSplineMakeCube mkCube(bb_min, bb_max, 3, 3, 3);
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
 
int edge = 0;
std::vector< int >index_f = AMCAX::TMS::TMSplineTool::EdgeFaceIndexs(tsp, edge);

Add Face

The AMCAX::TMS::TMSplineAddFace class provides add functionality. AMCAX::TMS::TMSplineAddFace::AddSingleFace adds a single face composed of a set of points to a TMSpline; AMCAX::TMS::TMSplineAddFace::AddFaceByEdge adds a single face composed of two edges to a TMSpline. In addition, AMCAX::TMS::TMSplineAddFace::CanAddSingleFace or AMCAX::TMS::TMSplineAddFace::CanAddFaceByEdge can be used to determine whether a face can be added successfully or not before adding.

Add a single face defined by a set of points to the TMSpline

AMCAX::Frame3 frame;
AMCAX::TMS::TMSplineMakeRectangle mkRect(frame, 10., 10., 2, 2);
AMCAX::TMS::TMSpline* tsp1 = mkRect.BuildSpline();
 
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 };
AMCAX::TMS::TMSplineAddFace af1;
bool r1 = af1.CanAddSingleFace(tsp1, vlist);
std::cout << r1 << std::endl;
af1.AddSingleFace(tsp1, vlist);
 
AMCAX::TMS::TMSplineMeshing tspMesh1(tsp1, 4);
tspMesh1.UpdateDrawMesh();
AMCAX::TMS::TMSplineMeshingIO meshIO1;
std::string fileNameOBJ1 = "AddSingleFace.obj";
meshIO1.ExportToOBJ(fileNameOBJ1, tspMesh1.GetDrawMesh());

Add a single face defined by two edges to the TMSpline

To be down.

Split

AMCAX::TMS::TMSplineSplit class provides split functions.
To be down.

Deletion

AMCAX::TMS::TMSplineReduce class provides deletion functions. The specific functions are:
AMCAX::TMS::TMSplineReduce::RemoveVertices removes vertices from the TMSpline (edges connected to those vertices are also deleted);
AMCAX::TMS::TMSplineReduce::RemoveEdges removes edges from the TMSpline;
AMCAX::TMS::TMSplineReduce::DeleteFaces removes faces from the TMSpline.
Before deletion, you can check if it's possible to remove vertices/edges/faces using AMCAX::TMS::TMSplineReduce::CanRemoveVertices, AMCAX::TMS::TMSplineReduce::CanRemoveEdges, or AMCAX::TMS::TMSplineReduce::CanDeleteFaces.

Remove vertices from the TMSpline

AMCAX::Point3 min(0.00, 0.00, 0.00), max(12.00, 12.00, 12.00);
AMCAX::TMS::TMSplineMakeCube mkCube(min, max, 2, 2, 2);
AMCAX::TMS::TMSpline* tsp1 = mkCube.BuildSpline();
 
std::vector< int >vlist = { 0,1};
AMCAX::TMS::TMSplineReduce rv;
std::cout << rv.CanRemoveVertices(tsp1, vlist) << std::endl;
rv.RemoveVertices(tsp1, vlist);

Remove edges from the TMSpline

AMCAX::Point3 min(0.00, 0.00, 0.00), max(12.00, 12.00, 12.00);
AMCAX::TMS::TMSplineMakeCube mkCube(min, max, 2, 2, 2);
AMCAX::TMS::TMSpline* tsp1 = mkCube.BuildSpline();
 
const std::vector< int > elist = { 10,15};
AMCAX::TMS::TMSplineReduce rv2;
std::cout << rv2.CanRemoveEdges(tsp1, elist) << std::endl;
rv2.RemoveEdges(tsp1, elist);

Remove faces from the TMSpline

AMCAX::Point3 min(0.00, 0.00, 0.00), max(12.00, 12.00, 12.00);
AMCAX::TMS::TMSplineMakeCube mkCube(min, max, 2, 2, 2);
AMCAX::TMS::TMSpline* tsp1 = mkCube.BuildSpline();
 
const std::vector< int > flist = { 2,6};
AMCAX::TMS::TMSplineReduce rv3;
std::cout << rv3.CanDeleteFaces(tsp1, flist) << std::endl;
rv3.DeleteFaces(tsp1, flist);

Separation and Weld

AMCAX::TMS::TMSplineSeparate class provides separation functions, and the AMCAX::TMS::TMSplineWeld class provides weld functions.

AMCAX::Frame3 frame;
AMCAX::TMS::TMSplineMakeRectangle mkRect(frame, 3, 3, 3, 3);
AMCAX::TMS::TMSpline* tsp1 = mkRect.BuildSpline();
 
//SeparateEdges
std::vector< int >elist = { 0 };
AMCAX::TMS::TMSplineSeparate se;
std::cout << se.SeparateEdges(tsp1, elist) << std::endl；
 
//WeldEdges
AMCAX::TMS::TMSplineWeld we;
std::cout << we.CanWeldEdges(tsp1, elist) << std::endl;
we.WeldEdges(tsp1, elist);

Topological Modeling Function

Topological modeling functions include transformation, extrusion, thicken, hole fill, and others.

Transformation

The AMCAX::TMS::TMSplineTransform class provides transformation functions. AMCAX::TMS::TMSplineTransform::TransformTMSplineVertices transforms the list of vertices in the TMSpline; AMCAX::TMS::TMSplineTransform::TransformTMSplineEdges transforms the list of edges in the TMSpline; AMCAX::TMS::TMSplineTransform::TransformTMSplineFaces transforms the list of faces in the TMSpline.

AMCAX::Point3 min(0.00, 0.00, 0.00), max(12.00, 12.00, 12.00);
AMCAX::TMS::TMSplineMakeCube mkCube(min, max, 3, 3, 3);
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
AMCAX::Frame3 frame;
double h = 30;
AMCAX::Vector3 vh(frame.Direction().Coord() * h);
AMCAX::TMS::TMSplineTransform trsfV;
AMCAX::Transformation3 trsfMove;
 
//TransformTMSplineVertices
std::vector< int > vlist = { 0,1,2 };
trsfV.TransformTMSplineVertices(tsp, vlist);
 
//TransformTMSplineEdges
std::vector< int > elist = { 14,15,16 };
trsfV.TransformTMSplineEdges(tsp, elist);
 
//TransformTMSplineFaces
std::vector< int > flist = { 27,28,29 };
trsfV.TransformTMSplineEdges(tsp, flist);

Extrusion

The AMCAX::TMS::TMSplineExtrude class provides extrusion functions. AMCAX::TMS::TMSplineExtrude::ExtrudeEdges is used to extrude edges; AMCAX::TMS::TMSplineExtrude::ExtrudeFaces is used to extrude faces.

Extrude Edge

Note that the edges to be extruded must be boundary edges.

AMCAX::Frame3 frame;
AMCAX::TMS::TMSplineMakeRectangle mkRect(frame, 3, 3, 1, 1);
AMCAX::TMS::TMSpline* tsp = mkRect.BuildSpline();
 
std::vector<int> edgeid = { 0,1,2 };
std::vector<int> edge_id_new;
std::cout << AMCAX::TMS::TMSplineCheck::IsEdgeBoundary(tsp, edgeid[0]) << std::endl;
std::cout << AMCAX::TMS::TMSplineCheck::IsEdgeBoundary(tsp, edgeid[1]) << std::endl;
std::cout << AMCAX::TMS::TMSplineCheck::IsEdgeBoundary(tsp, edgeid[2]) << std::endl;
 
AMCAX::TMS::TMSplineExtrude ex;
std::cout << ex.CanExtrudeEdges(tsp, edgeid) << std::endl;
ex.ExtrudeEdges(tsp, edgeid, edge_id_new);

Extrude Face

AMCAX::Point3 min(0.00, 0.00, 0.00), max(12.00, 12.00, 12.00);
AMCAX::TMS::TMSplineMakeCube mkCube(min, max, 3, 3, 3);
AMCAX::TMS::TMSpline* tsp2 = mkCube.BuildSpline();
std::vector<int> faceid = { 0,2,5};
std::vector<int> face_id_new;
 
std::cout << ex.CanExtrudeFaces(tsp2, faceid) << std::endl;
ex.ExtrudeFaces(tsp2, faceid, face_id_new);

Thicken

AMCAX::Frame3 frame;
AMCAX::TMS::TMSplineMakeRectangle mkRect(frame, 3, 3, 3, 3);
AMCAX::TMS::TMSpline* tsp = mkRect.BuildSpline();
 
AMCAX::TMS::TMSplineThicken mkThick;
mkThick.ThickenTMSpline(tsp, 1);

Hole Fill

The AMCAX::TMS::TMSplineFillHole class provides hole filling functions. AMCAX::TMS::TMSplineFillHole::FillAllHoles is used to fill a specific hole in a TMSpline; before filling hole, AMCAX::TMS::TMSplineFillHole::CanFillSingleHole can be used to check if a hole can be filled; AMCAX::TMS::TMSplineFillHole::FillAllHoles is used to fill all holes in the TMSpline. Note that for an open mesh, during hole filling, the boundary will also be considered a hole and filled with a polygon.

AMCAX::Point2 p0(1.0, 1.0), p1(10.0, 10.0);
AMCAX::TMS::TMSplineMakeRectangle mkRect(p0, p1, 3, 3);
AMCAX::TMS::TMSpline* tsp = mkRect.BuildSpline();
 
std::vector<int> face_id = { 4 };
std::vector<int> edge_id = { 6, 10, 13, 14 };
AMCAX::TMS::TMSplineReduce reduce;
reduce.DeleteFaces(tsp, face_id);
 
//FillSingleHole
AMCAX::TMS::TMSplineFillHole fillhole;
std::cout << fillhole.CanFillSingleHole(tsp, 6) << std::endl;
fillhole.FillSingleHole(tsp, 6);
 
//FillAllHoles
std::vector<int> face_id2 = { 0,6 };
AMCAX::TMS::TMSplineReduce reduce2;
reduce2.DeleteFaces(tsp, face_id2);
 
AMCAX::TMS::TMSplineFillHole fillhole2;
fillhole2.FillAllHoles(tsp);

Meshing

AMCAX::TMS::TMSplineMeshing class divides the TMSpline into triangular meshes.

AMCAX::Point3 bb_min(0.00, 0.00, 0.00), bb_max(12.00, 12.00, 12.00);
AMCAX::TMS::TMSplineMakeCube mkCube(bb_min, bb_max, 3, 3, 3);
AMCAX::TMS::TMSpline* tsp = mkCube.BuildSpline();
AMCAX::TMS::TMSplineMeshing tspMesh(tsp, 4);
tspMesh.UpdateDrawMesh();

Export OBJ/STL File

AMCAX::TMS::TMSplineMeshingIO::ExportToOBJ provides the function to export to OBJ files; AMCAX::TMS::TMSplineMeshingIO::ExportToSTL provides the function to export to STL files.

AMCAX::Point3 min(0.00, 0.00, 0.00), max(12.00, 12.00, 12.00);
AMCAX::TMS::TMSplineMakeCube mkCube(min, max, 3, 3, 3);
AMCAX::TMS::TMSpline* tsp4 = mkCube.BuildSpline();
AMCAX::TMS::TMSplineMeshing tspMesh4(tsp4, 4);
tspMesh4.UpdateDrawMesh();
 
AMCAX::TMS::TMSplineMeshingIO meshIO4;
std::string fileNameOBJ4 = "cube.obj";
std::string fileNameOBJ5 = "cube.stl";
meshIO4.ExportToOBJ(fileNameOBJ4, tspMesh4.GetDrawMesh());
meshIO4.ExportToSTL(fileNameOBJ5, tspMesh4.GetDrawMesh());