PolyMesh Subdivision Modeling

Basic Shape Construction

Basic shape include plane rectangle, cube, cylinder, cone, truncated cone, sphere, torus, etc.

MeshMakeRectangle（Plane Rectangle）

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeRectangle mkRect(frame, 3, 3, 3, 3);
AMCAX::SubD::PolyMesh* mesh1 = mkRect.BuildMesh();

MeshMakeCube（Cube）

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeCube makeCube(frame, 10, 10, 10, 10, 10, 10);
AMCAX::SubD::PolyMesh* mesh2 = makeCube.BuildMesh();

MeshMakeCylinder（Cylinder）

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeCylinder makeCylinder(frame, 2.0, 5.0);
AMCAX::SubD::PolyMesh* mesh3 = makeCylinder.BuildMesh();

MeshMakeCone（Cone）

AMCAX::SubD::MeshMakeCone meshmakeCone1(1., 1.);
AMCAX::SubD::PolyMesh* mesh4 = meshmakeCone1.BuildMesh();

MeshMakeCone（Truncated Cone）

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeCone meshmakeCone2(frame, 2., 1., 2.);
AMCAX::SubD::PolyMesh* mesh5 = meshmakeCone2.BuildMesh();

MeshMakeSphere（Sphere）

double r = 2.1;
AMCAX::SubD::MeshMakeSphere sphere(r);
AMCAX::SubD::PolyMesh* mesh6 = sphere.BuildMesh();

MeshMakeTorus（Torus）

AMCAX::SubD::MeshMakeTorus maketorus(2.0, 0.5, 8, 4);
AMCAX::SubD::PolyMesh* mesh7 = maketorus.BuildMesh();

Basic Edit Feature

Basic edit feature include traversal, face addition, split, deletion, separation, and weld.

Traversal

AMCAX::SubD::MeshTool class provides traversal features, such as the following:
AMCAX::SubD::MeshTool::EdgeVertexIndexs is used to get the indices of the vertices of a specific edge in the PolyMesh;
AMCAX::SubD::MeshTool::FaceVertexIndexs is used to get the indices of all vertices of a specific face in the PolyMesh;
AMCAX::SubD::MeshTool::FaceEdgeIndexs is used to get the indices of all edges of a specific face in the PolyMesh;
AMCAX::SubD::MeshTool::EdgeFaceIndexs is used to get the indices of the faces adjacent to a given edge in the PolyMesh;
AMCAX::SubD::MeshTool::VertEdgeIndexs is used to get the indices of edges adjacent to a given vertex in the PolyMesh;
AMCAX::SubD::MeshTool::VertFaceIndexs is used to get the indices of faces adjacent to a given vertex in the PolyMesh;
AMCAX::SubD::MeshTool::FaceAdjacentFaces is used to get the indices of faces adjacent to a given face in the PolyMesh.

Get the indices of the vertices of a specific edge in the PolyMesh

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeCube makeCube(frame, 10, 10, 10, 10, 10, 10);
AMCAX::SubD::PolyMesh* mesh = makeCube.BuildMesh();
 
int edge = 0;
int vfirst, vlast;
AMCAX::SubD::MeshTool::EdgeVertexIndexs(mesh, edge, vfirst, vlast);
AMCAX::Point3 p1 = AMCAX::SubD::MeshTool::Position(mesh, vfirst);
AMCAX::Point3 p2 = AMCAX::SubD::MeshTool::Position(mesh, vlast);

Get the indices of all vertices of a specific face in the PolyMesh

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeCube makeCube(frame, 10, 10, 10, 10, 10, 10);
AMCAX::SubD::PolyMesh* mesh = makeCube.BuildMesh();
 
std::vector< int > index = AMCAX::SubD::MeshTool::FaceVertexIndexs(mesh, face);
AMCAX::Point3 p3 = AMCAX::SubD::MeshTool::Position(mesh, index[0]);
AMCAX::Point3 p4 = AMCAX::SubD::MeshTool::Position(mesh, index[1]);
AMCAX::Point3 p5 = AMCAX::SubD::MeshTool::Position(mesh, index[2]);
AMCAX::Point3 p6 = AMCAX::SubD::MeshTool::Position(mesh, index[3]);

