PolyMesh Subdivision Modeling

Building Basic Primitives

Basic primitives include planar rectangles, cubes, cylinders, cones, frustums, spheres, tori, etc.

Planar Rectangle

AMCAX::SubD::MeshMakeRectangle class is used to construct planar rectangles.

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::SubD::MeshMakeRectangle mkRect(frame, dx, dy, useg, vseg);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkRect.BuildMesh();

Cube

AMCAX::SubD::MeshMakeCube class is used to construct cubes.

AMCAX::Frame3 frame;
double dx = 10.;// The size in x direction
double dy = 10.; // The size in y direction
double dz = 10.;// The size in z direction
size_t segX = 10.;// The number of segments in x direction
size_t segY = 10.;// The number of segments in y direction
size_t segZ = 10.;// The number of segments in z direction
 
// Construct a cube
AMCAX::SubD::MeshMakeCube mkCube(frame, dx, dy, dz, segX, segY, segZ);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCube.BuildMesh();

Cylinder

AMCAX::SubD::MeshMakeCylinder class is used to construct cylinders.

AMCAX::Frame3 frame;
double radius = 2.;
double height = 5.;
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 cylinder
AMCAX::SubD::MeshMakeCylinder mkCylinder(frame, radius, height, isTop, isBottom, rseg, vseg);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCylinder.BuildMesh();

Cone

AMCAX::SubD::MeshMakeCone class is used to construct cones.

double radius = 1.;
double height = 1.;
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::SubD::MeshMakeCone mkCone(radius, height, isBottom, rseg, vseg);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCone.BuildMesh();

Frustum

AMCAX::SubD::MeshMakeCone class is used to construct frustums.

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::SubD::MeshMakeCone mkCone(frame, radius1, radius2, height, isTop, isBottom, rseg, vseg);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCone.BuildMesh();

Sphere

AMCAX::SubD::MeshMakeSphere class is used to construct spheres.

double radius = 2.;
size_t rseg = 8;// The number of segments in rotation
size_t vseg = 4;// The number of segments in vertical
 
// Construct a sphere
AMCAX::SubD::MeshMakeSphere mksphere(radius, rseg, vseg);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mksphere.BuildMesh();

Torus

AMCAX::SubD::MeshMakeTorus class is used to construct tori.

double majorRadius = 2.;
double minorRadius = 0.5;
size_t majorSeg = 8;// The number of segments in major rotation
size_t minorSeg = 4;// The number of segments in minor rotation
 
// Construct a torus
AMCAX::SubD::MeshMakeTorus mktorus(majorRadius, minorRadius, majorSeg, minorSeg);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mktorus.BuildMesh();

Basic Editing Functions

Basic editing functions include traversal, face addition, refinement, deletion, separation, welding, etc.

Traversal

AMCAX::SubD::MeshTool class provides traversal functionality, as follows:

Get vertex indices of an edge in PolyMesh

AMCAX::Frame3 frame;
double dx = 10.;// The size in x direction
double dy = 10.; // The size in y direction
double dz = 10.;// The size in z direction
size_t segX = 10.;// The number of segments in x direction
size_t segY = 10.;// The number of segments in y direction
size_t segZ = 10.;// The number of segments in z direction
 
// Construct a cube
AMCAX::SubD::MeshMakeCube mkCube(frame, dx, dy, dz, segX, segY, segZ);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCube.BuildMesh();
 
// Get the vertices of the edge
int edge = 0;// The index of edge
int vfirst, vlast;
AMCAX::SubD::MeshTool::EdgeVertexIndexs(mesh, edge, vfirst, vlast);
 
// Get the position of the vertex
AMCAX::Point3 pf = AMCAX::SubD::MeshTool::Position(mesh, vfirst);
AMCAX::Point3 pl = AMCAX::SubD::MeshTool::Position(mesh, vlast);

Get all vertex indices of a face in PolyMesh

AMCAX::Frame3 frame;
double dx = 10.;// The size in x direction
double dy = 10.; // The size in y direction
double dz = 10.;// The size in z direction
size_t segX = 10.;// The number of segments in x direction
size_t segY = 10.;// The number of segments in y direction
size_t segZ = 10.;// The number of segments in z direction
 
