#include <opennurbs_mesh.h>
 | 
| bool  | ComputeFaceNormal (const ON_3dPoint *dV, ON_3dVector &FN) const | 
|   | Compute the face normal  More...
  | 
|   | 
| bool  | ComputeFaceNormal (const ON_3fPoint *fV, ON_3dVector &FN) const | 
|   | 
| bool  | ComputeFaceNormal (const class ON_3dPointListRef &vertex_list, ON_3dVector &FN) const | 
|   | 
| void  | Flip () | 
|   | Reverses the order of the vertices in v[]. vi[0] is not changed.  More...
  | 
|   | 
| unsigned int  | GetCornerNormals (const class ON_3dPointListRef &vertex_list, ON_3dVector corner_normals[4]) const | 
|   | Get corner normals.  More...
  | 
|   | 
| bool  | GetPlaneEquation (const class ON_3dPointListRef &vertex_list, ON_PlaneEquation &face_plane_equation) const | 
|   | 
| bool  | IsPlanar (double planar_tolerance, double angle_tolerance_radians, const class ON_3dPointListRef &vertex_list, ON_PlaneEquation *face_plane_equation) const | 
|   | 
| bool  | IsQuad () const | 
|   | 
| bool  | IsTriangle () const | 
|   | 
| bool  | IsValid (int mesh_vertex_count) const | 
|   | Determine if a face is valid by checking that the vertices are distinct.  More...
  | 
|   | 
| bool  | IsValid (unsigned int mesh_vertex_count) const | 
|   | 
| bool  | IsValid (int mesh_vertex_count, const ON_3fPoint *V) const | 
|   | 
| bool  | IsValid (int mesh_vertex_count, const ON_3dPoint *V) const | 
|   | 
| bool  | Repair (int mesh_vertex_count) | 
|   | If IsValid() returns false, then you can use Repair() to attempt to create a valid triangle.  More...
  | 
|   | 
| bool  | Repair (int mesh_vertex_count, const ON_3fPoint *V) | 
|   | 
| bool  | Repair (int mesh_vertex_count, const ON_3dPoint *V) | 
|   | 
◆ ComputeFaceNormal() [1/3]
Compute the face normal 
- Parameters
 - 
  
    | dV | [in] double precision vertex array for the mesh | 
    | fV | [in] float precision vertex array for the mesh | 
    | FN | [out] face normal | 
  
   
- Returns
 - true if FN is valid. 
 
 
 
◆ ComputeFaceNormal() [2/3]
◆ ComputeFaceNormal() [3/3]
◆ Flip()
      
        
          | void ON_MeshFace::Flip  | 
          ( | 
           | ) | 
           | 
        
      
 
Reverses the order of the vertices in v[]. vi[0] is not changed. 
 
 
◆ GetCornerNormals()
Get corner normals. 
- Parameters
 - 
  
    | vertex_list | [in] corner_normals[4] - [out] For a triangle, all values are identical. If a corner normal cannot be calculated, ON_3dVector::UnsetVector is returned. | 
  
   
- Returns
 - Number of corner normals that are valid. 
 
 
 
◆ GetPlaneEquation()
◆ IsPlanar()
      
        
          | bool ON_MeshFace::IsPlanar  | 
          ( | 
          double  | 
          planar_tolerance,  | 
        
        
           | 
           | 
          double  | 
          angle_tolerance_radians,  | 
        
        
           | 
           | 
          const class ON_3dPointListRef &  | 
          vertex_list,  | 
        
        
           | 
           | 
          ON_PlaneEquation *  | 
          face_plane_equation  | 
        
        
           | 
          ) | 
           |  const | 
        
      
 
- Parameters
 - 
  
    | planar_tolerance | [in] If planar_tolerance >= 0 and (maximum plane equation value - minimum plane equation value) > planar_tolerance, then false is returned. | 
    | angle_tolerance_radians | [in] If angle_tolerance_radians >= 0.0 and the angle between opposite corner normals is > angle_tolerance_radians, then false is returned. A corner normal is the normal to the triangle formed by two adjacent edges and the diagonal connecting their endpoints. A quad has four corner normals. Passing in ON_PI/2 is a good way will result in false being returned for non-convex quads | 
    | face_plane_equation | [out] If not null, the equation used to test planarity is returned here. | 
  
   
- Returns
 - True if the face is planar 
 
 
 
◆ IsQuad()
      
        
          | bool ON_MeshFace::IsQuad  | 
          ( | 
           | ) | 
           const | 
        
      
 
- Returns
 - True if vi[2] != vi[3]; 
 
Assumes the face is valid. 
 
 
◆ IsTriangle()
      
        
          | bool ON_MeshFace::IsTriangle  | 
          ( | 
           | ) | 
           const | 
        
      
 
- Returns
 - True if vi[2] == vi[3]; 
 
Assumes the face is valid. 
 
 
◆ IsValid() [1/4]
      
        
          | bool ON_MeshFace::IsValid  | 
          ( | 
          int  | 
          mesh_vertex_count | ) | 
           const | 
        
      
 
Determine if a face is valid by checking that the vertices are distinct. 
- Parameters
 - 
  
    | mesh_vertex_count | [in] number of vertices in the mesh | 
    | V | [in] optional array of mesh_vertex_count vertex locations. | 
  
   
- Returns
 - true The face is valid. false The face is not valid. It may be possible to repair the face by calling ON_MeshFace::Repair(). 
 
 
 
◆ IsValid() [2/4]
      
        
          | bool ON_MeshFace::IsValid  | 
          ( | 
          unsigned int  | 
          mesh_vertex_count | ) | 
           const | 
        
      
 
 
◆ IsValid() [3/4]
      
        
          | bool ON_MeshFace::IsValid  | 
          ( | 
          int  | 
          mesh_vertex_count,  | 
        
        
           | 
           | 
          const ON_3fPoint *  | 
          V  | 
        
        
           | 
          ) | 
           |  const | 
        
      
 
 
◆ IsValid() [4/4]
      
        
          | bool ON_MeshFace::IsValid  | 
          ( | 
          int  | 
          mesh_vertex_count,  | 
        
        
           | 
           | 
          const ON_3dPoint *  | 
          V  | 
        
        
           | 
          ) | 
           |  const | 
        
      
 
 
◆ Repair() [1/3]
      
        
          | bool ON_MeshFace::Repair  | 
          ( | 
          int  | 
          mesh_vertex_count | ) | 
           | 
        
      
 
If IsValid() returns false, then you can use Repair() to attempt to create a valid triangle. 
- Parameters
 - 
  
    | mesh_vertex_count | [in] number of vertices in the mesh | 
    | V | [in] optional array of mesh_vertex_count vertex locations. | 
  
   
- Returns
 - true repair was successful and v[0], v[1], vi[2] have distinct valid values and v[2] == v[3]. false this face's vi[] values cannot be repaired 
 
 
 
◆ Repair() [2/3]
      
        
          | bool ON_MeshFace::Repair  | 
          ( | 
          int  | 
          mesh_vertex_count,  | 
        
        
           | 
           | 
          const ON_3fPoint *  | 
          V  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
◆ Repair() [3/3]
      
        
          | bool ON_MeshFace::Repair  | 
          ( | 
          int  | 
          mesh_vertex_count,  | 
        
        
           | 
           | 
          const ON_3dPoint *  | 
          V  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
◆ UnsetMeshFace
◆ vi