Get the indices of all edges of a specific face in the PolyMesh

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeCube makeCube(frame, 10, 10, 10, 10, 10, 10);
AMCAX::SubD::PolyMesh* mesh = makeCube.BuildMesh();
int face = 0;
std::vector< int > index_e =AMCAX::SubD::MeshTool::FaceEdgeIndexs(mesh, face);

Get the indices of the faces adjacent to a given edge in the PolyMesh

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeCube makeCube(frame, 10, 10, 10, 10, 10, 10);
AMCAX::SubD::PolyMesh* mesh = makeCube.BuildMesh();
int edge = 0;
std::vector< int > index_f = AMCAX::SubD::MeshTool::EdgeFaceIndexs(mesh, edge);

Get the indices of edges adjacent to a given vertex in the PolyMesh

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeCube makeCube(frame, 10, 10, 10, 10, 10, 10);
AMCAX::SubD::PolyMesh* mesh = makeCube.BuildMesh();
int vertex = 0;
std::vector< int > index_e1 = AMCAX::SubD::MeshTool::VertEdgeIndexs(mesh, vertex);

Get the indices of faces adjacent to a given vertex in the PolyMesh

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeCube makeCube(frame, 10, 10, 10, 10, 10, 10);
AMCAX::SubD::PolyMesh* mesh = makeCube.BuildMesh();
int vertex = 0;
std::vector< int > index_f1 = AMCAX::SubD::MeshTool::VertFaceIndexs(mesh, vertex);

Get the indices of faces adjacent to a given face in the PolyMesh

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeCube makeCube(frame, 10, 10, 10, 10, 10, 10);
AMCAX::SubD::PolyMesh* mesh = makeCube.BuildMesh();
int face = 0;
std::vector< int > index_f2 = AMCAX::SubD::MeshTool::FaceAdjacentFaces(mesh, face);

Add Face

AMCAX::SubD::MeshInsertFace class provides functionality for adding face. Specifically:
AMCAX::SubD::MeshInsertFace::AddSingleFace is used to add a single face constructed from points to the PolyMesh;
AMCAX::SubD::MeshInsertFace::EmbedSingleFace is used to add a single face constructed from certain PolyMesh vertices;
AMCAX::SubD::MeshInsertFace::AddFaceByEdge is used to add a single face constructed from two edges.

Add a single face constructed from points to the PolyMesh

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeCube makeCube(frame, 10, 10, 10, 10, 10, 10);
AMCAX::SubD::PolyMesh* mesh = makeCube.BuildMesh();
AMCAX::Point3 p1(10., 2., 1.);
AMCAX::Point3 p2(12., 5., 3.);
AMCAX::Point3 p3(15., 7., 6.);
std::vector< AMCAX::Point3 > p = { p1,p2,p3 };
AMCAX::SubD::MeshInsertFace::AddSingleFace(mesh, p);

Add a single face constructed from certain PolyMesh vertices to the PolyMesh

The vertices must be boundary vertices, meaning that they are surrounded by boundary edges (edges whose associated faces are less than 2) or have no edges.

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeRectangle mkRect(frame, 15, 15, 1, 1);
AMCAX::SubD::PolyMesh* mesh3 = mkRect.BuildMesh();
int face = 0;
std::vector< int > index_v = AMCAX::SubD::MeshTool::FaceVertexIndexs(mesh3, face);
std::vector< int > vlist{ 0,1,2 };
AMCAX::SubD::MeshInsertFace::EmbedSingleFace(mesh3, vlist);

Add a single face constructed from two edges to the PolyMesh

These two edges must be boundary edges.

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeRectangle mkRect(frame, 15, 15, 1, 1);
AMCAX::SubD::PolyMesh* mesh3 = mkRect.BuildMesh();
int face = 0;
std::vector< int > index_e = AMCAX::SubD::MeshTool::FaceEdgeIndexs(mesh3, face);
AMCAX::SubD::MeshInsertFace::AddFaceByEdge(mesh3, index_e[1], index_e[2]);

Split

AMCAX::SubD::MeshSplit class provides split functionality.
To be down.

Deletion

AMCAX::SubD::MeshReduce class provides deletion functionality. AMCAX::SubD::MeshReduce::DeleteFaces is used to delete faces from the PolyMesh (it allows you to delete any number of faces while leaving holes);AMCAX::SubD::MeshReduce::DeleteIsolatedVertices is used to delete all isolated vertices in the PolyMesh.