// Construct a cube
AMCAX::SubD::MeshMakeCube mkCube(frame, dx, dy, dz, segX, segY, segZ);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCube.BuildMesh();
 
// Get the indices of vertices in face
int face = 0;// The index of face
std::vector< int > index_v = AMCAX::SubD::MeshTool::FaceVertexIndexs(mesh, face);
 
// Get the position of the vertex
AMCAX::Point3 p0 = AMCAX::SubD::MeshTool::Position(mesh, index_v[0]);
AMCAX::Point3 p1 = AMCAX::SubD::MeshTool::Position(mesh, index_v[1]);
AMCAX::Point3 p2 = AMCAX::SubD::MeshTool::Position(mesh, index_v[2]);
AMCAX::Point3 p3 = AMCAX::SubD::MeshTool::Position(mesh, index_v[3]);

Get all edge indices of a face in PolyMesh

AMCAX::Frame3 frame;
double dx = 10.;// The size in x direction
double dy = 10.; // The size in y direction
double dz = 10.;// The size in z direction
size_t segX = 10.;// The number of segments in x direction
size_t segY = 10.;// The number of segments in y direction
size_t segZ = 10.;// The number of segments in z direction
 
// Construct a cube
AMCAX::SubD::MeshMakeCube mkCube(frame, dx, dy, dz, segX, segY, segZ);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCube.BuildMesh();
 
// Get the edges of the face
int face = 0;// The index of face
std::vector< int > index_e = AMCAX::SubD::MeshTool::FaceEdgeIndexs(mesh, face);

Get face indices adjacent to an input edge in PolyMesh

AMCAX::Frame3 frame;
double dx = 10.;// The size in x direction
double dy = 10.; // The size in y direction
double dz = 10.;// The size in z direction
size_t segX = 10.;// The number of segments in x direction
size_t segY = 10.;// The number of segments in y direction
size_t segZ = 10.;// The number of segments in z direction
 
// Construct a cube
AMCAX::SubD::MeshMakeCube mkCube(frame, dx, dy, dz, segX, segY, segZ);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCube.BuildMesh();
 
// Get the faces adjacent to the edge
int edge = 0;// The index of edge 
std::vector< int > index_f = AMCAX::SubD::MeshTool::EdgeFaceIndexs(mesh, edge);

Get edge indices adjacent to an input vertex in PolyMesh

AMCAX::Frame3 frame;
double dx = 10.;// The size in x direction
double dy = 10.; // The size in y direction
double dz = 10.;// The size in z direction
size_t segX = 10.;// The number of segments in x direction
size_t segY = 10.;// The number of segments in y direction
size_t segZ = 10.;// The number of segments in z direction
 
// Construct a cube
AMCAX::SubD::MeshMakeCube mkCube(frame, dx, dy, dz, segX, segY, segZ);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCube.BuildMesh();
 
// Get the edges adjacent to the vertex
int vertex = 0;// The index of vertex
std::vector< int > index_e = AMCAX::SubD::MeshTool::VertEdgeIndexs(mesh, vertex);

Get face indices adjacent to an input vertex in PolyMesh

AMCAX::Frame3 frame;
double dx = 10.;// The size in x direction
double dy = 10.; // The size in y direction
double dz = 10.;// The size in z direction
size_t segX = 10.;// The number of segments in x direction
size_t segY = 10.;// The number of segments in y direction
size_t segZ = 10.;// The number of segments in z direction
 
// Construct a cube
AMCAX::SubD::MeshMakeCube mkCube(frame, dx, dy, dz, segX, segY, segZ);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCube.BuildMesh();
 
// Get the faces adjacent to the vertex
int vertex = 0;// The index of vertex
std::vector< int > index_f = AMCAX::SubD::MeshTool::VertFaceIndexs(mesh, vertex);

Get face indices adjacent to an input face in PolyMesh

AMCAX::Frame3 frame;
double dx = 10.;// The size in x direction
double dy = 10.; // The size in y direction
double dz = 10.;// The size in z direction
size_t segX = 10.;// The number of segments in x direction
size_t segY = 10.;// The number of segments in y direction
size_t segZ = 10.;// The number of segments in z direction
 
// Construct a cube
AMCAX::SubD::MeshMakeCube mkCube(frame, dx, dy, dz, segX, segY, segZ);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCube.BuildMesh();
 
// Get the faces adjacent to the face
int face = 0;// The index of face
std::vector< int > index_f = AMCAX::SubD::MeshTool::FaceAdjacentFaces(mesh, face);

Adding Faces

AMCAX::SubD::MeshInsertFace class provides face addition functionality. Details are as follows:

Add a single face constructed from points to PolyMesh

AMCAX::Frame3 frame;
double dx = 10.;// The size in x direction
double dy = 10.; // The size in y direction
double dz = 10.;// The size in z direction
size_t segX = 10.;// The number of segments in x direction
size_t segY = 10.;// The number of segments in y direction
size_t segZ = 10.;// The number of segments in z direction
 
// Construct a cube
AMCAX::SubD::MeshMakeCube mkCube(frame, dx, dy, dz, segX, segY, segZ);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCube.BuildMesh();
 
// Add a single face constructed from points to PolyMesh
AMCAX::Point3 p1(10., 2., 1.);
AMCAX::Point3 p2(12., 5., 3.);
AMCAX::Point3 p3(15., 7., 6.);
std::vector< AMCAX::Point3 > points = { p1,p2,p3 };// The points for constructing face
AMCAX::SubD::MeshInsertFace::AddSingleFace(mesh, points);

Add a single face constructed from some PolyMesh vertices to PolyMesh

The vertices must be boundary vertices, meaning vertices that have boundary edges (edges belonging to fewer than 2 faces) or no edges around them.

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::SubD::MeshMakeRectangle mkRect(frame, dx, dy, useg, vseg);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkRect.BuildMesh();
 
// Add a single face constructed from some PolyMesh vert
std::vector< int > vlist{ 0,1,2 };// The vert for constructing face
AMCAX::SubD::MeshInsertFace::EmbedSingleFace(mesh, vlist);

Add a single face constructed from two edges to PolyMesh

These two edges must be boundary edges.

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::SubD::MeshMakeRectangle mkRect(frame, dx, dy, useg, vseg);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkRect.BuildMesh();
 
// Add a single face constructed from two edges
int face = 0;// The index of face
std::vector< int > index_e = AMCAX::SubD::MeshTool::FaceEdgeIndexs(mesh, face);
int edge1 = index_e[1];// The first edge
int edge2 = index_e[2];// The second edge
AMCAX::SubD::MeshInsertFace::AddFaceByEdge(mesh, edge1, edge2);

Refinement

AMCAX::SubD::MeshSplit class provides refinement functionality.

Split loop 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::SubD::MeshMakeRectangle mkRect(p0, p1, useg, vseg);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkRect.BuildMesh();
 
// Split a loop faces generated from edge
int eid = 4;
double t = 0.5;
AMCAX::SubD::MeshSplit split;
split.SplitLoop(mesh, eid, t);

Split faces 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::SubD::MeshMakeRectangle mkRect(p0, p1, useg, vseg);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkRect.BuildMesh();
 
// Split faces by sequentially cross vertices in Mesh
std::vector<int> vlist = { 5, 10 };
AMCAX::SubD::MeshSplit split;
split.SplitFaceWithVertex(mesh, vlist);

Deletion

AMCAX::SubD::MeshReduce class provides deletion functionality.

Delete faces

AMCAX::SubD::MeshReduce::DeleteFaces is used to delete faces in PolyMesh (can freely delete any number of faces and leave holes).

AMCAX::Frame3 frame;
double dx = 10.;// The size in x direction
double dy = 10.; // The size in y direction
double dz = 10.;// The size in z direction
size_t segX = 10.;// The number of segments in x direction
size_t segY = 10.;// The number of segments in y direction
size_t segZ = 10.;// The number of segments in z direction
 
// Construct a cube
AMCAX::SubD::MeshMakeCube mkCube(frame, dx, dy, dz, segX, segY, segZ);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCube.BuildMesh();
 
// Delete given faces
std::vector<int> face_id = { 1,3, 4 };// The faces to be delete
AMCAX::SubD::MeshReduce::DeleteFaces(mesh, face_id);