Delete Face

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeCube makeCube(frame, 10, 10, 10, 10, 10, 10);
AMCAX::SubD::PolyMesh* mesh = makeCube.BuildMesh();
std::vector<int> face_id = { 1,3, 4 };
AMCAX::SubD::MeshReduce::DeleteFaces(mesh, face_id);

Separation and Weld

AMCAX::SubD::MeshSeparate class provides separation functionality, while the AMCAX::SubD::MeshWeld class provides weld functionality.

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeCube makeCube(frame, 10, 10, 10, 10, 10, 10);
AMCAX::SubD::PolyMesh* mesh = makeCube.BuildMesh();
std::vector< int >edge = { 1,2,3 };
//MeshSeparate
bool r = AMCAX::SubD::MeshSeparate::SeparateEdges(mesh, edge);
std::cout << r << std::endl;
//MeshWeld
AMCAX::SubD::MeshWeld::MeshWeldEdges(mesh, edge);

Topological Modeling Function

Topological modeling function include transformation, extrusion, thicken, hole fill, etc.

Transformation

AMCAX::SubD::MeshTransform class provides transformation functionality. Transformation include:
AMCAX::SubD::MeshTransform::TransformMeshEdges Applies transformations to a list of edges in a PolyMesh;
AMCAX::SubD::MeshTransform::TransformMeshFaces;
AMCAX::SubD::MeshTransform::TransformMeshVertices Applies transformations to a list of vertices in a PolyMesh.

Apply Transformation to a List of Edges in PolyMesh

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeCube makeCube(frame, 10, 10, 10, 10, 10, 10);
AMCAX::SubD::PolyMesh* mesh = makeCube.BuildMesh();
 
AMCAX::SubD::MeshTransform trsfF;
AMCAX::Transformation3 trsfMove;
double h = 2.;
AMCAX::Vector3 vh(frame.Direction().Coord() * h);
trsfMove.SetTranslation(vh);
trsfF.SetTransformation(trsfMove);
 
std::vector< int > index_e = { 0,1,2 };
trsfF.TransformMeshEdges(mesh, index_e);

Apply Transformation to a List of Faces in PolyMesh

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeCube makeCube(frame, 10, 10, 10, 10, 10, 10);
AMCAX::SubD::PolyMesh* mesh = makeCube.BuildMesh();
 
AMCAX::SubD::MeshTransform trsfF;
AMCAX::Transformation3 trsfMove;
double h = 2.;
AMCAX::Vector3 vh(frame.Direction().Coord() * h);
trsfMove.SetTranslation(vh);
trsfF.SetTransformation(trsfMove);
 
std::vector< int > index_f = { 50,70,90,100 };
trsfF.TransformMeshFaces(mesh, index_f);

Apply Transformation to a List of Vertices in PolyMesh

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeCube makeCube(frame, 10, 10, 10, 10, 10, 10);
AMCAX::SubD::PolyMesh* mesh = makeCube.BuildMesh();
 
AMCAX::SubD::MeshTransform trsfF;
AMCAX::Transformation3 trsfMove;
double h = 2.;
AMCAX::Vector3 vh(frame.Direction().Coord() * h);
trsfMove.SetTranslation(vh);
trsfF.SetTransformation(trsfMove);
 
std::vector< int > index_v = { 5,7,9,11 };
trsfF.TransformMeshVertices(mesh, index_v);

Extrusion

AMCAX::SubD::MeshExtrude class provides extrusion functionality. Among which, AMCAX::SubD::MeshExtrude::ExtrudeEdge is used to extrude edges, and AMCAX::SubD::MeshExtrude::ExtrudeFace is used to extrude faces.
To be down.

Thicken

AMCAX::SubD::MeshOffset class provides thicken functionality.

double h = 2;
AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeRectangle mkRect(frame, 3, 3, 3, 3);
AMCAX::SubD::PolyMesh* mesh = mkRect.BuildMesh();
AMCAX::SubD::MeshOffset::ThickenMesh(mesh, 0.2);

Hole Fill