Separation and Welding

AMCAX::SubD::MeshSeparate class provides separation functionality.

AMCAX::Frame3 frame;
double dx = 10.;// The size in x direction
double dy = 10.; // The size in y direction
double dz = 10.;// The size in z direction
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::SubD::MeshMakeCube mkCube(frame, dx, dy, dz, segX, segY, segZ);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCube.BuildMesh();
 
// Separate edges into each other
std::vector< int >elist = { 0, 3, 6 };
AMCAX::SubD::MeshSeparate::SeparateEdges(mesh, elist);

Welding

AMCAX::SubD::MeshWeld class provides welding functionality.

AMCAX::Frame3 frame;
double dx = 10.;// The size in x direction
double dy = 10.; // The size in y direction
double dz = 10.;// The size in z direction
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::SubD::MeshMakeCube mkCube(frame, dx, dy, dz, segX, segY, segZ);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCube.BuildMesh();
 
// Separate edges into each other
std::vector< int >elist = { 0, 3, 6 };
AMCAX::SubD::MeshSeparate::SeparateEdges(mesh, elist);
 
// Weld
if (AMCAX::SubD::MeshWeld::FilterVoidWeldEdges(mesh, elist))
{
    // Weld them to inner edges
    AMCAX::SubD::MeshWeld::MeshWeldEdges(mesh, elist);
}

Topological Modeling Functions

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

Transformation

AMCAX::SubD::MeshTransform class provides transformation functionality.

Apply transformation to vertex list in PolyMesh

AMCAX::Frame3 frame;
double dx = 10.;// The size in x direction
double dy = 10.; // The size in y direction
double dz = 10.;// The size in z direction
size_t segX = 10.;// The number of segments in x direction
size_t segY = 10.;// The number of segments in y direction
size_t segZ = 10.;// The number of segments in z direction
 
// Construct a cube
AMCAX::SubD::MeshMakeCube mkCube(frame, dx, dy, dz, segX, segY, segZ);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCube.BuildMesh();
 
// Set the transformation as the translation
AMCAX::SubD::MeshTransform trsf;
AMCAX::Transformation3 trsfMove;
double h = 2.;
AMCAX::Vector3 vh(frame.Direction().Coord() * h);
trsfMove.SetTranslation(vh);
trsf.SetTransformation(trsfMove);
 
// Applying transformations to the vertex list
std::vector< int > index_v = { 5,7,9,11 };
trsf.TransformMeshVertices(mesh, index_v);

Apply transformation to edge list in PolyMesh

AMCAX::Frame3 frame;
double dx = 10.;// The size in x direction
double dy = 10.; // The size in y direction
double dz = 10.;// The size in z direction
size_t segX = 10.;// The number of segments in x direction
size_t segY = 10.;// The number of segments in y direction
size_t segZ = 10.;// The number of segments in z direction
 
// Construct a cube
AMCAX::SubD::MeshMakeCube mkCube(frame, dx, dy, dz, segX, segY, segZ);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCube.BuildMesh();
 
// Set the transformation as the translation
AMCAX::SubD::MeshTransform trsf;
AMCAX::Transformation3 trsfMove;
double h = 2.;
AMCAX::Vector3 vh(frame.Direction().Coord() * h);
trsfMove.SetTranslation(vh);
trsf.SetTransformation(trsfMove);
 
// Applying transformations to the edge list
std::vector< int > index_e = { 0,1,2 };
trsf.TransformMeshEdges(mesh, index_e);

Apply transformation to face list in PolyMesh

AMCAX::Frame3 frame;
double dx = 10.;// The size in x direction
double dy = 10.; // The size in y direction
double dz = 10.;// The size in z direction
size_t segX = 10.;// The number of segments in x direction
size_t segY = 10.;// The number of segments in y direction
size_t segZ = 10.;// The number of segments in z direction
 
// Construct a cube
AMCAX::SubD::MeshMakeCube mkCube(frame, dx, dy, dz, segX, segY, segZ);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCube.BuildMesh();
 
// Set the transformation as the translation
AMCAX::SubD::MeshTransform trsf;
AMCAX::Transformation3 trsfMove;
double h = 2.;
AMCAX::Vector3 vh(frame.Direction().Coord() * h);
trsfMove.SetTranslation(vh);
trsf.SetTransformation(trsfMove);
 
// Applying transformations to the face list
std::vector< int > index_f = { 50,70,90,100 };
trsf.TransformMeshFaces(mesh, index_f);

Extrusion

AMCAX::SubD::MeshExtrude class provides extrusion functionality.

Extrude edges

AMCAX::SubD::MeshExtrude::ExtrudeEdge is used to extrude edges.

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::SubD::MeshMakeRectangle mkRect(frame, dx, dy, useg, vseg);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkRect.BuildMesh();
 
// Extrude the edges in PolyMesh
AMCAX::SubD::MeshExtrude extrude;
std::vector<int> edgeid = { 0, 1, 2 };
std::vector<int> edgeid_new; // Indices of the edges after extrusion
extrude.ExtrudeEdge(mesh, edgeid, edgeid_new);

Extrude faces

AMCAX::SubD::MeshExtrude::ExtrudeFace is used to extrude faces.

AMCAX::Point3 p0(0., 0., 0.);// The min corner point
AMCAX::Point3 p1(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 rectangle
AMCAX::SubD::MeshMakeCube mkCube(p0, p1, segX, segY, segZ);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCube.BuildMesh();
 
// Extrude the faces in PolyMesh
AMCAX::SubD::MeshExtrude extrude;
std::vector<int> faceid = { 0, 2, 5 };
std::vector<int> faceid_new; // Indices of the faces after extrusion
extrude.ExtrudeFace(mesh, faceid, faceid_new);

Thickening

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

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::SubD::MeshMakeRectangle mkRect(frame, dx, dy, useg, vseg);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkRect.BuildMesh();
 
// Thicken a mesh
double dist = 0.2;// The reference thickening distance
bool isConnect = true;
AMCAX::SubD::MeshOffset::ThickenMesh(mesh, dist, isConnect);

Hole Filling

AMCAX::SubD::MeshFillHole class provides hole filling functionality.

Fill a single hole in PolyMesh

AMCAX::Frame3 frame;
double dx = 10.;// The size in x direction
double dy = 10.; // The size in y direction
double dz = 10.;// The size in z direction
size_t segX = 10.;// The number of segments in x direction
size_t segY = 10.;// The number of segments in y direction
size_t segZ = 10.;// The number of segments in z direction
 
// Construct a cube
AMCAX::SubD::MeshMakeCube mkCube(frame, dx, dy, dz, segX, segY, segZ);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCube.BuildMesh();
 
// Delete given faces
std::vector<int> face_id = { 1,3, 4 };
AMCAX::SubD::MeshReduce::DeleteFaces(mesh, face_id);
 
// Get the edges of the face
int face = 0;
std::vector< int > index_e = AMCAX::SubD::MeshTool::FaceEdgeIndexs(mesh, face);
 
// Fill a hole with input edge
AMCAX::SubD::MeshFillHole::FillSingleHole(mesh, index_e[1]);

Note: The input edge ID can be any edge ID of the hole.

Fill all holes in PolyMesh

AMCAX::Frame3 frame;
double dx = 10.;// The size in x direction
double dy = 10.; // The size in y direction
double dz = 10.;// The size in z direction
size_t segX = 10.;// The number of segments in x direction
size_t segY = 10.;// The number of segments in y direction
size_t segZ = 10.;// The number of segments in z direction
 
// Construct a cube
AMCAX::SubD::MeshMakeCube mkCube(frame, dx, dy, dz, segX, segY, segZ);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCube.BuildMesh();
 
// Delete given faces
std::vector<int> face_id = { 1,3, 4 };
AMCAX::SubD::MeshReduce::DeleteFaces(mesh, face_id);
 
// Fill all holes in PolyMesh
AMCAX::SubD::MeshFillHole::FillAllHole(mesh);

Mesh Subdivision

Mesh subdivision includes two types: Catmull-Clark subdivision and Loop subdivision. They will be introduced one by one below.

Catmull-Clark Subdivision

Catmull-Clark subdivision supports arbitrary meshes.

double radius = 1.;
double height = 1.;
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::SubD::MeshMakeCone mkCone(radius, height, isBottom, rseg, vseg);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCone.BuildMesh();
 
// Do Catmull-Clark Subdivision for input mesh
size_t sumTime = 3;
AMCAX::SubD::MeshSubdivideHE::CatmullClark(mesh, sumTime);

To improve subdivision efficiency, the kernel provides AMCAX::SubD::MeshSubdivideRenderCC (for all-quad meshes). Its results are the same as Catmull-Clark subdivision results, with the same number of vertices/faces, but different order, so they cannot be compared. Note: An all-quad mesh can be obtained by one subdivision AMCAX::SubD::MeshSubdivideHE::CatmullClark(mesh, 1).

double radius = 1.;
double height = 1.;
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::SubD::MeshMakeCone mkCone(radius, height, isBottom, rseg, vseg);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCone.BuildMesh();
 
// Do Catmull-Clark subdivision for input mesh
size_t sumTime = 1;
AMCAX::SubD::MeshSubdivideHE::CatmullClark(mesh, sumTime);
 
// Do Catmull-Clark subdivision for input mesh
AMCAX::SubD::MeshSubdivideRenderCC subdivide;
size_t sumTime2 = 3;
subdivide.DoCatmullClark(mesh, sumTime2);

Loop Subdivision

Loop subdivision only supports triangle meshes (an all-triangle mesh can be obtained by triangulation AMCAX::SubD::MeshTool::MeshTriangles).

double radius = 1.;
double height = 1.;
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::SubD::MeshMakeCone mkCone(radius, height, isBottom, rseg, vseg);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCone.BuildMesh();
 
// Make a mesh to triangular mesh
AMCAX::SubD::MeshTool::MeshTriangles(mesh);
 
// Do Loop subdivision for input mesh
size_t sumTime = 3;
AMCAX::SubD::MeshSubdivideHE::Loop(mesh, sumTime);

To improve subdivision efficiency, the kernel provides AMCAX::SubD::MeshSubdivideRenderLoop (for all-triangle meshes). Its results are the same as Loop subdivision results, with the same number of vertices/faces, but different order, so they cannot be compared.

double radius = 1.;
double height = 1.;
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::SubD::MeshMakeCone mkCone(radius, height, isBottom, rseg, vseg);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCone.BuildMesh();
 
// Make a mesh to triangular mesh
AMCAX::SubD::MeshTool::MeshTriangles(mesh);
 
// Do Loop subdivision for input mesh
size_t sumTime = 3;
AMCAX::SubD::MeshSubdivideRenderLoop subloop;
subloop.DoLoop(mesh, sumTime);

Import and Export

Import

// OBJ
AMCAX::SubD::PolyMesh* mesh1 = nullptr;
std::string fileNameOBJ = "1.obj";
AMCAX::SubD::PolyMeshIO::LoadMesh(fileNameOBJ, mesh1);
 
// OFF
AMCAX::SubD::PolyMesh* mesh2 = nullptr;
std::string fileNameOFF = "2.off";
AMCAX::SubD::PolyMeshIO::LoadMesh(fileNameOFF, mesh2);

Export

AMCAX::Frame3 frame;
double dx = 10.;// The size in x direction
double dy = 10.; // The size in y direction
double dz = 10.;// The size in z direction
size_t segX = 10.;// The number of segments in x direction
size_t segY = 10.;// The number of segments in y direction
size_t segZ = 10.;// The number of segments in z direction
 
// Construct a cube
AMCAX::SubD::MeshMakeCube mkCube(frame, dx, dy, dz, segX, segY, segZ);
 
// Build and get the result PolyMesh
AMCAX::SubD::PolyMesh* mesh = mkCube.BuildMesh();
 
// OBJ
std::string fileNameOBJ = "sampleResult.obj";
AMCAX::SubD::PolyMeshIO::WriteMesh(fileNameOBJ, mesh);
 
// OFF
std::string fileNameOFF = "sampleResult.off";
AMCAX::SubD::PolyMeshIO::WriteMesh(fileNameOFF, mesh);