AMCAX::SubD::MeshFillHole class provides hole filling functionality. Among which, AMCAX::SubD::MeshFillHole::FillAllHole fills all holes in a PolyMesh, and AMCAX::SubD::MeshFillHole::FillSingleHole fills a specific hole in a PolyMesh (by inputting the edge ID of any edge of the hole).

Fill All Holes in PolyMesh

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeCube makeCube(frame, 10, 10, 10, 10, 10, 10);
AMCAX::SubD::PolyMesh* mesh = makeCube.BuildMesh();
std::vector<int> face_id = { 1,3, 4 };
AMCAX::SubD::MeshReduce::DeleteFaces(mesh, face_id);
 
int face = 0;
std::vector< int > index_e = AMCAX::SubD::MeshTool::FaceEdgeIndexs(mesh, face);
 
bool r = AMCAX::SubD::MeshFillHole::FillSingleHole(mesh, index_e[1]);
std::cout << r << std::endl;

Fill a Specific Hole in PolyMesh

AMCAX::Frame3 frame;
AMCAX::SubD::MeshMakeCube makeCube(frame, 10, 10, 10, 10, 10, 10);
AMCAX::SubD::PolyMesh* mesh = makeCube.BuildMesh();
std::vector<int> face_id = { 1,3, 4 };
AMCAX::SubD::MeshReduce::DeleteFaces(mesh, face_id);
 
bool r2 = AMCAX::SubD::MeshFillHole::FillAllHole(mesh);
std::cout << r2 << std::endl;

Mesh Subdivision

Mesh subdivision includes two types: Catmull-Clark subdivision and Loop subdivision. Catmull-Clark subdivision supports any mesh, while Loop subdivision only supports triangular meshes (which can be obtained through triangulation using AMCAX::SubD::MeshTool::MeshTriangles).

Catmull-Clark Subdivision

double r = 1;
double h = 1;
AMCAX::SubD::MeshMakeCone meshmakeCone(r, h);
AMCAX::SubD::PolyMesh* mesh = meshmakeCone.BuildMesh();
AMCAX::SubD::MeshSubdivideHE::CatmullClark(mesh, 1);

Additionally, to improve the subdivision efficiency, the kernel also provides AMCAX::SubD::MeshSubdivideRenderCC (for full quadrilateral meshes). The result is the same as Catmull-Clark subdivision, with the same number of vertices, but the sequence is different, so it cannot be compared. Additionally, full quadrilateral meshes can be obtained after one subdivision using AMCAX::MeshSubdivideHE::CatmullClark(mesh, 1).

double r = 1;
double h = 1;
AMCAX::SubD::MeshMakeCone meshmakeCone(r, h);
AMCAX::SubD::PolyMesh* mesh = meshmakeCone.BuildMesh();
AMCAX::SubD::MeshSubdivideHE::CatmullClark(mesh, 1);
 
AMCAX::SubD::MeshSubdivideRenderCC subdivide;
bool r1 = subdivide.DoCatmullClark(mesh, 1);
std::cout << r1 << std::endl;

Loop Subdivision

double r = 1;
double h = 1;
AMCAX::SubD::MeshMakeCone meshmakeCone3(r, h);
AMCAX::SubD::PolyMesh* mesh3 = meshmakeCone.BuildMesh();
AMCAX::SubD::MeshTool::MeshTriangles(mesh3);
AMCAX::SubD::MeshSubdivideHE::Loop(mesh3, 3);

Additionally, to improve the subdivision efficiency, the kernel also provides AMCAX::SubD::MeshSubdivideRenderLoop (for full triangular meshes). The result is the same as Loop subdivision, with the same number of vertices, but the sequence is different, so it cannot be compared.

Import and Export of OBJ and OFF File

Import

//OBJ
AMCAX::SubD::PolyMesh* mesh4;
std::string fileNameOBJ5 = "MeshSubdivideRenderLoop.obj";
AMCAX::SubD::PolyMeshIO::LoadMesh(fileNameOBJ5, mesh4);

Export

//OBJ
std::string fileNameOBJ = "sampleResult.obj";
AMCAX::SubD::PolyMeshIO::WriteMesh(fileNameOBJ, mesh);
 
//OFF
std::string fileNameOFF = "sampleResult.off";
AMCAX::SubD::PolyMeshIO::WriteMesh(fileNameOFF, mesh);