TetGen-1.5.1/tetgen.cxx

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// TetGen                                                                    //
//                                                                           //
// A Quality Tetrahedral Mesh Generator and A 3D Delaunay Triangulator       //
//                                                                           //
// Version 1.5                                                               //
// August 18, 2018                                                           //
//                                                                           //
// Copyright (C) 2002--2018                                                  //
//                                                                           //
// TetGen is freely available through the website: http://www.tetgen.org.    //
//   It may be copied, modified, and redistributed for non-commercial use.   //
//   Please consult the file LICENSE for the detailed copyright notices.     //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include "tetgen.h"

//// io_cxx ///////////////////////////////////////////////////////////////////
////                                                                       ////
////                                                                       ////

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// load_node_call()    Read a list of points from a file.                    //
//                                                                           //
// 'infile' is the file handle contains the node list.  It may point to a    //
// .node, or .poly or .smesh file. 'markers' indicates each node contains an //
// additional marker (integer) or not. 'uvflag' indicates each node contains //
// u,v coordinates or not. It is reuqired by a PSC. 'infilename' is the name //
// of the file being read,  it is only used in error messages.               //
//                                                                           //
// The 'firstnumber' (0 or 1) is automatically determined by the number of   //
// the first index of the first point.                                       //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenio::load_node_call(FILE* infile, int markers, int uvflag, char* infilename) {
    char inputline[INPUTLINESIZE];
    char* stringptr;
    REAL x, y, z, attrib;
    int firstnode, currentmarker;
    int index, attribindex;
    int i, j;

    // Initialize 'pointlist', 'pointattributelist', and 'pointmarkerlist'.
    pointlist = new REAL[numberofpoints * 3];
    if (pointlist == (REAL*)NULL) {
        terminatetetgen(NULL, 1);
    }
    if (numberofpointattributes > 0) {
        pointattributelist = new REAL[numberofpoints * numberofpointattributes];
        if (pointattributelist == (REAL*)NULL) {
            terminatetetgen(NULL, 1);
        }
    }
    if (markers) {
        pointmarkerlist = new int[numberofpoints];
        if (pointmarkerlist == (int*)NULL) {
            terminatetetgen(NULL, 1);
        }
    }
    if (uvflag) {
        pointparamlist = new pointparam[numberofpoints];
        if (pointparamlist == NULL) {
            terminatetetgen(NULL, 1);
        }
    }

    // Read the point section.
    index = 0;
    attribindex = 0;
    for (i = 0; i < numberofpoints; i++) {
        stringptr = readnumberline(inputline, infile, infilename);
        if (useindex) {
            if (i == 0) {
                firstnode = (int)strtol(stringptr, &stringptr, 0);
                if ((firstnode == 0) || (firstnode == 1)) {
                    firstnumber = firstnode;
                }
            }
            stringptr = findnextnumber(stringptr);
        } // if (useindex)
        if (*stringptr == '\0') {
            printf("Error:  Point %d has no x coordinate.\n", firstnumber + i);
            break;
        }
        x = (REAL)strtod(stringptr, &stringptr);
        stringptr = findnextnumber(stringptr);
        if (*stringptr == '\0') {
            printf("Error:  Point %d has no y coordinate.\n", firstnumber + i);
            break;
        }
        y = (REAL)strtod(stringptr, &stringptr);
        if (mesh_dim == 3) {
            stringptr = findnextnumber(stringptr);
            if (*stringptr == '\0') {
                printf("Error:  Point %d has no z coordinate.\n", firstnumber + i);
                break;
            }
            z = (REAL)strtod(stringptr, &stringptr);
        } else {
            z = 0.0; // mesh_dim == 2;
        }
        pointlist[index++] = x;
        pointlist[index++] = y;
        pointlist[index++] = z;
        // Read the point attributes.
        for (j = 0; j < numberofpointattributes; j++) {
            stringptr = findnextnumber(stringptr);
            if (*stringptr == '\0') {
                attrib = 0.0;
            } else {
                attrib = (REAL)strtod(stringptr, &stringptr);
            }
            pointattributelist[attribindex++] = attrib;
        }
        if (markers) {
            // Read a point marker.
            stringptr = findnextnumber(stringptr);
            if (*stringptr == '\0') {
                currentmarker = 0;
            } else {
                currentmarker = (int)strtol(stringptr, &stringptr, 0);
            }
            pointmarkerlist[i] = currentmarker;
        }
        if (uvflag) {
            // Read point paramteters.
            stringptr = findnextnumber(stringptr);
            if (*stringptr == '\0') {
                printf("Error:  Point %d has no uv[0].\n", firstnumber + i);
                break;
            }
            pointparamlist[i].uv[0] = (REAL)strtod(stringptr, &stringptr);
            stringptr = findnextnumber(stringptr);
            if (*stringptr == '\0') {
                printf("Error:  Point %d has no uv[1].\n", firstnumber + i);
                break;
            }
            pointparamlist[i].uv[1] = (REAL)strtod(stringptr, &stringptr);
            stringptr = findnextnumber(stringptr);
            if (*stringptr == '\0') {
                printf("Error:  Point %d has no tag.\n", firstnumber + i);
                break;
            }
            pointparamlist[i].tag = (int)strtol(stringptr, &stringptr, 0);
            stringptr = findnextnumber(stringptr);
            if (*stringptr == '\0') {
                printf("Error:  Point %d has no type.\n", firstnumber + i);
                break;
            }
            pointparamlist[i].type = (int)strtol(stringptr, &stringptr, 0);
            if ((pointparamlist[i].type < 0) || (pointparamlist[i].type > 2)) {
                printf("Error:  Point %d has an invalid type.\n", firstnumber + i);
                break;
            }
        }
    }
    if (i < numberofpoints) {
        // Failed to read points due to some error.
        delete[] pointlist;
        pointlist = (REAL*)NULL;
        if (markers) {
            delete[] pointmarkerlist;
            pointmarkerlist = (int*)NULL;
        }
        if (numberofpointattributes > 0) {
            delete[] pointattributelist;
            pointattributelist = (REAL*)NULL;
        }
        if (uvflag) {
            delete[] pointparamlist;
            pointparamlist = NULL;
        }
        numberofpoints = 0;
        return false;
    }
    return true;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// load_node()    Load a list of points from a .node file.                   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenio::load_node(char* filebasename) {
    FILE* infile;
    char innodefilename[FILENAMESIZE];
    char inputline[INPUTLINESIZE];
    char* stringptr;
    bool okflag;
    int markers;
    int uvflag; // for psc input.

    // Assembling the actual file names we want to open.
    strcpy(innodefilename, filebasename);
    strcat(innodefilename, ".node");

    // Try to open a .node file.
    infile = fopen(innodefilename, "r");
    if (infile == (FILE*)NULL) {
        printf("  Cannot access file %s.\n", innodefilename);
        return false;
    }
    printf("Opening %s.\n", innodefilename);

    // Set initial flags.
    mesh_dim = 3;
    numberofpointattributes = 0; // no point attribute.
    markers = 0;                 // no boundary marker.
    uvflag = 0;                  // no uv parameters (required by a PSC).

    // Read the first line of the file.
    stringptr = readnumberline(inputline, infile, innodefilename);
    // Does this file contain an index column?
    stringptr = strstr(inputline, "rbox");
    if (stringptr == NULL) {
        // Read number of points, number of dimensions, number of point
        //   attributes, and number of boundary markers.
        stringptr = inputline;
        numberofpoints = (int)strtol(stringptr, &stringptr, 0);
        stringptr = findnextnumber(stringptr);
        if (*stringptr != '\0') {
            mesh_dim = (int)strtol(stringptr, &stringptr, 0);
        }
        stringptr = findnextnumber(stringptr);
        if (*stringptr != '\0') {
            numberofpointattributes = (int)strtol(stringptr, &stringptr, 0);
        }
        stringptr = findnextnumber(stringptr);
        if (*stringptr != '\0') {
            markers = (int)strtol(stringptr, &stringptr, 0);
        }
        stringptr = findnextnumber(stringptr);
        if (*stringptr != '\0') {
            uvflag = (int)strtol(stringptr, &stringptr, 0);
        }
    } else {
        // It is a rbox (qhull) input file.
        stringptr = inputline;
        // Get the dimension.
        mesh_dim = (int)strtol(stringptr, &stringptr, 0);
        // Get the number of points.
        stringptr = readnumberline(inputline, infile, innodefilename);
        numberofpoints = (int)strtol(stringptr, &stringptr, 0);
        // There is no index column.
        useindex = 0;
    }

    // Load the list of nodes.
    okflag = load_node_call(infile, markers, uvflag, innodefilename);

    fclose(infile);
    return okflag;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// load_edge()    Load a list of edges from a .edge file.                    //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenio::load_edge(char* filebasename) {
    FILE* infile;
    char inedgefilename[FILENAMESIZE];
    char inputline[INPUTLINESIZE];
    char* stringptr;
    int markers, corner;
    int index;
    int i, j;

    strcpy(inedgefilename, filebasename);
    strcat(inedgefilename, ".edge");

    infile = fopen(inedgefilename, "r");
    if (infile != (FILE*)NULL) {
        printf("Opening %s.\n", inedgefilename);
    } else {
        // printf("  Cannot access file %s.\n", inedgefilename);
        return false;
    }

    // Read number of boundary edges.
    stringptr = readnumberline(inputline, infile, inedgefilename);
    numberofedges = (int)strtol(stringptr, &stringptr, 0);
    if (numberofedges > 0) {
        edgelist = new int[numberofedges * 2];
        if (edgelist == (int*)NULL) {
            terminatetetgen(NULL, 1);
        }
        stringptr = findnextnumber(stringptr);
        if (*stringptr == '\0') {
            markers = 0; // Default value.
        } else {
            markers = (int)strtol(stringptr, &stringptr, 0);
        }
        if (markers > 0) {
            edgemarkerlist = new int[numberofedges];
        }
    }

    // Read the list of edges.
    index = 0;
    for (i = 0; i < numberofedges; i++) {
        // Read edge index and the edge's two endpoints.
        stringptr = readnumberline(inputline, infile, inedgefilename);
        for (j = 0; j < 2; j++) {
            stringptr = findnextnumber(stringptr);
            if (*stringptr == '\0') {
                printf("Error:  Edge %d is missing vertex %d in %s.\n", i + firstnumber, j + 1,
                       inedgefilename);
                terminatetetgen(NULL, 1);
            }
            corner = (int)strtol(stringptr, &stringptr, 0);
            if (corner < firstnumber || corner >= numberofpoints + firstnumber) {
                printf("Error:  Edge %d has an invalid vertex index.\n", i + firstnumber);
                terminatetetgen(NULL, 1);
            }
            edgelist[index++] = corner;
        }
        if (numberofcorners == 10) {
            // Skip an extra vertex (generated by a previous -o2 option).
            stringptr = findnextnumber(stringptr);
        }
        // Read the edge marker if it has.
        if (markers) {
            stringptr = findnextnumber(stringptr);
            edgemarkerlist[i] = (int)strtol(stringptr, &stringptr, 0);
        }
    }

    fclose(infile);
    return true;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// load_face()    Load a list of faces (triangles) from a .face file.        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenio::load_face(char* filebasename) {
    FILE* infile;
    char infilename[FILENAMESIZE];
    char inputline[INPUTLINESIZE];
    char* stringptr;
    REAL attrib;
    int markers, corner;
    int index;
    int i, j;

    strcpy(infilename, filebasename);
    strcat(infilename, ".face");

    infile = fopen(infilename, "r");
    if (infile != (FILE*)NULL) {
        printf("Opening %s.\n", infilename);
    } else {
        return false;
    }

    // Read number of faces, boundary markers.
    stringptr = readnumberline(inputline, infile, infilename);
    numberoftrifaces = (int)strtol(stringptr, &stringptr, 0);
    stringptr = findnextnumber(stringptr);
    if (mesh_dim == 2) {
        // Skip a number.
        stringptr = findnextnumber(stringptr);
    }
    if (*stringptr == '\0') {
        markers = 0; // Default there is no marker per face.
    } else {
        markers = (int)strtol(stringptr, &stringptr, 0);
    }
    if (numberoftrifaces > 0) {
        trifacelist = new int[numberoftrifaces * 3];
        if (trifacelist == (int*)NULL) {
            terminatetetgen(NULL, 1);
        }
        if (markers) {
            trifacemarkerlist = new int[numberoftrifaces];
            if (trifacemarkerlist == (int*)NULL) {
                terminatetetgen(NULL, 1);
            }
        }
    }

    // Read the list of faces.
    index = 0;
    for (i = 0; i < numberoftrifaces; i++) {
        // Read face index and the face's three corners.
        stringptr = readnumberline(inputline, infile, infilename);
        for (j = 0; j < 3; j++) {
            stringptr = findnextnumber(stringptr);
            if (*stringptr == '\0') {
                printf("Error:  Face %d is missing vertex %d in %s.\n", i + firstnumber, j + 1,
                       infilename);
                terminatetetgen(NULL, 1);
            }
            corner = (int)strtol(stringptr, &stringptr, 0);
            if (corner < firstnumber || corner >= numberofpoints + firstnumber) {
                printf("Error:  Face %d has an invalid vertex index.\n", i + firstnumber);
                terminatetetgen(NULL, 1);
            }
            trifacelist[index++] = corner;
        }
        if (numberofcorners == 10) {
            // Skip 3 extra vertices (generated by a previous -o2 option).
            for (j = 0; j < 3; j++) {
                stringptr = findnextnumber(stringptr);
            }
        }
        // Read the boundary marker if it exists.
        if (markers) {
            stringptr = findnextnumber(stringptr);
            if (*stringptr == '\0') {
                attrib = 0.0;
            } else {
                attrib = (REAL)strtod(stringptr, &stringptr);
            }
            trifacemarkerlist[i] = (int)attrib;
        }
    }

    fclose(infile);

    return true;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// load_tet()    Load a list of tetrahedra from a .ele file.                 //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenio::load_tet(char* filebasename) {
    FILE* infile;
    char infilename[FILENAMESIZE];
    char inputline[INPUTLINESIZE];
    char* stringptr;
    REAL attrib;
    int corner;
    int index, attribindex;
    int i, j;

    strcpy(infilename, filebasename);
    strcat(infilename, ".ele");

    infile = fopen(infilename, "r");
    if (infile != (FILE*)NULL) {
        printf("Opening %s.\n", infilename);
    } else {
        return false;
    }

    // Read number of elements, number of corners (4 or 10), number of
    //   element attributes.
    stringptr = readnumberline(inputline, infile, infilename);
    numberoftetrahedra = (int)strtol(stringptr, &stringptr, 0);
    if (numberoftetrahedra <= 0) {
        printf("Error:  Invalid number of tetrahedra.\n");
        fclose(infile);
        return false;
    }
    stringptr = findnextnumber(stringptr);
    if (*stringptr == '\0') {
        numberofcorners = 4; // Default read 4 nodes per element.
    } else {
        numberofcorners = (int)strtol(stringptr, &stringptr, 0);
    }
    stringptr = findnextnumber(stringptr);
    if (*stringptr == '\0') {
        numberoftetrahedronattributes = 0; // Default no attribute.
    } else {
        numberoftetrahedronattributes = (int)strtol(stringptr, &stringptr, 0);
    }
    if (numberofcorners != 4 && numberofcorners != 10) {
        printf("Error:  Wrong number of corners %d (should be 4 or 10).\n", numberofcorners);
        fclose(infile);
        return false;
    }

    // Allocate memory for tetrahedra.
    tetrahedronlist = new int[numberoftetrahedra * numberofcorners];
    if (tetrahedronlist == (int*)NULL) {
        terminatetetgen(NULL, 1);
    }
    // Allocate memory for output tetrahedron attributes if necessary.
    if (numberoftetrahedronattributes > 0) {
        tetrahedronattributelist = new REAL[numberoftetrahedra * numberoftetrahedronattributes];
        if (tetrahedronattributelist == (REAL*)NULL) {
            terminatetetgen(NULL, 1);
        }
    }

    // Read the list of tetrahedra.
    index = 0;
    attribindex = 0;
    for (i = 0; i < numberoftetrahedra; i++) {
        // Read tetrahedron index and the tetrahedron's corners.
        stringptr = readnumberline(inputline, infile, infilename);
        for (j = 0; j < numberofcorners; j++) {
            stringptr = findnextnumber(stringptr);
            if (*stringptr == '\0') {
                printf("Error:  Tetrahedron %d is missing vertex %d in %s.\n", i + firstnumber,
                       j + 1, infilename);
                terminatetetgen(NULL, 1);
            }
            corner = (int)strtol(stringptr, &stringptr, 0);
            if (corner < firstnumber || corner >= numberofpoints + firstnumber) {
                printf("Error:  Tetrahedron %d has an invalid vertex index.\n", i + firstnumber);
                terminatetetgen(NULL, 1);
            }
            tetrahedronlist[index++] = corner;
        }
        // Read the tetrahedron's attributes.
        for (j = 0; j < numberoftetrahedronattributes; j++) {
            stringptr = findnextnumber(stringptr);
            if (*stringptr == '\0') {
                attrib = 0.0;
            } else {
                attrib = (REAL)strtod(stringptr, &stringptr);
            }
            tetrahedronattributelist[attribindex++] = attrib;
        }
    }

    fclose(infile);

    return true;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// load_vol()    Load a list of volume constraints from a .vol file.         //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenio::load_vol(char* filebasename) {
    FILE* infile;
    char inelefilename[FILENAMESIZE];
    char infilename[FILENAMESIZE];
    char inputline[INPUTLINESIZE];
    char* stringptr;
    REAL volume;
    int volelements;
    int i;

    strcpy(infilename, filebasename);
    strcat(infilename, ".vol");

    infile = fopen(infilename, "r");
    if (infile != (FILE*)NULL) {
        printf("Opening %s.\n", infilename);
    } else {
        return false;
    }

    // Read number of tetrahedra.
    stringptr = readnumberline(inputline, infile, infilename);
    volelements = (int)strtol(stringptr, &stringptr, 0);
    if (volelements != numberoftetrahedra) {
        strcpy(inelefilename, filebasename);
        strcat(infilename, ".ele");
        printf("Warning:  %s and %s disagree on number of tetrahedra.\n", inelefilename,
               infilename);
        fclose(infile);
        return false;
    }

    tetrahedronvolumelist = new REAL[volelements];
    if (tetrahedronvolumelist == (REAL*)NULL) {
        terminatetetgen(NULL, 1);
    }

    // Read the list of volume constraints.
    for (i = 0; i < volelements; i++) {
        stringptr = readnumberline(inputline, infile, infilename);
        stringptr = findnextnumber(stringptr);
        if (*stringptr == '\0') {
            volume = -1.0; // No constraint on this tetrahedron.
        } else {
            volume = (REAL)strtod(stringptr, &stringptr);
        }
        tetrahedronvolumelist[i] = volume;
    }

    fclose(infile);

    return true;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// load_var()    Load constraints applied on facets, segments, and nodes     //
//               from a .var file.                                           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenio::load_var(char* filebasename) {
    FILE* infile;
    char varfilename[FILENAMESIZE];
    char inputline[INPUTLINESIZE];
    char* stringptr;
    int index;
    int i;

    // Variant constraints are saved in file "filename.var".
    strcpy(varfilename, filebasename);
    strcat(varfilename, ".var");
    infile = fopen(varfilename, "r");
    if (infile != (FILE*)NULL) {
        printf("Opening %s.\n", varfilename);
    } else {
        return false;
    }

    // Read the facet constraint section.
    stringptr = readnumberline(inputline, infile, varfilename);
    if (stringptr == NULL) {
        // No region list, return.
        fclose(infile);
        return true;
    }
    if (*stringptr != '\0') {
        numberoffacetconstraints = (int)strtol(stringptr, &stringptr, 0);
    } else {
        numberoffacetconstraints = 0;
    }
    if (numberoffacetconstraints > 0) {
        // Initialize 'facetconstraintlist'.
        facetconstraintlist = new REAL[numberoffacetconstraints * 2];
        index = 0;
        for (i = 0; i < numberoffacetconstraints; i++) {
            stringptr = readnumberline(inputline, infile, varfilename);
            stringptr = findnextnumber(stringptr);
            if (*stringptr == '\0') {
                printf("Error:  facet constraint %d has no facet marker.\n", firstnumber + i);
                break;
            } else {
                facetconstraintlist[index++] = (REAL)strtod(stringptr, &stringptr);
            }
            stringptr = findnextnumber(stringptr);
            if (*stringptr == '\0') {
                printf("Error:  facet constraint %d has no maximum area bound.\n", firstnumber + i);
                break;
            } else {
                facetconstraintlist[index++] = (REAL)strtod(stringptr, &stringptr);
            }
        }
        if (i < numberoffacetconstraints) {
            // This must be caused by an error.
            fclose(infile);
            return false;
        }
    }

    // Read the segment constraint section.
    stringptr = readnumberline(inputline, infile, varfilename);
    if (stringptr == NULL) {
        // No segment list, return.
        fclose(infile);
        return true;
    }
    if (*stringptr != '\0') {
        numberofsegmentconstraints = (int)strtol(stringptr, &stringptr, 0);
    } else {
        numberofsegmentconstraints = 0;
    }
    if (numberofsegmentconstraints > 0) {
        // Initialize 'segmentconstraintlist'.
        segmentconstraintlist = new REAL[numberofsegmentconstraints * 3];
        index = 0;
        for (i = 0; i < numberofsegmentconstraints; i++) {
            stringptr = readnumberline(inputline, infile, varfilename);
            stringptr = findnextnumber(stringptr);
            if (*stringptr == '\0') {
                printf("Error:  segment constraint %d has no frist endpoint.\n", firstnumber + i);
                break;
            } else {
                segmentconstraintlist[index++] = (REAL)strtod(stringptr, &stringptr);
            }
            stringptr = findnextnumber(stringptr);
            if (*stringptr == '\0') {
                printf("Error:  segment constraint %d has no second endpoint.\n", firstnumber + i);
                break;
            } else {
                segmentconstraintlist[index++] = (REAL)strtod(stringptr, &stringptr);
            }
            stringptr = findnextnumber(stringptr);
            if (*stringptr == '\0') {
                printf("Error:  segment constraint %d has no maximum length bound.\n",
                       firstnumber + i);
                break;
            } else {
                segmentconstraintlist[index++] = (REAL)strtod(stringptr, &stringptr);
            }
        }
        if (i < numberofsegmentconstraints) {
            // This must be caused by an error.
            fclose(infile);
            return false;
        }
    }

    fclose(infile);
    return true;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// load_mtr()    Load a size specification map from a .mtr file.             //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenio::load_mtr(char* filebasename) {
    FILE* infile;
    char mtrfilename[FILENAMESIZE];
    char inputline[INPUTLINESIZE];
    char* stringptr;
    REAL mtr;
    int ptnum;
    int mtrindex;
    int i, j;

    strcpy(mtrfilename, filebasename);
    strcat(mtrfilename, ".mtr");
    infile = fopen(mtrfilename, "r");
    if (infile != (FILE*)NULL) {
        printf("Opening %s.\n", mtrfilename);
    } else {
        return false;
    }

    // Read the number of points.
    stringptr = readnumberline(inputline, infile, mtrfilename);
    ptnum = (int)strtol(stringptr, &stringptr, 0);
    if (ptnum != numberofpoints) {
        printf("  !! Point numbers are not equal. Ignored.\n");
        fclose(infile);
        return false;
    }
    // Read the number of columns (1, 3, or 6).
    stringptr = findnextnumber(stringptr); // Skip number of points.
    if (*stringptr != '\0') {
        numberofpointmtrs = (int)strtol(stringptr, &stringptr, 0);
    }
    if ((numberofpointmtrs != 1) && (numberofpointmtrs != 3) && (numberofpointmtrs != 6)) {
        // Column number doesn't match.
        numberofpointmtrs = 0;
        printf("  !! Metric size does not match (1, 3, or 6). Ignored.\n");
        fclose(infile);
        return false;
    }

    // Allocate space for pointmtrlist.
    pointmtrlist = new REAL[numberofpoints * numberofpointmtrs];
    if (pointmtrlist == (REAL*)NULL) {
        terminatetetgen(NULL, 1);
    }
    mtrindex = 0;
    for (i = 0; i < numberofpoints; i++) {
        // Read metrics.
        stringptr = readnumberline(inputline, infile, mtrfilename);
        for (j = 0; j < numberofpointmtrs; j++) {
            if (*stringptr == '\0') {
                printf("Error:  Metric %d is missing value #%d in %s.\n", i + firstnumber, j + 1,
                       mtrfilename);
                terminatetetgen(NULL, 1);
            }
            mtr = (REAL)strtod(stringptr, &stringptr);
            pointmtrlist[mtrindex++] = mtr;
            stringptr = findnextnumber(stringptr);
        }
    }

    fclose(infile);
    return true;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// load_poly()    Load a PL complex from a .poly or a .smesh file.           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenio::load_poly(char* filebasename) {
    FILE* infile;
    char inpolyfilename[FILENAMESIZE];
    char insmeshfilename[FILENAMESIZE];
    char inputline[INPUTLINESIZE];
    char *stringptr, *infilename;
    int smesh, markers, uvflag, currentmarker;
    int index;
    int i, j, k;

    // Assembling the actual file names we want to open.
    strcpy(inpolyfilename, filebasename);
    strcpy(insmeshfilename, filebasename);
    strcat(inpolyfilename, ".poly");
    strcat(insmeshfilename, ".smesh");

    // First assume it is a .poly file.
    smesh = 0;
    // Try to open a .poly file.
    infile = fopen(inpolyfilename, "r");
    if (infile == (FILE*)NULL) {
        // .poly doesn't exist! Try to open a .smesh file.
        infile = fopen(insmeshfilename, "r");
        if (infile == (FILE*)NULL) {
            printf("  Cannot access file %s and %s.\n", inpolyfilename, insmeshfilename);
            return false;
        } else {
            printf("Opening %s.\n", insmeshfilename);
            infilename = insmeshfilename;
        }
        smesh = 1;
    } else {
        printf("Opening %s.\n", inpolyfilename);
        infilename = inpolyfilename;
    }

    // Initialize the default values.
    mesh_dim = 3;                // Three-dimensional coordinates.
    numberofpointattributes = 0; // no point attribute.
    markers = 0;                 // no boundary marker.
    uvflag = 0;                  // no uv parameters (required by a PSC).

    // Read number of points, number of dimensions, number of point
    //   attributes, and number of boundary markers.
    stringptr = readnumberline(inputline, infile, infilename);
    numberofpoints = (int)strtol(stringptr, &stringptr, 0);
    stringptr = findnextnumber(stringptr);
    if (*stringptr != '\0') {
        mesh_dim = (int)strtol(stringptr, &stringptr, 0);
    }
    stringptr = findnextnumber(stringptr);
    if (*stringptr != '\0') {
        numberofpointattributes = (int)strtol(stringptr, &stringptr, 0);
    }
    stringptr = findnextnumber(stringptr);
    if (*stringptr != '\0') {
        markers = (int)strtol(stringptr, &stringptr, 0);
    }
    if (*stringptr != '\0') {
        uvflag = (int)strtol(stringptr, &stringptr, 0);
    }

    if (numberofpoints > 0) {
        // Load the list of nodes.
        if (!load_node_call(infile, markers, uvflag, infilename)) {
            fclose(infile);
            return false;
        }
    } else {
        // If the .poly or .smesh file claims there are zero points, that
        //   means the points should be read from a separate .node file.
        if (!load_node(filebasename)) {
            fclose(infile);
            return false;
        }
    }

    if ((mesh_dim != 3) && (mesh_dim != 2)) {
        printf("Input error:  TetGen only works for 2D & 3D point sets.\n");
        fclose(infile);
        return false;
    }
    if (numberofpoints < (mesh_dim + 1)) {
        printf("Input error:  TetGen needs at least %d points.\n", mesh_dim + 1);
        fclose(infile);
        return false;
    }

    facet* f;
    polygon* p;

    if (mesh_dim == 3) {

        // Read number of facets and number of boundary markers.
        stringptr = readnumberline(inputline, infile, infilename);
        if (stringptr == NULL) {
            // No facet list, return.
            fclose(infile);
            return true;
        }
        numberoffacets = (int)strtol(stringptr, &stringptr, 0);
        if (numberoffacets <= 0) {
            // No facet list, return.
            fclose(infile);
            return true;
        }
        stringptr = findnextnumber(stringptr);
        if (*stringptr == '\0') {
            markers = 0; // no boundary marker.
        } else {
            markers = (int)strtol(stringptr, &stringptr, 0);
        }

        // Initialize the 'facetlist', 'facetmarkerlist'.
        facetlist = new facet[numberoffacets];
        if (markers == 1) {
            facetmarkerlist = new int[numberoffacets];
        }

        // Read data into 'facetlist', 'facetmarkerlist'.
        if (smesh == 0) {
            // Facets are in .poly file format.
            for (i = 1; i <= numberoffacets; i++) {
                f = &(facetlist[i - 1]);
                init(f);
                f->numberofholes = 0;
                currentmarker = 0;
                // Read number of polygons, number of holes, and a boundary marker.
                stringptr = readnumberline(inputline, infile, infilename);
                f->numberofpolygons = (int)strtol(stringptr, &stringptr, 0);
                stringptr = findnextnumber(stringptr);
                if (*stringptr != '\0') {
                    f->numberofholes = (int)strtol(stringptr, &stringptr, 0);
                    if (markers == 1) {
                        stringptr = findnextnumber(stringptr);
                        if (*stringptr != '\0') {
                            currentmarker = (int)strtol(stringptr, &stringptr, 0);
                        }
                    }
                }
                // Initialize facetmarker if it needs.
                if (markers == 1) {
                    facetmarkerlist[i - 1] = currentmarker;
                }
                // Each facet should has at least one polygon.
                if (f->numberofpolygons <= 0) {
                    printf("Error:  Wrong number of polygon in %d facet.\n", i);
                    break;
                }
                // Initialize the 'f->polygonlist'.
                f->polygonlist = new polygon[f->numberofpolygons];
                // Go through all polygons, read in their vertices.
                for (j = 1; j <= f->numberofpolygons; j++) {
                    p = &(f->polygonlist[j - 1]);
                    init(p);
                    // Read number of vertices of this polygon.
                    stringptr = readnumberline(inputline, infile, infilename);
                    p->numberofvertices = (int)strtol(stringptr, &stringptr, 0);
                    if (p->numberofvertices < 1) {
                        printf("Error:  Wrong polygon %d in facet %d\n", j, i);
                        break;
                    }
                    // Initialize 'p->vertexlist'.
                    p->vertexlist = new int[p->numberofvertices];
                    // Read all vertices of this polygon.
                    for (k = 1; k <= p->numberofvertices; k++) {
                        stringptr = findnextnumber(stringptr);
                        if (*stringptr == '\0') {
                            // Try to load another non-empty line and continue to read the
                            //   rest of vertices.
                            stringptr = readnumberline(inputline, infile, infilename);
                            if (*stringptr == '\0') {
                                printf("Error: Missing %d endpoints of polygon %d in facet %d",
                                       p->numberofvertices - k, j, i);
                                break;
                            }
                        }
                        p->vertexlist[k - 1] = (int)strtol(stringptr, &stringptr, 0);
                    }
                }
                if (j <= f->numberofpolygons) {
                    // This must be caused by an error. However, there're j - 1
                    //   polygons have been read. Reset the 'f->numberofpolygon'.
                    if (j == 1) {
                        // This is the first polygon.
                        delete[] f->polygonlist;
                    }
                    f->numberofpolygons = j - 1;
                    // No hole will be read even it exists.
                    f->numberofholes = 0;
                    break;
                }
                // If this facet has hole pints defined, read them.
                if (f->numberofholes > 0) {
                    // Initialize 'f->holelist'.
                    f->holelist = new REAL[f->numberofholes * 3];
                    // Read the holes' coordinates.
                    index = 0;
                    for (j = 1; j <= f->numberofholes; j++) {
                        stringptr = readnumberline(inputline, infile, infilename);
                        for (k = 1; k <= 3; k++) {
                            stringptr = findnextnumber(stringptr);
                            if (*stringptr == '\0') {
                                printf("Error:  Hole %d in facet %d has no coordinates", j, i);
                                break;
                            }
                            f->holelist[index++] = (REAL)strtod(stringptr, &stringptr);
                        }
                        if (k <= 3) {
                            // This must be caused by an error.
                            break;
                        }
                    }
                    if (j <= f->numberofholes) {
                        // This must be caused by an error.
                        break;
                    }
                }
            }
            if (i <= numberoffacets) {
                // This must be caused by an error.
                numberoffacets = i - 1;
                fclose(infile);
                return false;
            }
        } else { // poly == 0
            // Read the facets from a .smesh file.
            for (i = 1; i <= numberoffacets; i++) {
                f = &(facetlist[i - 1]);
                init(f);
                // Initialize 'f->facetlist'. In a .smesh file, each facetlist only
                //   contains exactly one polygon, no hole.
                f->numberofpolygons = 1;
                f->polygonlist = new polygon[f->numberofpolygons];
                p = &(f->polygonlist[0]);
                init(p);
                // Read number of vertices of this polygon.
                stringptr = readnumberline(inputline, infile, insmeshfilename);
                p->numberofvertices = (int)strtol(stringptr, &stringptr, 0);
                if (p->numberofvertices < 1) {
                    printf("Error:  Wrong number of vertex in facet %d\n", i);
                    break;
                }
                // Initialize 'p->vertexlist'.
                p->vertexlist = new int[p->numberofvertices];
                for (k = 1; k <= p->numberofvertices; k++) {
                    stringptr = findnextnumber(stringptr);
                    if (*stringptr == '\0') {
                        // Try to load another non-empty line and continue to read the
                        //   rest of vertices.
                        stringptr = readnumberline(inputline, infile, infilename);
                        if (*stringptr == '\0') {
                            printf("Error:  Missing %d endpoints in facet %d",
                                   p->numberofvertices - k, i);
                            break;
                        }
                    }
                    p->vertexlist[k - 1] = (int)strtol(stringptr, &stringptr, 0);
                }
                if (k <= p->numberofvertices) {
                    // This must be caused by an error.
                    break;
                }
                // Read facet's boundary marker at last.
                if (markers == 1) {
                    stringptr = findnextnumber(stringptr);
                    if (*stringptr == '\0') {
                        currentmarker = 0;
                    } else {
                        currentmarker = (int)strtol(stringptr, &stringptr, 0);
                    }
                    facetmarkerlist[i - 1] = currentmarker;
                }
            }
            if (i <= numberoffacets) {
                // This must be caused by an error.
                numberoffacets = i - 1;
                fclose(infile);
                return false;
            }
        }

        // Read the hole section.
        stringptr = readnumberline(inputline, infile, infilename);
        if (stringptr == NULL) {
            // No hole list, return.
            fclose(infile);
            return true;
        }
        if (*stringptr != '\0') {
            numberofholes = (int)strtol(stringptr, &stringptr, 0);
        } else {
            numberofholes = 0;
        }
        if (numberofholes > 0) {
            // Initialize 'holelist'.
            holelist = new REAL[numberofholes * 3];
            for (i = 0; i < 3 * numberofholes; i += 3) {
                stringptr = readnumberline(inputline, infile, infilename);
                stringptr = findnextnumber(stringptr);
                if (*stringptr == '\0') {
                    printf("Error:  Hole %d has no x coord.\n", firstnumber + (i / 3));
                    break;
                } else {
                    holelist[i] = (REAL)strtod(stringptr, &stringptr);
                }
                stringptr = findnextnumber(stringptr);
                if (*stringptr == '\0') {
                    printf("Error:  Hole %d has no y coord.\n", firstnumber + (i / 3));
                    break;
                } else {
                    holelist[i + 1] = (REAL)strtod(stringptr, &stringptr);
                }
                stringptr = findnextnumber(stringptr);
                if (*stringptr == '\0') {
                    printf("Error:  Hole %d has no z coord.\n", firstnumber + (i / 3));
                    break;
                } else {
                    holelist[i + 2] = (REAL)strtod(stringptr, &stringptr);
                }
            }
            if (i < 3 * numberofholes) {
                // This must be caused by an error.
                fclose(infile);
                return false;
            }
        }

        // Read the region section.  The 'region' section is optional, if we
        //   don't reach the end-of-file, try read it in.
        stringptr = readnumberline(inputline, infile, NULL);
        if (stringptr != (char*)NULL && *stringptr != '\0') {
            numberofregions = (int)strtol(stringptr, &stringptr, 0);
        } else {
            numberofregions = 0;
        }
        if (numberofregions > 0) {
            // Initialize 'regionlist'.
            regionlist = new REAL[numberofregions * 5];
            index = 0;
            for (i = 0; i < numberofregions; i++) {
                stringptr = readnumberline(inputline, infile, infilename);
                stringptr = findnextnumber(stringptr);
                if (*stringptr == '\0') {
                    printf("Error:  Region %d has no x coordinate.\n", firstnumber + i);
                    break;
                } else {
                    regionlist[index++] = (REAL)strtod(stringptr, &stringptr);
                }
                stringptr = findnextnumber(stringptr);
                if (*stringptr == '\0') {
                    printf("Error:  Region %d has no y coordinate.\n", firstnumber + i);
                    break;
                } else {
                    regionlist[index++] = (REAL)strtod(stringptr, &stringptr);
                }
                stringptr = findnextnumber(stringptr);
                if (*stringptr == '\0') {
                    printf("Error:  Region %d has no z coordinate.\n", firstnumber + i);
                    break;
                } else {
                    regionlist[index++] = (REAL)strtod(stringptr, &stringptr);
                }
                stringptr = findnextnumber(stringptr);
                if (*stringptr == '\0') {
                    printf("Error:  Region %d has no region attrib.\n", firstnumber + i);
                    break;
                } else {
                    regionlist[index++] = (REAL)strtod(stringptr, &stringptr);
                }
                stringptr = findnextnumber(stringptr);
                if (*stringptr == '\0') {
                    regionlist[index] = regionlist[index - 1];
                } else {
                    regionlist[index] = (REAL)strtod(stringptr, &stringptr);
                }
                index++;
            }
            if (i < numberofregions) {
                // This must be caused by an error.
                fclose(infile);
                return false;
            }
        }
    }

    // End of reading poly/smesh file.
    fclose(infile);
    return true;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// load_off()    Load a polyhedron from a .off file.                         //
//                                                                           //
// The .off format is one of file formats of the Geomview, an interactive    //
// program for viewing and manipulating geometric objects.  More information //
// is available form: http://www.geomview.org.                               //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenio::load_off(char* filebasename) {
    FILE* fp;
    tetgenio::facet* f;
    tetgenio::polygon* p;
    char infilename[FILENAMESIZE];
    char buffer[INPUTLINESIZE];
    char* bufferp;
    double* coord;
    int nverts = 0, iverts = 0;
    int nfaces = 0, ifaces = 0;
    int nedges = 0;
    int line_count = 0, i;

    // Default, the off file's index is from '0'. We check it by remembering the
    //   smallest index we found in the file. It should be either 0 or 1.
    int smallestidx = 0;

    strncpy(infilename, filebasename, 1024 - 1);
    infilename[FILENAMESIZE - 1] = '\0';
    if (infilename[0] == '\0') {
        printf("Error:  No filename.\n");
        return false;
    }
    if (strcmp(&infilename[strlen(infilename) - 4], ".off") != 0) {
        strcat(infilename, ".off");
    }

    if (!(fp = fopen(infilename, "r"))) {
        printf("  Unable to open file %s\n", infilename);
        return false;
    }
    printf("Opening %s.\n", infilename);

    while ((bufferp = readline(buffer, fp, &line_count)) != NULL) {
        // Check section
        if (nverts == 0) {
            // Read header
            bufferp = strstr(bufferp, "OFF");
            if (bufferp != NULL) {
                // Read mesh counts
                bufferp = findnextnumber(bufferp); // Skip field "OFF".
                if (*bufferp == '\0') {
                    // Read a non-empty line.
                    bufferp = readline(buffer, fp, &line_count);
                }
                if ((sscanf(bufferp, "%d%d%d", &nverts, &nfaces, &nedges) != 3) || (nverts == 0)) {
                    printf("Syntax error reading header on line %d in file %s\n", line_count,
                           infilename);
                    fclose(fp);
                    return false;
                }
                // Allocate memory for 'tetgenio'
                if (nverts > 0) {
                    numberofpoints = nverts;
                    pointlist = new REAL[nverts * 3];
                    smallestidx = nverts + 1; // A bigger enough number.
                }
                if (nfaces > 0) {
                    numberoffacets = nfaces;
                    facetlist = new tetgenio::facet[nfaces];
                }
            }
        } else if (iverts < nverts) {
            // Read vertex coordinates
            coord = &pointlist[iverts * 3];
            for (i = 0; i < 3; i++) {
                if (*bufferp == '\0') {
                    printf("Syntax error reading vertex coords on line %d in file %s\n", line_count,
                           infilename);
                    fclose(fp);
                    return false;
                }
                coord[i] = (REAL)strtod(bufferp, &bufferp);
                bufferp = findnextnumber(bufferp);
            }
            iverts++;
        } else if (ifaces < nfaces) {
            // Get next face
            f = &facetlist[ifaces];
            init(f);
            // In .off format, each facet has one polygon, no hole.
            f->numberofpolygons = 1;
            f->polygonlist = new tetgenio::polygon[1];
            p = &f->polygonlist[0];
            init(p);
            // Read the number of vertices, it should be greater than 0.
            p->numberofvertices = (int)strtol(bufferp, &bufferp, 0);
            if (p->numberofvertices == 0) {
                printf("Syntax error reading polygon on line %d in file %s\n", line_count,
                       infilename);
                fclose(fp);
                return false;
            }
            // Allocate memory for face vertices
            p->vertexlist = new int[p->numberofvertices];
            for (i = 0; i < p->numberofvertices; i++) {
                bufferp = findnextnumber(bufferp);
                if (*bufferp == '\0') {
                    printf("Syntax error reading polygon on line %d in file %s\n", line_count,
                           infilename);
                    fclose(fp);
                    return false;
                }
                p->vertexlist[i] = (int)strtol(bufferp, &bufferp, 0);
                // Detect the smallest index.
                if (p->vertexlist[i] < smallestidx) {
                    smallestidx = p->vertexlist[i];
                }
            }
            ifaces++;
        } else {
            // Should never get here
            printf("Found extra text starting at line %d in file %s\n", line_count, infilename);
            break;
        }
    }

    // Close file
    fclose(fp);

    // Decide the firstnumber of the index.
    if (smallestidx == 0) {
        firstnumber = 0;
    } else if (smallestidx == 1) {
        firstnumber = 1;
    } else {
        printf("A wrong smallest index (%d) was detected in file %s\n", smallestidx, infilename);
        return false;
    }

    if (iverts != nverts) {
        printf("Expected %d vertices, but read only %d vertices in file %s\n", nverts, iverts,
               infilename);
        return false;
    }
    if (ifaces != nfaces) {
        printf("Expected %d faces, but read only %d faces in file %s\n", nfaces, ifaces,
               infilename);
        return false;
    }

    return true;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// load_ply()    Load a polyhedron from a .ply file.                         //
//                                                                           //
// This is a simplified version of reading .ply files, which only reads the  //
// set of vertices and the set of faces. Other informations (such as color,  //
// material, texture, etc) in .ply file are ignored. Complete routines for   //
// reading and writing ,ply files are available from: http://www.cc.gatech.  //
// edu/projects/large_models/ply.html.  Except the header section, ply file  //
// format has exactly the same format for listing vertices and polygons as   //
// off file format.                                                          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenio::load_ply(char* filebasename) {
    FILE* fp;
    tetgenio::facet* f;
    tetgenio::polygon* p;
    char infilename[FILENAMESIZE];
    char buffer[INPUTLINESIZE];
    char *bufferp, *str;
    double* coord;
    int endheader = 0, format = 0;
    int nverts = 0, iverts = 0;
    int nfaces = 0, ifaces = 0;
    int line_count = 0, i;

    // Default, the ply file's index is from '0'. We check it by remembering the
    //   smallest index we found in the file. It should be either 0 or 1.
    int smallestidx = 0;

    strncpy(infilename, filebasename, FILENAMESIZE - 1);
    infilename[FILENAMESIZE - 1] = '\0';
    if (infilename[0] == '\0') {
        printf("Error:  No filename.\n");
        return false;
    }
    if (strcmp(&infilename[strlen(infilename) - 4], ".ply") != 0) {
        strcat(infilename, ".ply");
    }

    if (!(fp = fopen(infilename, "r"))) {
        printf("Error:  Unable to open file %s\n", infilename);
        return false;
    }
    printf("Opening %s.\n", infilename);

    while ((bufferp = readline(buffer, fp, &line_count)) != NULL) {
        if (!endheader) {
            // Find if it is the keyword "end_header".
            str = strstr(bufferp, "end_header");
            // strstr() is case sensitive.
            if (!str) str = strstr(bufferp, "End_header");
            if (!str) str = strstr(bufferp, "End_Header");
            if (str) {
                // This is the end of the header section.
                endheader = 1;
                continue;
            }
            // Parse the number of vertices and the number of faces.
            if (nverts == 0 || nfaces == 0) {
                // Find if it si the keyword "element".
                str = strstr(bufferp, "element");
                if (!str) str = strstr(bufferp, "Element");
                if (str) {
                    bufferp = findnextfield(str);
                    if (*bufferp == '\0') {
                        printf("Syntax error reading element type on line%d in file %s\n",
                               line_count, infilename);
                        fclose(fp);
                        return false;
                    }
                    if (nverts == 0) {
                        // Find if it is the keyword "vertex".
                        str = strstr(bufferp, "vertex");
                        if (!str) str = strstr(bufferp, "Vertex");
                        if (str) {
                            bufferp = findnextnumber(str);
                            if (*bufferp == '\0') {
                                printf("Syntax error reading vertex number on line");
                                printf(" %d in file %s\n", line_count, infilename);
                                fclose(fp);
                                return false;
                            }
                            nverts = (int)strtol(bufferp, &bufferp, 0);
                            // Allocate memory for 'tetgenio'
                            if (nverts > 0) {
                                numberofpoints = nverts;
                                pointlist = new REAL[nverts * 3];
                                smallestidx = nverts + 1; // A big enough index.
                            }
                        }
                    }
                    if (nfaces == 0) {
                        // Find if it is the keyword "face".
                        str = strstr(bufferp, "face");
                        if (!str) str = strstr(bufferp, "Face");
                        if (str) {
                            bufferp = findnextnumber(str);
                            if (*bufferp == '\0') {
                                printf("Syntax error reading face number on line");
                                printf(" %d in file %s\n", line_count, infilename);
                                fclose(fp);
                                return false;
                            }
                            nfaces = (int)strtol(bufferp, &bufferp, 0);
                            // Allocate memory for 'tetgenio'
                            if (nfaces > 0) {
                                numberoffacets = nfaces;
                                facetlist = new tetgenio::facet[nfaces];
                            }
                        }
                    }
                } // It is not the string "element".
            }
            if (format == 0) {
                // Find the keyword "format".
                str = strstr(bufferp, "format");
                if (!str) str = strstr(bufferp, "Format");
                if (str) {
                    format = 1;
                    bufferp = findnextfield(str);
                    // Find if it is the string "ascii".
                    str = strstr(bufferp, "ascii");
                    if (!str) str = strstr(bufferp, "ASCII");
                    if (!str) {
                        printf("This routine only reads ascii format of ply files.\n");
                        printf("Hint: You can convert the binary to ascii format by\n");
                        printf("  using the provided ply tools:\n");
                        printf("  ply2ascii < %s > ascii_%s\n", infilename, infilename);
                        fclose(fp);
                        return false;
                    }
                }
            }
        } else if (iverts < nverts) {
            // Read vertex coordinates
            coord = &pointlist[iverts * 3];
            for (i = 0; i < 3; i++) {
                if (*bufferp == '\0') {
                    printf("Syntax error reading vertex coords on line %d in file %s\n", line_count,
                           infilename);
                    fclose(fp);
                    return false;
                }
                coord[i] = (REAL)strtod(bufferp, &bufferp);
                bufferp = findnextnumber(bufferp);
            }
            iverts++;
        } else if (ifaces < nfaces) {
            // Get next face
            f = &facetlist[ifaces];
            init(f);
            // In .off format, each facet has one polygon, no hole.
            f->numberofpolygons = 1;
            f->polygonlist = new tetgenio::polygon[1];
            p = &f->polygonlist[0];
            init(p);
            // Read the number of vertices, it should be greater than 0.
            p->numberofvertices = (int)strtol(bufferp, &bufferp, 0);
            if (p->numberofvertices == 0) {
                printf("Syntax error reading polygon on line %d in file %s\n", line_count,
                       infilename);
                fclose(fp);
                return false;
            }
            // Allocate memory for face vertices
            p->vertexlist = new int[p->numberofvertices];
            for (i = 0; i < p->numberofvertices; i++) {
                bufferp = findnextnumber(bufferp);
                if (*bufferp == '\0') {
                    printf("Syntax error reading polygon on line %d in file %s\n", line_count,
                           infilename);
                    fclose(fp);
                    return false;
                }
                p->vertexlist[i] = (int)strtol(bufferp, &bufferp, 0);
                if (p->vertexlist[i] < smallestidx) {
                    smallestidx = p->vertexlist[i];
                }
            }
            ifaces++;
        } else {
            // Should never get here
            printf("Found extra text starting at line %d in file %s\n", line_count, infilename);
            break;
        }
    }

    // Close file
    fclose(fp);

    // Decide the firstnumber of the index.
    if (smallestidx == 0) {
        firstnumber = 0;
    } else if (smallestidx == 1) {
        firstnumber = 1;
    } else {
        printf("A wrong smallest index (%d) was detected in file %s\n", smallestidx, infilename);
        return false;
    }

    if (iverts != nverts) {
        printf("Expected %d vertices, but read only %d vertices in file %s\n", nverts, iverts,
               infilename);
        return false;
    }
    if (ifaces != nfaces) {
        printf("Expected %d faces, but read only %d faces in file %s\n", nfaces, ifaces,
               infilename);
        return false;
    }

    return true;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// load_stl()    Load a surface mesh from a .stl file.                       //
//                                                                           //
// The .stl or stereolithography format is an ASCII or binary file used in   //
// manufacturing.  It is a list of the triangular surfaces that describe a   //
// computer generated solid model. This is the standard input for most rapid //
// prototyping machines.                                                     //
//                                                                           //
// Comment: A .stl file many contain many duplicated points.  They will be   //
// unified during the Delaunay tetrahedralization process.                   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void SwapBytes(char* array, int size, int n) {
    char* x = new char[size];
    for (int i = 0; i < n; i++) {
        char* a = &array[i * size];
        memcpy(x, a, size);
        for (int c = 0; c < size; c++)
            a[size - 1 - c] = x[c];
    }
    delete[] x;
}

bool tetgenio::load_stl(char* filebasename) {
    FILE* fp;
    tetgenmesh::arraypool* plist;
    tetgenio::facet* f;
    tetgenio::polygon* p;
    char infilename[FILENAMESIZE];
    char buffer[INPUTLINESIZE];
    char *bufferp, *str;
    double* coord;
    int solid = 0;
    int nverts = 0, iverts = 0;
    int nfaces = 0;
    int line_count = 0, i;

    strncpy(infilename, filebasename, FILENAMESIZE - 1);
    infilename[FILENAMESIZE - 1] = '\0';
    if (infilename[0] == '\0') {
        printf("Error:  No filename.\n");
        return false;
    }
    if (strcmp(&infilename[strlen(infilename) - 4], ".stl") != 0) {
        strcat(infilename, ".stl");
    }

    if (!(fp = fopen(infilename, "rb"))) {
        printf("Error:  Unable to open file %s\n", infilename);
        return false;
    }
    printf("Opening %s.\n", infilename);

    // "solid", or binary data header
    if (!fgets(buffer, sizeof(buffer), fp)) {
        fclose(fp);
        return 0;
    }
    bool binary = strncmp(buffer, "solid", 5) && strncmp(buffer, "SOLID", 5);

    // STL file has no number of points available. Use a list to read points.
    plist = new tetgenmesh::arraypool(sizeof(double) * 3, 10);

    if (!binary) {
        solid = 1;
        while ((bufferp = readline(buffer, fp, &line_count)) != NULL) {
            // The ASCII .stl file must start with the lower case keyword solid and
            //   end with endsolid.
            if (solid == 0) {
                // Read header
                bufferp = strstr(bufferp, "solid");
                if (bufferp != NULL) {
                    solid = 1;
                }
            } else {
                // We're inside the block of the solid.
                str = bufferp;
                // Is this the end of the solid.
                bufferp = strstr(bufferp, "endsolid");
                if (bufferp != NULL) {
                    solid = 0;
                } else {
                    // Read the XYZ coordinates if it is a vertex.
                    bufferp = str;
                    bufferp = strstr(bufferp, "vertex");
                    if (bufferp != NULL) {
                        plist->newindex((void**)&coord);
                        for (i = 0; i < 3; i++) {
                            bufferp = findnextnumber(bufferp);
                            if (*bufferp == '\0') {
                                printf("Syntax error reading vertex coords on line %d\n",
                                       line_count);
                                delete plist;
                                fclose(fp);
                                return false;
                            }
                            coord[i] = (REAL)strtod(bufferp, &bufferp);
                        }
                    }
                }
            }
        }
    } // if(!binary)

    else {
        rewind(fp);
        while (!feof(fp)) {
            char header[80];
            if (!fread(header, sizeof(char), 80, fp)) break;
            unsigned int nfacets = 0;
            size_t ret = fread(&nfacets, sizeof(unsigned int), 1, fp);
            bool swap = false;
            if (nfacets > 100000000) {
                // Msg::Info("Swapping bytes from binary file");
                swap = true;
                SwapBytes((char*)&nfacets, sizeof(unsigned int), 1);
            }
            if (ret && nfacets) {
                // points.resize(points.size() + 1);
                char* data = new char[nfacets * 50 * sizeof(char)];
                ret = fread(data, sizeof(char), nfacets * 50, fp);
                if (ret == nfacets * 50) {
                    for (unsigned int i = 0; i < nfacets; i++) {
                        float* xyz = (float*)&data[i * 50 * sizeof(char)];
                        if (swap) SwapBytes((char*)xyz, sizeof(float), 12);
                        for (int j = 0; j < 3; j++) {
                            // SPoint3 p(xyz[3 + 3 * j], xyz[3 + 3 * j + 1], xyz[3 + 3 * j + 2]);
                            // points.back().push_back(p);
                            // bbox += p;
                            plist->newindex((void**)&coord);
                            coord[0] = xyz[3 + 3 * j];
                            coord[1] = xyz[3 + 3 * j + 1];
                            coord[2] = xyz[3 + 3 * j + 2];
                        }
                    }
                }
                delete[] data;
            }
        } // while (!feof(fp))
    }     // binary

    fclose(fp);

    nverts = (int)plist->objects;
    // nverts should be an integer times 3 (every 3 vertices denote a face).
    if (nverts == 0 || (nverts % 3 != 0)) {
        printf("Error:  Wrong number of vertices in file %s.\n", infilename);
        delete plist;
        return false;
    }
    numberofpoints = nverts;
    pointlist = new REAL[nverts * 3];
    for (i = 0; i < nverts; i++) {
        coord = (double*)fastlookup(plist, i);
        iverts = i * 3;
        pointlist[iverts] = (REAL)coord[0];
        pointlist[iverts + 1] = (REAL)coord[1];
        pointlist[iverts + 2] = (REAL)coord[2];
    }

    nfaces = (int)(nverts / 3);
    numberoffacets = nfaces;
    facetlist = new tetgenio::facet[nfaces];

    // Default use '1' as the array starting index.
    firstnumber = 1;
    iverts = firstnumber;
    for (i = 0; i < nfaces; i++) {
        f = &facetlist[i];
        init(f);
        // In .stl format, each facet has one polygon, no hole.
        f->numberofpolygons = 1;
        f->polygonlist = new tetgenio::polygon[1];
        p = &f->polygonlist[0];
        init(p);
        // Each polygon has three vertices.
        p->numberofvertices = 3;
        p->vertexlist = new int[p->numberofvertices];
        p->vertexlist[0] = iverts;
        p->vertexlist[1] = iverts + 1;
        p->vertexlist[2] = iverts + 2;
        iverts += 3;
    }

    delete plist;
    return true;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// load_medit()    Load a surface mesh from a .mesh file.                    //
//                                                                           //
// The .mesh format is the file format of Medit, a user-friendly interactive //
// mesh viewer program.                                                      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenio::load_medit(char* filebasename, int istetmesh) {
    FILE* fp;
    tetgenio::facet *tmpflist, *f;
    tetgenio::polygon* p;
    char infilename[FILENAMESIZE];
    char buffer[INPUTLINESIZE];
    char *bufferp, *str;
    double* coord;
    int* tmpfmlist;
    int dimension = 0;
    int nverts = 0;
    int nfaces = 0;
    int ntets = 0;
    int line_count = 0;
    int corners = 0; // 3 (triangle) or 4 (quad).
    int* plist;
    int i, j;

    int smallestidx = 0;

    strncpy(infilename, filebasename, FILENAMESIZE - 1);
    infilename[FILENAMESIZE - 1] = '\0';
    if (infilename[0] == '\0') {
        printf("Error:  No filename.\n");
        return false;
    }
    if (strcmp(&infilename[strlen(infilename) - 5], ".mesh") != 0) {
        strcat(infilename, ".mesh");
    }

    if (!(fp = fopen(infilename, "r"))) {
        printf("Error:  Unable to open file %s\n", infilename);
        return false;
    }
    printf("Opening %s.\n", infilename);

    while ((bufferp = readline(buffer, fp, &line_count)) != NULL) {
        if (*bufferp == '#') continue; // A comment line is skipped.
        if (dimension == 0) {
            // Find if it is the keyword "Dimension".
            str = strstr(bufferp, "Dimension");
            if (!str) str = strstr(bufferp, "dimension");
            if (!str) str = strstr(bufferp, "DIMENSION");
            if (str) {
                // Read the dimensions
                bufferp = findnextnumber(str); // Skip field "Dimension".
                if (*bufferp == '\0') {
                    // Read a non-empty line.
                    bufferp = readline(buffer, fp, &line_count);
                }
                dimension = (int)strtol(bufferp, &bufferp, 0);
                if (dimension != 2 && dimension != 3) {
                    printf("Unknown dimension in file on line %d in file %s\n", line_count,
                           infilename);
                    fclose(fp);
                    return false;
                }
                mesh_dim = dimension;
            }
        }
        if (nverts == 0) {
            // Find if it is the keyword "Vertices".
            str = strstr(bufferp, "Vertices");
            if (!str) str = strstr(bufferp, "vertices");
            if (!str) str = strstr(bufferp, "VERTICES");
            if (str) {
                // Read the number of vertices.
                bufferp = findnextnumber(str); // Skip field "Vertices".
                if (*bufferp == '\0') {
                    // Read a non-empty line.
                    bufferp = readline(buffer, fp, &line_count);
                }
                nverts = (int)strtol(bufferp, &bufferp, 0);
                // Initialize the smallest index.
                smallestidx = nverts + 1;
                // Allocate memory for 'tetgenio'
                if (nverts > 0) {
                    numberofpoints = nverts;
                    pointlist = new REAL[nverts * 3];
                }
                // Read the follwoing node list.
                for (i = 0; i < nverts; i++) {
                    bufferp = readline(buffer, fp, &line_count);
                    if (bufferp == NULL) {
                        printf("Unexpected end of file on line %d in file %s\n", line_count,
                               infilename);
                        fclose(fp);
                        return false;
                    }
                    // Read vertex coordinates
                    coord = &pointlist[i * 3];
                    for (j = 0; j < 3; j++) {
                        if (*bufferp == '\0') {
                            printf("Syntax error reading vertex coords on line");
                            printf(" %d in file %s\n", line_count, infilename);
                            fclose(fp);
                            return false;
                        }
                        if ((j < 2) || (dimension == 3)) {
                            coord[j] = (REAL)strtod(bufferp, &bufferp);
                        } else {
                            coord[j] = 0.0;
                        }
                        bufferp = findnextnumber(bufferp);
                    }
                }
                continue;
            }
        }
        if (ntets == 0) {
            // Find if it is the keyword "Tetrahedra"
            corners = 0;
            str = strstr(bufferp, "Tetrahedra");
            if (!str) str = strstr(bufferp, "tetrahedra");
            if (!str) str = strstr(bufferp, "TETRAHEDRA");
            if (str) {
                corners = 4;
            }
            if (corners == 4) {
                // Read the number of tetrahedra
                bufferp = findnextnumber(str); // Skip field "Tetrahedra".
                if (*bufferp == '\0') {
                    // Read a non-empty line.
                    bufferp = readline(buffer, fp, &line_count);
                }
                ntets = strtol(bufferp, &bufferp, 0);
                if (ntets > 0) {
                    // It is a tetrahedral mesh.
                    numberoftetrahedra = ntets;
                    numberofcorners = 4;
                    numberoftetrahedronattributes = 1;
                    tetrahedronlist = new int[ntets * 4];
                    tetrahedronattributelist = new REAL[ntets];
                }
            } // if (corners == 4)
            // Read the list of tetrahedra.
            for (i = 0; i < numberoftetrahedra; i++) {
                plist = &(tetrahedronlist[i * 4]);
                bufferp = readline(buffer, fp, &line_count);
                if (bufferp == NULL) {
                    printf("Unexpected end of file on line %d in file %s\n", line_count,
                           infilename);
                    fclose(fp);
                    return false;
                }
                // Read the vertices of the tet.
                for (j = 0; j < corners; j++) {
                    if (*bufferp == '\0') {
                        printf("Syntax error reading face on line %d in file %s\n", line_count,
                               infilename);
                        fclose(fp);
                        return false;
                    }
                    plist[j] = (int)strtol(bufferp, &bufferp, 0);
                    // Remember the smallest index.
                    if (plist[j] < smallestidx) smallestidx = plist[j];
                    bufferp = findnextnumber(bufferp);
                }
                // Read the attribute of the tet if it exists.
                tetrahedronattributelist[i] = 0;
                if (*bufferp != '\0') {
                    tetrahedronattributelist[i] = (REAL)strtol(bufferp, &bufferp, 0);
                }
            } // i
        }     // Tetrahedra
        if (nfaces == 0) {
            // Find if it is the keyword "Triangles" or "Quadrilaterals".
            corners = 0;
            str = strstr(bufferp, "Triangles");
            if (!str) str = strstr(bufferp, "triangles");
            if (!str) str = strstr(bufferp, "TRIANGLES");
            if (str) {
                corners = 3;
            } else {
                str = strstr(bufferp, "Quadrilaterals");
                if (!str) str = strstr(bufferp, "quadrilaterals");
                if (!str) str = strstr(bufferp, "QUADRILATERALS");
                if (str) {
                    corners = 4;
                }
            }
            if (corners == 3 || corners == 4) {
                // Read the number of triangles (or quadrilaterals).
                bufferp = findnextnumber(str); // Skip field "Triangles".
                if (*bufferp == '\0') {
                    // Read a non-empty line.
                    bufferp = readline(buffer, fp, &line_count);
                }
                nfaces = strtol(bufferp, &bufferp, 0);
                // Allocate memory for 'tetgenio'
                if (nfaces > 0) {
                    if (!istetmesh) {
                        // It is a PLC surface mesh.
                        if (numberoffacets > 0) {
                            // facetlist has already been allocated. Enlarge arrays.
                            // This happens when the surface mesh contains mixed cells.
                            tmpflist = new tetgenio::facet[numberoffacets + nfaces];
                            tmpfmlist = new int[numberoffacets + nfaces];
                            // Copy the data of old arrays into new arrays.
                            for (i = 0; i < numberoffacets; i++) {
                                f = &(tmpflist[i]);
                                tetgenio::init(f);
                                *f = facetlist[i];
                                tmpfmlist[i] = facetmarkerlist[i];
                            }
                            // Release old arrays.
                            delete[] facetlist;
                            delete[] facetmarkerlist;
                            // Remember the new arrays.
                            facetlist = tmpflist;
                            facetmarkerlist = tmpfmlist;
                        } else {
                            // This is the first time to allocate facetlist.
                            facetlist = new tetgenio::facet[nfaces];
                            facetmarkerlist = new int[nfaces];
                        }
                    } else {
                        if (corners == 3) {
                            // It is a surface mesh of a tetrahedral mesh.
                            numberoftrifaces = nfaces;
                            trifacelist = new int[nfaces * 3];
                            trifacemarkerlist = new int[nfaces];
                        }
                    }
                } // if (nfaces > 0)
                // Read the following list of faces.
                if (!istetmesh) {
                    for (i = numberoffacets; i < numberoffacets + nfaces; i++) {
                        bufferp = readline(buffer, fp, &line_count);
                        if (bufferp == NULL) {
                            printf("Unexpected end of file on line %d in file %s\n", line_count,
                                   infilename);
                            fclose(fp);
                            return false;
                        }
                        f = &facetlist[i];
                        tetgenio::init(f);
                        // In .mesh format, each facet has one polygon, no hole.
                        f->numberofpolygons = 1;
                        f->polygonlist = new tetgenio::polygon[1];
                        p = &f->polygonlist[0];
                        tetgenio::init(p);
                        p->numberofvertices = corners;
                        // Allocate memory for face vertices
                        p->vertexlist = new int[p->numberofvertices];
                        // Read the vertices of the face.
                        for (j = 0; j < corners; j++) {
                            if (*bufferp == '\0') {
                                printf("Syntax error reading face on line %d in file %s\n",
                                       line_count, infilename);
                                fclose(fp);
                                return false;
                            }
                            p->vertexlist[j] = (int)strtol(bufferp, &bufferp, 0);
                            // Remember the smallest index.
                            if (p->vertexlist[j] < smallestidx) {
                                smallestidx = p->vertexlist[j];
                            }
                            bufferp = findnextnumber(bufferp);
                        }
                        // Read the marker of the face if it exists.
                        facetmarkerlist[i] = 0;
                        if (*bufferp != '\0') {
                            facetmarkerlist[i] = (int)strtol(bufferp, &bufferp, 0);
                        }
                    }
                    // Have read in a list of triangles/quads.
                    numberoffacets += nfaces;
                    nfaces = 0;
                } else {
                    // It is a surface mesh of a tetrahedral mesh.
                    if (corners == 3) {
                        for (i = 0; i < numberoftrifaces; i++) {
                            plist = &(trifacelist[i * 3]);
                            bufferp = readline(buffer, fp, &line_count);
                            if (bufferp == NULL) {
                                printf("Unexpected end of file on line %d in file %s\n", line_count,
                                       infilename);
                                fclose(fp);
                                return false;
                            }
                            // Read the vertices of the face.
                            for (j = 0; j < corners; j++) {
                                if (*bufferp == '\0') {
                                    printf("Syntax error reading face on line %d in file %s\n",
                                           line_count, infilename);
                                    fclose(fp);
                                    return false;
                                }
                                plist[j] = (int)strtol(bufferp, &bufferp, 0);
                                // Remember the smallest index.
                                if (plist[j] < smallestidx) {
                                    smallestidx = plist[j];
                                }
                                bufferp = findnextnumber(bufferp);
                            }
                            // Read the marker of the face if it exists.
                            trifacemarkerlist[i] = 0;
                            if (*bufferp != '\0') {
                                trifacemarkerlist[i] = (int)strtol(bufferp, &bufferp, 0);
                            }
                        } // i
                    }     // if (corners == 3)
                }         // if (b->refine)
            }             // if (corners == 3 || corners == 4)
        }
    }

    // Close file
    fclose(fp);

    // Decide the firstnumber of the index.
    if (smallestidx == 0) {
        firstnumber = 0;
    } else if (smallestidx == 1) {
        firstnumber = 1;
    } else {
        printf("A wrong smallest index (%d) was detected in file %s\n", smallestidx, infilename);
        return false;
    }

    return true;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// load_vtk()    Load VTK surface mesh from file (.vtk ascii or binary).     //
//                                                                           //
// This function is contributed by: Bryn Lloyd, Computer Vision Laboratory,  //
// ETH, Zuerich. May 7, 2007.                                                //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

// Two inline functions used in read/write VTK files.

void swapBytes(unsigned char* var, int size) {
    int i = 0;
    int j = size - 1;
    char c;

    while (i < j) {
        c = var[i];
        var[i] = var[j];
        var[j] = c;
        i++, j--;
    }
}

bool testIsBigEndian() {
    short word = 0x4321;
    if ((*(char*)&word) != 0x21)
        return true;
    else
        return false;
}

bool tetgenio::load_vtk(char* filebasename) {
    FILE* fp;
    tetgenio::facet* f;
    tetgenio::polygon* p;
    char infilename[FILENAMESIZE];
    char line[INPUTLINESIZE];
    char mode[128], id[256], fmt[64];
    char* bufferp;
    double* coord;
    float _x, _y, _z;
    int nverts = 0;
    int nfaces = 0;
    int line_count = 0;
    int dummy;
    int id1, id2, id3;
    int nn = -1;
    int nn_old = -1;
    int i, j;
    bool ImALittleEndian = !testIsBigEndian();

    int smallestidx = 0;

    strncpy(infilename, filebasename, FILENAMESIZE - 1);
    infilename[FILENAMESIZE - 1] = '\0';
    if (infilename[0] == '\0') {
        printf("Error:  No filename.\n");
        return false;
    }
    if (strcmp(&infilename[strlen(infilename) - 4], ".vtk") != 0) {
        strcat(infilename, ".vtk");
    }
    if (!(fp = fopen(infilename, "r"))) {
        printf("Error:  Unable to open file %s\n", infilename);
        return false;
    }
    printf("Opening %s.\n", infilename);

    // Default uses the index starts from '0'.
    firstnumber = 0;
    strcpy(mode, "BINARY");

    while ((bufferp = readline(line, fp, &line_count)) != NULL) {
        if (strlen(line) == 0) continue;
        // swallow lines beginning with a comment sign or white space
        if (line[0] == '#' || line[0] == '\n' || line[0] == 10 || line[0] == 13 || line[0] == 32)
            continue;

        sscanf(line, "%s", id);
        if (!strcmp(id, "ASCII")) {
            strcpy(mode, "ASCII");
        }

        if (!strcmp(id, "POINTS")) {
            sscanf(line, "%s %d %s", id, &nverts, fmt);
            if (nverts > 0) {
                numberofpoints = nverts;
                pointlist = new REAL[nverts * 3];
                smallestidx = nverts + 1;
            }

            if (!strcmp(mode, "BINARY")) {
                for (i = 0; i < nverts; i++) {
                    coord = &pointlist[i * 3];
                    if (!strcmp(fmt, "double")) {
                        fread((char*)(&(coord[0])), sizeof(double), 1, fp);
                        fread((char*)(&(coord[1])), sizeof(double), 1, fp);
                        fread((char*)(&(coord[2])), sizeof(double), 1, fp);
                        if (ImALittleEndian) {
                            swapBytes((unsigned char*)&(coord[0]), sizeof(coord[0]));
                            swapBytes((unsigned char*)&(coord[1]), sizeof(coord[1]));
                            swapBytes((unsigned char*)&(coord[2]), sizeof(coord[2]));
                        }
                    } else if (!strcmp(fmt, "float")) {
                        fread((char*)(&_x), sizeof(float), 1, fp);
                        fread((char*)(&_y), sizeof(float), 1, fp);
                        fread((char*)(&_z), sizeof(float), 1, fp);
                        if (ImALittleEndian) {
                            swapBytes((unsigned char*)&_x, sizeof(_x));
                            swapBytes((unsigned char*)&_y, sizeof(_y));
                            swapBytes((unsigned char*)&_z, sizeof(_z));
                        }
                        coord[0] = double(_x);
                        coord[1] = double(_y);
                        coord[2] = double(_z);
                    } else {
                        printf("Error: Only float or double formats are supported!\n");
                        return false;
                    }
                }
            } else if (!strcmp(mode, "ASCII")) {
                for (i = 0; i < nverts; i++) {
                    bufferp = readline(line, fp, &line_count);
                    if (bufferp == NULL) {
                        printf("Unexpected end of file on line %d in file %s\n", line_count,
                               infilename);
                        fclose(fp);
                        return false;
                    }
                    // Read vertex coordinates
                    coord = &pointlist[i * 3];
                    for (j = 0; j < 3; j++) {
                        if (*bufferp == '\0') {
                            printf("Syntax error reading vertex coords on line");
                            printf(" %d in file %s\n", line_count, infilename);
                            fclose(fp);
                            return false;
                        }
                        coord[j] = (REAL)strtod(bufferp, &bufferp);
                        bufferp = findnextnumber(bufferp);
                    }
                }
            }
            continue;
        }

        if (!strcmp(id, "POLYGONS")) {
            sscanf(line, "%s %d  %d", id, &nfaces, &dummy);
            if (nfaces > 0) {
                numberoffacets = nfaces;
                facetlist = new tetgenio::facet[nfaces];
            }

            if (!strcmp(mode, "BINARY")) {
                for (i = 0; i < nfaces; i++) {
                    fread((char*)(&nn), sizeof(int), 1, fp);
                    if (ImALittleEndian) {
                        swapBytes((unsigned char*)&nn, sizeof(nn));
                    }
                    if (i == 0) nn_old = nn;
                    if (nn != nn_old) {
                        printf("Error:  No mixed cells are allowed.\n");
                        return false;
                    }

                    if (nn == 3) {
                        fread((char*)(&id1), sizeof(int), 1, fp);
                        fread((char*)(&id2), sizeof(int), 1, fp);
                        fread((char*)(&id3), sizeof(int), 1, fp);
                        if (ImALittleEndian) {
                            swapBytes((unsigned char*)&id1, sizeof(id1));
                            swapBytes((unsigned char*)&id2, sizeof(id2));
                            swapBytes((unsigned char*)&id3, sizeof(id3));
                        }
                        f = &facetlist[i];
                        init(f);
                        // In .off format, each facet has one polygon, no hole.
                        f->numberofpolygons = 1;
                        f->polygonlist = new tetgenio::polygon[1];
                        p = &f->polygonlist[0];
                        init(p);
                        // Set number of vertices
                        p->numberofvertices = 3;
                        // Allocate memory for face vertices
                        p->vertexlist = new int[p->numberofvertices];
                        p->vertexlist[0] = id1;
                        p->vertexlist[1] = id2;
                        p->vertexlist[2] = id3;
                        // Detect the smallest index.
                        for (j = 0; j < 3; j++) {
                            if (p->vertexlist[j] < smallestidx) {
                                smallestidx = p->vertexlist[j];
                            }
                        }
                    } else {
                        printf("Error: Only triangles are supported\n");
                        return false;
                    }
                }
            } else if (!strcmp(mode, "ASCII")) {
                for (i = 0; i < nfaces; i++) {
                    bufferp = readline(line, fp, &line_count);
                    nn = (int)strtol(bufferp, &bufferp, 0);
                    if (i == 0) nn_old = nn;
                    if (nn != nn_old) {
                        printf("Error:  No mixed cells are allowed.\n");
                        return false;
                    }

                    if (nn == 3) {
                        bufferp = findnextnumber(bufferp); // Skip the first field.
                        id1 = (int)strtol(bufferp, &bufferp, 0);
                        bufferp = findnextnumber(bufferp);
                        id2 = (int)strtol(bufferp, &bufferp, 0);
                        bufferp = findnextnumber(bufferp);
                        id3 = (int)strtol(bufferp, &bufferp, 0);
                        f = &facetlist[i];
                        init(f);
                        // In .off format, each facet has one polygon, no hole.
                        f->numberofpolygons = 1;
                        f->polygonlist = new tetgenio::polygon[1];
                        p = &f->polygonlist[0];
                        init(p);
                        // Set number of vertices
                        p->numberofvertices = 3;
                        // Allocate memory for face vertices
                        p->vertexlist = new int[p->numberofvertices];
                        p->vertexlist[0] = id1;
                        p->vertexlist[1] = id2;
                        p->vertexlist[2] = id3;
                        // Detect the smallest index.
                        for (j = 0; j < 3; j++) {
                            if (p->vertexlist[j] < smallestidx) {
                                smallestidx = p->vertexlist[j];
                            }
                        }
                    } else {
                        printf("Error:  Only triangles are supported.\n");
                        return false;
                    }
                }
            }

            fclose(fp);

            // Decide the firstnumber of the index.
            if (smallestidx == 0) {
                firstnumber = 0;
            } else if (smallestidx == 1) {
                firstnumber = 1;
            } else {
                printf("A wrong smallest index (%d) was detected in file %s\n", smallestidx,
                       infilename);
                return false;
            }

            return true;
        }

        if (!strcmp(id, "LINES") || !strcmp(id, "CELLS")) {
            printf("Warning:  load_vtk(): cannot read formats LINES, CELLS.\n");
        }
    } // while ()

    return true;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// load_plc()    Load a piecewise linear complex from file(s).               //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenio::load_plc(char* filebasename, int object) {
    bool success;

    if (object == (int)tetgenbehavior::NODES) {
        success = load_node(filebasename);
    } else if (object == (int)tetgenbehavior::POLY) {
        success = load_poly(filebasename);
    } else if (object == (int)tetgenbehavior::OFF) {
        success = load_off(filebasename);
    } else if (object == (int)tetgenbehavior::PLY) {
        success = load_ply(filebasename);
    } else if (object == (int)tetgenbehavior::STL) {
        success = load_stl(filebasename);
    } else if (object == (int)tetgenbehavior::MEDIT) {
        success = load_medit(filebasename, 0);
    } else if (object == (int)tetgenbehavior::VTK) {
        success = load_vtk(filebasename);
    } else {
        success = load_poly(filebasename);
    }

    if (success) {
        // Try to load the following files (.edge, .var, .mtr).
        load_edge(filebasename);
        load_var(filebasename);
        load_mtr(filebasename);
    }

    return success;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// load_mesh()    Load a tetrahedral mesh from file(s).                      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenio::load_tetmesh(char* filebasename, int object) {
    bool success;

    if (object == (int)tetgenbehavior::MEDIT) {
        success = load_medit(filebasename, 1);
    } else if (object == (int)tetgenbehavior::NEU_MESH) {
        // success = load_neumesh(filebasename, 1);
    } else {
        success = load_node(filebasename);
        if (success) {
            success = load_tet(filebasename);
        }
        if (success) {
            // Try to load the following files (.face, .edge, .vol).
            load_face(filebasename);
            load_edge(filebasename);
            load_vol(filebasename);
        }
    }

    // if (success) {
    // Try to load the following files (.var, .mtr).
    load_var(filebasename);
    load_mtr(filebasename);
    //}

    return success;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// save_nodes()    Save points to a .node file.                              //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenio::save_nodes(char* filebasename) {
    FILE* fout;
    char outnodefilename[FILENAMESIZE];
    char outmtrfilename[FILENAMESIZE];
    int i, j;

    sprintf(outnodefilename, "%s.node", filebasename);
    printf("Saving nodes to %s\n", outnodefilename);
    fout = fopen(outnodefilename, "w");
    fprintf(fout, "%d  %d  %d  %d\n", numberofpoints, mesh_dim, numberofpointattributes,
            pointmarkerlist != NULL ? 1 : 0);
    for (i = 0; i < numberofpoints; i++) {
        if (mesh_dim == 2) {
            fprintf(fout, "%d  %.16g  %.16g", i + firstnumber, pointlist[i * 3],
                    pointlist[i * 3 + 1]);
        } else {
            fprintf(fout, "%d  %.16g  %.16g  %.16g", i + firstnumber, pointlist[i * 3],
                    pointlist[i * 3 + 1], pointlist[i * 3 + 2]);
        }
        for (j = 0; j < numberofpointattributes; j++) {
            fprintf(fout, "  %.16g", pointattributelist[i * numberofpointattributes + j]);
        }
        if (pointmarkerlist != NULL) {
            fprintf(fout, "  %d", pointmarkerlist[i]);
        }
        fprintf(fout, "\n");
    }
    fclose(fout);

    // If the point metrics exist, output them to a .mtr file.
    if ((numberofpointmtrs > 0) && (pointmtrlist != (REAL*)NULL)) {
        sprintf(outmtrfilename, "%s.mtr", filebasename);
        printf("Saving metrics to %s\n", outmtrfilename);
        fout = fopen(outmtrfilename, "w");
        fprintf(fout, "%d  %d\n", numberofpoints, numberofpointmtrs);
        for (i = 0; i < numberofpoints; i++) {
            for (j = 0; j < numberofpointmtrs; j++) {
                fprintf(fout, "%.16g ", pointmtrlist[i * numberofpointmtrs + j]);
            }
            fprintf(fout, "\n");
        }
        fclose(fout);
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// save_elements()    Save elements to a .ele file.                          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenio::save_elements(char* filebasename) {
    FILE* fout;
    char outelefilename[FILENAMESIZE];
    int i, j;

    sprintf(outelefilename, "%s.ele", filebasename);
    printf("Saving elements to %s\n", outelefilename);
    fout = fopen(outelefilename, "w");
    if (mesh_dim == 3) {
        fprintf(fout, "%d  %d  %d\n", numberoftetrahedra, numberofcorners,
                numberoftetrahedronattributes);
        for (i = 0; i < numberoftetrahedra; i++) {
            fprintf(fout, "%d", i + firstnumber);
            for (j = 0; j < numberofcorners; j++) {
                fprintf(fout, "  %5d", tetrahedronlist[i * numberofcorners + j]);
            }
            for (j = 0; j < numberoftetrahedronattributes; j++) {
                fprintf(fout, "  %g",
                        tetrahedronattributelist[i * numberoftetrahedronattributes + j]);
            }
            fprintf(fout, "\n");
        }
    } else {
        // Save a two-dimensional mesh.
        fprintf(fout, "%d  %d  %d\n", numberoftrifaces, 3, trifacemarkerlist ? 1 : 0);
        for (i = 0; i < numberoftrifaces; i++) {
            fprintf(fout, "%d", i + firstnumber);
            for (j = 0; j < 3; j++) {
                fprintf(fout, "  %5d", trifacelist[i * 3 + j]);
            }
            if (trifacemarkerlist != NULL) {
                fprintf(fout, "  %d", trifacemarkerlist[i]);
            }
            fprintf(fout, "\n");
        }
    }

    fclose(fout);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// save_faces()    Save faces to a .face file.                               //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenio::save_faces(char* filebasename) {
    FILE* fout;
    char outfacefilename[FILENAMESIZE];
    int i;

    sprintf(outfacefilename, "%s.face", filebasename);
    printf("Saving faces to %s\n", outfacefilename);
    fout = fopen(outfacefilename, "w");
    fprintf(fout, "%d  %d\n", numberoftrifaces, trifacemarkerlist != NULL ? 1 : 0);
    for (i = 0; i < numberoftrifaces; i++) {
        fprintf(fout, "%d  %5d  %5d  %5d", i + firstnumber, trifacelist[i * 3],
                trifacelist[i * 3 + 1], trifacelist[i * 3 + 2]);
        if (trifacemarkerlist != NULL) {
            fprintf(fout, "  %d", trifacemarkerlist[i]);
        }
        fprintf(fout, "\n");
    }

    fclose(fout);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// save_edges()    Save egdes to a .edge file.                               //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenio::save_edges(char* filebasename) {
    FILE* fout;
    char outedgefilename[FILENAMESIZE];
    int i;

    sprintf(outedgefilename, "%s.edge", filebasename);
    printf("Saving edges to %s\n", outedgefilename);
    fout = fopen(outedgefilename, "w");
    fprintf(fout, "%d  %d\n", numberofedges, edgemarkerlist != NULL ? 1 : 0);
    for (i = 0; i < numberofedges; i++) {
        fprintf(fout, "%d  %4d  %4d", i + firstnumber, edgelist[i * 2], edgelist[i * 2 + 1]);
        if (edgemarkerlist != NULL) {
            fprintf(fout, "  %d", edgemarkerlist[i]);
        }
        fprintf(fout, "\n");
    }

    fclose(fout);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// save_neighbors()    Save egdes to a .neigh file.                          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenio::save_neighbors(char* filebasename) {
    FILE* fout;
    char outneighborfilename[FILENAMESIZE];
    int i;

    sprintf(outneighborfilename, "%s.neigh", filebasename);
    printf("Saving neighbors to %s\n", outneighborfilename);
    fout = fopen(outneighborfilename, "w");
    fprintf(fout, "%d  %d\n", numberoftetrahedra, mesh_dim + 1);
    for (i = 0; i < numberoftetrahedra; i++) {
        if (mesh_dim == 2) {
            fprintf(fout, "%d  %5d  %5d  %5d", i + firstnumber, neighborlist[i * 3],
                    neighborlist[i * 3 + 1], neighborlist[i * 3 + 2]);
        } else {
            fprintf(fout, "%d  %5d  %5d  %5d  %5d", i + firstnumber, neighborlist[i * 4],
                    neighborlist[i * 4 + 1], neighborlist[i * 4 + 2], neighborlist[i * 4 + 3]);
        }
        fprintf(fout, "\n");
    }

    fclose(fout);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// save_poly()    Save segments or facets to a .poly file.                   //
//                                                                           //
// It only save the facets, holes and regions. No .node file is saved.       //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenio::save_poly(char* filebasename) {
    FILE* fout;
    facet* f;
    polygon* p;
    char outpolyfilename[FILENAMESIZE];
    int i, j, k;

    sprintf(outpolyfilename, "%s.poly", filebasename);
    printf("Saving poly to %s\n", outpolyfilename);
    fout = fopen(outpolyfilename, "w");

    // The zero indicates that the vertices are in a separate .node file.
    //   Followed by number of dimensions, number of vertex attributes,
    //   and number of boundary markers (zero or one).
    fprintf(fout, "%d  %d  %d  %d\n", 0, mesh_dim, numberofpointattributes,
            pointmarkerlist != NULL ? 1 : 0);

    // Save segments or facets.
    if (mesh_dim == 2) {
        // Number of segments, number of boundary markers (zero or one).
        fprintf(fout, "%d  %d\n", numberofedges, edgemarkerlist != NULL ? 1 : 0);
        for (i = 0; i < numberofedges; i++) {
            fprintf(fout, "%d  %4d  %4d", i + firstnumber, edgelist[i * 2], edgelist[i * 2 + 1]);
            if (edgemarkerlist != NULL) {
                fprintf(fout, "  %d", edgemarkerlist[i]);
            }
            fprintf(fout, "\n");
        }
    } else {
        // Number of facets, number of boundary markers (zero or one).
        fprintf(fout, "%d  %d\n", numberoffacets, facetmarkerlist != NULL ? 1 : 0);
        for (i = 0; i < numberoffacets; i++) {
            f = &(facetlist[i]);
            fprintf(fout, "%d  %d  %d  # %d\n", f->numberofpolygons, f->numberofholes,
                    facetmarkerlist != NULL ? facetmarkerlist[i] : 0, i + firstnumber);
            // Output polygons of this facet.
            for (j = 0; j < f->numberofpolygons; j++) {
                p = &(f->polygonlist[j]);
                fprintf(fout, "%d  ", p->numberofvertices);
                for (k = 0; k < p->numberofvertices; k++) {
                    if (((k + 1) % 10) == 0) {
                        fprintf(fout, "\n  ");
                    }
                    fprintf(fout, "  %d", p->vertexlist[k]);
                }
                fprintf(fout, "\n");
            }
            // Output holes of this facet.
            for (j = 0; j < f->numberofholes; j++) {
                fprintf(fout, "%d  %.12g  %.12g  %.12g\n", j + firstnumber, f->holelist[j * 3],
                        f->holelist[j * 3 + 1], f->holelist[j * 3 + 2]);
            }
        }
    }

    // Save holes.
    fprintf(fout, "%d\n", numberofholes);
    for (i = 0; i < numberofholes; i++) {
        // Output x, y coordinates.
        fprintf(fout, "%d  %.12g  %.12g", i + firstnumber, holelist[i * mesh_dim],
                holelist[i * mesh_dim + 1]);
        if (mesh_dim == 3) {
            // Output z coordinate.
            fprintf(fout, "  %.12g", holelist[i * mesh_dim + 2]);
        }
        fprintf(fout, "\n");
    }

    // Save regions.
    fprintf(fout, "%d\n", numberofregions);
    for (i = 0; i < numberofregions; i++) {
        if (mesh_dim == 2) {
            // Output the index, x, y coordinates, attribute (region number)
            //   and maximum area constraint (maybe -1).
            fprintf(fout, "%d  %.12g  %.12g  %.12g  %.12g\n", i + firstnumber, regionlist[i * 4],
                    regionlist[i * 4 + 1], regionlist[i * 4 + 2], regionlist[i * 4 + 3]);
        } else {
            // Output the index, x, y, z coordinates, attribute (region number)
            //   and maximum volume constraint (maybe -1).
            fprintf(fout, "%d  %.12g  %.12g  %.12g  %.12g  %.12g\n", i + firstnumber,
                    regionlist[i * 5], regionlist[i * 5 + 1], regionlist[i * 5 + 2],
                    regionlist[i * 5 + 3], regionlist[i * 5 + 4]);
        }
    }

    fclose(fout);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// save_faces2smesh()    Save triangular faces to a .smesh file.             //
//                                                                           //
// It only save the facets. No holes and regions. No .node file.             //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenio::save_faces2smesh(char* filebasename) {
    FILE* fout;
    char outsmeshfilename[FILENAMESIZE];
    int i, j;

    sprintf(outsmeshfilename, "%s.smesh", filebasename);
    printf("Saving faces to %s\n", outsmeshfilename);
    fout = fopen(outsmeshfilename, "w");

    // The zero indicates that the vertices are in a separate .node file.
    //   Followed by number of dimensions, number of vertex attributes,
    //   and number of boundary markers (zero or one).
    fprintf(fout, "%d  %d  %d  %d\n", 0, mesh_dim, numberofpointattributes,
            pointmarkerlist != NULL ? 1 : 0);

    // Number of facets, number of boundary markers (zero or one).
    fprintf(fout, "%d  %d\n", numberoftrifaces, trifacemarkerlist != NULL ? 1 : 0);

    // Output triangular facets.
    for (i = 0; i < numberoftrifaces; i++) {
        j = i * 3;
        fprintf(fout, "3  %d %d %d", trifacelist[j], trifacelist[j + 1], trifacelist[j + 2]);
        if (trifacemarkerlist != NULL) {
            fprintf(fout, "  %d", trifacemarkerlist[i]);
        }
        fprintf(fout, "\n");
    }

    // No holes and regions.
    fprintf(fout, "0\n");
    fprintf(fout, "0\n");

    fclose(fout);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// readline()   Read a nonempty line from a file.                            //
//                                                                           //
// A line is considered "nonempty" if it contains something more than white  //
// spaces.  If a line is considered empty, it will be dropped and the next   //
// line will be read, this process ends until reaching the end-of-file or a  //
// non-empty line.  Return NULL if it is the end-of-file, otherwise, return  //
// a pointer to the first non-whitespace character of the line.              //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

char* tetgenio::readline(char* string, FILE* infile, int* linenumber) {
    char* result;

    // Search for a non-empty line.
    do {
        result = fgets(string, INPUTLINESIZE - 1, infile);
        if (linenumber) (*linenumber)++;
        if (result == (char*)NULL) {
            return (char*)NULL;
        }
        // Skip white spaces.
        while ((*result == ' ') || (*result == '\t'))
            result++;
        // If it's end of line, read another line and try again.
    } while ((*result == '\0') || (*result == '\r') || (*result == '\n'));
    return result;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// findnextfield()   Find the next field of a string.                        //
//                                                                           //
// Jumps past the current field by searching for whitespace or a comma, then //
// jumps past the whitespace or the comma to find the next field.            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

char* tetgenio::findnextfield(char* string) {
    char* result;

    result = string;
    // Skip the current field.  Stop upon reaching whitespace or a comma.
    while ((*result != '\0') && (*result != ' ') && (*result != '\t') && (*result != ',') &&
           (*result != ';')) {
        result++;
    }
    // Now skip the whitespace or the comma, stop at anything else that looks
    //   like a character, or the end of a line.
    while ((*result == ' ') || (*result == '\t') || (*result == ',') || (*result == ';')) {
        result++;
    }
    return result;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// readnumberline()   Read a nonempty number line from a file.               //
//                                                                           //
// A line is considered "nonempty" if it contains something that looks like  //
// a number.  Comments (prefaced by `#') are ignored.                        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

char* tetgenio::readnumberline(char* string, FILE* infile, char* infilename) {
    char* result;

    // Search for something that looks like a number.
    do {
        result = fgets(string, INPUTLINESIZE, infile);
        if (result == (char*)NULL) {
            return result;
        }
        // Skip anything that doesn't look like a number, a comment,
        //   or the end of a line.
        while ((*result != '\0') && (*result != '#') && (*result != '.') && (*result != '+') &&
               (*result != '-') && ((*result < '0') || (*result > '9'))) {
            result++;
        }
        // If it's a comment or end of line, read another line and try again.
    } while ((*result == '#') || (*result == '\0'));
    return result;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// findnextnumber()   Find the next field of a number string.                //
//                                                                           //
// Jumps past the current field by searching for whitespace or a comma, then //
// jumps past the whitespace or the comma to find the next field that looks  //
// like a number.                                                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

char* tetgenio::findnextnumber(char* string) {
    char* result;

    result = string;
    // Skip the current field.  Stop upon reaching whitespace or a comma.
    while ((*result != '\0') && (*result != '#') && (*result != ' ') && (*result != '\t') &&
           (*result != ',')) {
        result++;
    }
    // Now skip the whitespace and anything else that doesn't look like a
    //   number, a comment, or the end of a line.
    while ((*result != '\0') && (*result != '#') && (*result != '.') && (*result != '+') &&
           (*result != '-') && ((*result < '0') || (*result > '9'))) {
        result++;
    }
    // Check for a comment (prefixed with `#').
    if (*result == '#') {
        *result = '\0';
    }
    return result;
}

////                                                                       ////
////                                                                       ////
//// io_cxx ///////////////////////////////////////////////////////////////////

//// behavior_cxx /////////////////////////////////////////////////////////////
////                                                                       ////
////                                                                       ////

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// syntax()    Print list of command line switches.                          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenbehavior::syntax() {
    printf("  tetgen [-pYrq_Aa_miO_S_T_XMwcdzfenvgkJBNEFICQVh] input_file\n");
    printf("    -p  Tetrahedralizes a piecewise linear complex (PLC).\n");
    printf("    -Y  Preserves the input surface mesh (does not modify it).\n");
    printf("    -r  Reconstructs a previously generated mesh.\n");
    printf("    -q  Refines mesh (to improve mesh quality).\n");
    printf("    -R  Mesh coarsening (to reduce the mesh elements).\n");
    printf("    -A  Assigns attributes to tetrahedra in different regions.\n");
    printf("    -a  Applies a maximum tetrahedron volume constraint.\n");
    printf("    -m  Applies a mesh sizing function.\n");
    printf("    -i  Inserts a list of additional points.\n");
    printf("    -O  Specifies the level of mesh optimization.\n");
    printf("    -S  Specifies maximum number of added points.\n");
    printf("    -T  Sets a tolerance for coplanar test (default 1e-8).\n");
    printf("    -X  Suppresses use of exact arithmetic.\n");
    printf("    -M  No merge of coplanar facets or very close vertices.\n");
    printf("    -w  Generates weighted Delaunay (regular) triangulation.\n");
    printf("    -c  Retains the convex hull of the PLC.\n");
    printf("    -d  Detects self-intersections of facets of the PLC.\n");
    printf("    -z  Numbers all output items starting from zero.\n");
    printf("    -f  Outputs all faces to .face file.\n");
    printf("    -e  Outputs all edges to .edge file.\n");
    printf("    -n  Outputs tetrahedra neighbors to .neigh file.\n");
    printf("    -v  Outputs Voronoi diagram to files.\n");
    printf("    -g  Outputs mesh to .mesh file for viewing by Medit.\n");
    printf("    -k  Outputs mesh to .vtk file for viewing by Paraview.\n");
    printf("    -J  No jettison of unused vertices from output .node file.\n");
    printf("    -B  Suppresses output of boundary information.\n");
    printf("    -N  Suppresses output of .node file.\n");
    printf("    -E  Suppresses output of .ele file.\n");
    printf("    -F  Suppresses output of .face and .edge file.\n");
    printf("    -I  Suppresses mesh iteration numbers.\n");
    printf("    -C  Checks the consistency of the final mesh.\n");
    printf("    -Q  Quiet:  No terminal output except errors.\n");
    printf("    -V  Verbose:  Detailed information, more terminal output.\n");
    printf("    -h  Help:  A brief instruction for using TetGen.\n");
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// usage()    Print a brief instruction for using TetGen.                    //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenbehavior::usage() {
    printf("TetGen\n");
    printf("A Quality Tetrahedral Mesh Generator and 3D Delaunay ");
    printf("Triangulator\n");
    printf("Version 1.5\n");
    printf("August 18, 2018\n");
    printf("\n");
    printf("Copyright (C) 2002 - 2018\n");
    printf("\n");
    printf("What Can TetGen Do?\n");
    printf("\n");
    printf("  TetGen generates Delaunay tetrahedralizations, constrained\n");
    printf("  Delaunay tetrahedralizations, and quality tetrahedral meshes.\n");
    printf("\n");
    printf("Command Line Syntax:\n");
    printf("\n");
    printf("  Below is the basic command line syntax of TetGen with a list of ");
    printf("short\n");
    printf("  descriptions. Underscores indicate that numbers may optionally\n");
    printf("  follow certain switches.  Do not leave any space between a ");
    printf("switch\n");
    printf("  and its numeric parameter.  \'input_file\' contains input data\n");
    printf("  depending on the switches you supplied which may be a ");
    printf("  piecewise\n");
    printf("  linear complex or a list of nodes.  File formats and detailed\n");
    printf("  description of command line switches are found in user's ");
    printf("manual.\n");
    printf("\n");
    syntax();
    printf("\n");
    printf("Examples of How to Use TetGen:\n");
    printf("\n");
    printf("  \'tetgen object\' reads vertices from object.node, and writes ");
    printf("their\n  Delaunay tetrahedralization to object.1.node, ");
    printf("object.1.ele\n  (tetrahedra), and object.1.face");
    printf(" (convex hull faces).\n");
    printf("\n");
    printf("  \'tetgen -p object\' reads a PLC from object.poly or object.");
    printf("smesh (and\n  possibly object.node) and writes its constrained ");
    printf("Delaunay\n  tetrahedralization to object.1.node, object.1.ele, ");
    printf("object.1.face,\n");
    printf("  (boundary faces) and object.1.edge (boundary edges).\n");
    printf("\n");
    printf("  \'tetgen -pq1.414a.1 object\' reads a PLC from object.poly or\n");
    printf("  object.smesh (and possibly object.node), generates a mesh ");
    printf("whose\n  tetrahedra have radius-edge ratio smaller than 1.414 and ");
    printf("have volume\n  of 0.1 or less, and writes the mesh to ");
    printf("object.1.node, object.1.ele,\n  object.1.face, and object.1.edge\n");
    printf("\n");
    printf("Please send bugs/comments to Hang Si <si@wias-berlin.de>\n");
    terminatetetgen(NULL, 0);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// parse_commandline()    Read the command line, identify switches, and set  //
//                        up options and file names.                         //
//                                                                           //
// 'argc' and 'argv' are the same parameters passed to the function main()   //
// of a C/C++ program. They together represent the command line user invoked //
// from an environment in which TetGen is running.                           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenbehavior::parse_commandline(int argc, char** argv) {
    int startindex;
    int increment;
    int meshnumber;
    int i, j, k;
    char workstring[1024];

    // First determine the input style of the switches.
    if (argc == 0) {
        startindex = 0; // Switches are given without a dash.
        argc = 1;       // For running the following for-loop once.
        commandline[0] = '\0';
    } else {
        startindex = 1;
        strcpy(commandline, argv[0]);
        strcat(commandline, " ");
    }

    for (i = startindex; i < argc; i++) {
        // Remember the command line for output.
        strcat(commandline, argv[i]);
        strcat(commandline, " ");
        if (startindex == 1) {
            // Is this string a filename?
            if (argv[i][0] != '-') {
                strncpy(infilename, argv[i], 1024 - 1);
                infilename[1024 - 1] = '\0';
                continue;
            }
        }
        // Parse the individual switch from the string.
        for (j = startindex; argv[i][j] != '\0'; j++) {
            if (argv[i][j] == 'p') {
                plc = 1;
                if (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                    (argv[i][j + 1] == '.')) {
                    k = 0;
                    while (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                           (argv[i][j + 1] == '.')) {
                        j++;
                        workstring[k] = argv[i][j];
                        k++;
                    }
                    workstring[k] = '\0';
                    facet_separate_ang_tol = (REAL)strtod(workstring, (char**)NULL);
                }
                if ((argv[i][j + 1] == '/') || (argv[i][j + 1] == ',')) {
                    j++;
                    if (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                        (argv[i][j + 1] == '.')) {
                        k = 0;
                        while (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                               (argv[i][j + 1] == '.') || (argv[i][j + 1] == 'e') ||
                               (argv[i][j + 1] == '-') || (argv[i][j + 1] == '+')) {
                            j++;
                            workstring[k] = argv[i][j];
                            k++;
                        }
                        workstring[k] = '\0';
                        facet_overlap_ang_tol = (REAL)strtod(workstring, (char**)NULL);
                    }
                }
                if ((argv[i][j + 1] == '/') || (argv[i][j + 1] == ',')) {
                    j++;
                    if (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                        (argv[i][j + 1] == '.')) {
                        k = 0;
                        while (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                               (argv[i][j + 1] == '.')) {
                            j++;
                            workstring[k] = argv[i][j];
                            k++;
                        }
                        workstring[k] = '\0';
                        facet_small_ang_tol = (REAL)strtod(workstring, (char**)NULL);
                    }
                }
            } else if (argv[i][j] == 's') {
                psc = 1;
            } else if (argv[i][j] == 'Y') {
                nobisect = 1;
                if ((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) {
                    nobisect_nomerge = (argv[i][j + 1] - '0');
                    j++;
                }
                if ((argv[i][j + 1] == '/') || (argv[i][j + 1] == ',')) {
                    j++;
                    if ((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) {
                        supsteiner_level = (argv[i][j + 1] - '0');
                        j++;
                    }
                }
                if ((argv[i][j + 1] == '/') || (argv[i][j + 1] == ',')) {
                    j++;
                    if ((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) {
                        addsteiner_algo = (argv[i][j + 1] - '0');
                        j++;
                    }
                }
            } else if (argv[i][j] == 'r') {
                refine = 1;
            } else if (argv[i][j] == 'q') {
                quality = 1;
                if (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                    (argv[i][j + 1] == '.')) {
                    k = 0;
                    while (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                           (argv[i][j + 1] == '.')) {
                        j++;
                        workstring[k] = argv[i][j];
                        k++;
                    }
                    workstring[k] = '\0';
                    minratio = (REAL)strtod(workstring, (char**)NULL);
                }
                if ((argv[i][j + 1] == '/') || (argv[i][j + 1] == ',')) {
                    j++;
                    if (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                        (argv[i][j + 1] == '.')) {
                        k = 0;
                        while (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                               (argv[i][j + 1] == '.')) {
                            j++;
                            workstring[k] = argv[i][j];
                            k++;
                        }
                        workstring[k] = '\0';
                        mindihedral = (REAL)strtod(workstring, (char**)NULL);
                    }
                }
            } else if (argv[i][j] == 'R') {
                coarsen = 1;
                if ((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) {
                    coarsen_param = (argv[i][j + 1] - '0');
                    j++;
                }
                if ((argv[i][j + 1] == '/') || (argv[i][j + 1] == ',')) {
                    j++;
                    if (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                        (argv[i][j + 1] == '.')) {
                        k = 0;
                        while (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                               (argv[i][j + 1] == '.')) {
                            j++;
                            workstring[k] = argv[i][j];
                            k++;
                        }
                        workstring[k] = '\0';
                        coarsen_percent = (REAL)strtod(workstring, (char**)NULL);
                    }
                }
            } else if (argv[i][j] == 'w') {
                weighted = 1;
                if ((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) {
                    weighted_param = (argv[i][j + 1] - '0');
                    j++;
                }
            } else if (argv[i][j] == 'b') {
                // -b(brio_threshold/brio_ratio/hilbert_limit/hilbert_order)
                brio_hilbert = 1;
                if (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                    (argv[i][j + 1] == '.')) {
                    k = 0;
                    while (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                           (argv[i][j + 1] == '.')) {
                        j++;
                        workstring[k] = argv[i][j];
                        k++;
                    }
                    workstring[k] = '\0';
                    brio_threshold = (int)strtol(workstring, (char**)&workstring, 0);
                }
                if ((argv[i][j + 1] == '/') || (argv[i][j + 1] == ',')) {
                    j++;
                    if (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                        (argv[i][j + 1] == '.')) {
                        k = 0;
                        while (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                               (argv[i][j + 1] == '.')) {
                            j++;
                            workstring[k] = argv[i][j];
                            k++;
                        }
                        workstring[k] = '\0';
                        brio_ratio = (REAL)strtod(workstring, (char**)NULL);
                    }
                }
                if ((argv[i][j + 1] == '/') || (argv[i][j + 1] == ',')) {
                    j++;
                    if (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                        (argv[i][j + 1] == '.') || (argv[i][j + 1] == '-')) {
                        k = 0;
                        while (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                               (argv[i][j + 1] == '.') || (argv[i][j + 1] == '-')) {
                            j++;
                            workstring[k] = argv[i][j];
                            k++;
                        }
                        workstring[k] = '\0';
                        hilbert_limit = (int)strtol(workstring, (char**)&workstring, 0);
                    }
                }
                if ((argv[i][j + 1] == '/') || (argv[i][j + 1] == ',')) {
                    j++;
                    if (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                        (argv[i][j + 1] == '.') || (argv[i][j + 1] == '-')) {
                        k = 0;
                        while (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                               (argv[i][j + 1] == '.') || (argv[i][j + 1] == '-')) {
                            j++;
                            workstring[k] = argv[i][j];
                            k++;
                        }
                        workstring[k] = '\0';
                        hilbert_order = (REAL)strtod(workstring, (char**)NULL);
                    }
                }
                if (brio_threshold == 0) { // -b0
                    brio_hilbert = 0;      // Turn off BRIO-Hilbert sorting.
                }
                if (brio_ratio >= 1.0) { // -b/1
                    no_sort = 1;
                    brio_hilbert = 0; // Turn off BRIO-Hilbert sorting.
                }
            } else if (argv[i][j] == 'l') {
                incrflip = 1;
            } else if (argv[i][j] == 'L') {
                flipinsert = 1;
            } else if (argv[i][j] == 'm') {
                metric = 1;
            } else if (argv[i][j] == 'a') {
                if (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                    (argv[i][j + 1] == '.')) {
                    fixedvolume = 1;
                    k = 0;
                    while (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                           (argv[i][j + 1] == '.') || (argv[i][j + 1] == 'e') ||
                           (argv[i][j + 1] == '-') || (argv[i][j + 1] == '+')) {
                        j++;
                        workstring[k] = argv[i][j];
                        k++;
                    }
                    workstring[k] = '\0';
                    maxvolume = (REAL)strtod(workstring, (char**)NULL);
                } else {
                    varvolume = 1;
                }
            } else if (argv[i][j] == 'A') {
                regionattrib = 1;
            } else if (argv[i][j] == 'D') {
                cdtrefine = 1;
                if (argv[i][j + 1] == 'l') {
                    use_equatorial_lens = 1;
                } else if ((argv[i][j + 1] >= '1') && (argv[i][j + 1] <= '3')) {
                    reflevel = (argv[i][j + 1] - '1') + 1;
                    j++;
                }
            } else if (argv[i][j] == 'i') {
                insertaddpoints = 1;
            } else if (argv[i][j] == 'd') {
                diagnose = 1;
            } else if (argv[i][j] == 'c') {
                convex = 1;
            } else if (argv[i][j] == 'M') {
                nomergefacet = 1;
                nomergevertex = 1;
                if ((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '1')) {
                    nomergefacet = (argv[i][j + 1] - '0');
                    j++;
                }
                if ((argv[i][j + 1] == '/') || (argv[i][j + 1] == ',')) {
                    j++;
                    if ((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '1')) {
                        nomergevertex = (argv[i][j + 1] - '0');
                        j++;
                    }
                }
            } else if (argv[i][j] == 'X') {
                if (argv[i][j + 1] == '1') {
                    nostaticfilter = 1;
                    j++;
                } else {
                    noexact = 1;
                }
            } else if (argv[i][j] == 'z') {
                if (argv[i][j + 1] == '1') { // -z1
                    reversetetori = 1;
                    j++;
                } else {
                    zeroindex = 1; // -z
                }
            } else if (argv[i][j] == 'f') {
                facesout++;
            } else if (argv[i][j] == 'e') {
                edgesout++;
            } else if (argv[i][j] == 'n') {
                neighout++;
            } else if (argv[i][j] == 'v') {
                voroout = 1;
            } else if (argv[i][j] == 'g') {
                meditview = 1;
            } else if (argv[i][j] == 'k') {
                vtkview = 1;
            } else if (argv[i][j] == 'J') {
                nojettison = 1;
            } else if (argv[i][j] == 'B') {
                nobound = 1;
            } else if (argv[i][j] == 'N') {
                nonodewritten = 1;
            } else if (argv[i][j] == 'E') {
                noelewritten = 1;
            } else if (argv[i][j] == 'F') {
                nofacewritten = 1;
            } else if (argv[i][j] == 'I') {
                noiterationnum = 1;
            } else if (argv[i][j] == 'S') {
                if (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                    (argv[i][j + 1] == '.')) {
                    k = 0;
                    while (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                           (argv[i][j + 1] == '.') || (argv[i][j + 1] == 'e') ||
                           (argv[i][j + 1] == '-') || (argv[i][j + 1] == '+')) {
                        j++;
                        workstring[k] = argv[i][j];
                        k++;
                    }
                    workstring[k] = '\0';
                    steinerleft = (int)strtol(workstring, (char**)NULL, 0);
                }
            } else if (argv[i][j] == 'o') {
                if (argv[i][j + 1] == '2') {
                    order = 2;
                    j++;
                }
                if ((argv[i][j + 1] == '/') || (argv[i][j + 1] == ',')) {
                    j++;
                    if (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                        (argv[i][j + 1] == '.')) {
                        k = 0;
                        while (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                               (argv[i][j + 1] == '.')) {
                            j++;
                            workstring[k] = argv[i][j];
                            k++;
                        }
                        workstring[k] = '\0';
                        optmaxdihedral = (REAL)strtod(workstring, (char**)NULL);
                    }
                }
            } else if (argv[i][j] == 'O') {
                if ((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) {
                    optlevel = (argv[i][j + 1] - '0');
                    j++;
                }
                if ((argv[i][j + 1] == '/') || (argv[i][j + 1] == ',')) {
                    j++;
                    if ((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '7')) {
                        optscheme = (argv[i][j + 1] - '0');
                        j++;
                    }
                }
            } else if (argv[i][j] == 'T') {
                if (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                    (argv[i][j + 1] == '.')) {
                    k = 0;
                    while (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                           (argv[i][j + 1] == '.') || (argv[i][j + 1] == 'e') ||
                           (argv[i][j + 1] == '-') || (argv[i][j + 1] == '+')) {
                        j++;
                        workstring[k] = argv[i][j];
                        k++;
                    }
                    workstring[k] = '\0';
                    epsilon = (REAL)strtod(workstring, (char**)NULL);
                }
            } else if (argv[i][j] == 'C') {
                docheck++;
            } else if (argv[i][j] == 'Q') {
                quiet = 1;
            } else if (argv[i][j] == 'V') {
                verbose++;
            } else if (argv[i][j] == 'x') {
                if (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                    (argv[i][j + 1] == '.')) {
                    k = 0;
                    while (((argv[i][j + 1] >= '0') && (argv[i][j + 1] <= '9')) ||
                           (argv[i][j + 1] == '.') || (argv[i][j + 1] == 'e') ||
                           (argv[i][j + 1] == '-') || (argv[i][j + 1] == '+')) {
                        j++;
                        workstring[k] = argv[i][j];
                        k++;
                    }
                    workstring[k] = '\0';
                    tetrahedraperblock = (int)strtol(workstring, (char**)NULL, 0);
                    if (tetrahedraperblock > 8188) {
                        vertexperblock = tetrahedraperblock / 2;
                        shellfaceperblock = vertexperblock / 2;
                    } else {
                        tetrahedraperblock = 8188;
                    }
                }
            } else if (argv[i][j] == 'H') {
                if (argv[i + 1][0] != '-') {
                    hole_mesh = 1;
                    // It is a filename following by -H
                    strncpy(hole_mesh_filename, argv[i + 1], 1024 - 1);
                    hole_mesh_filename[1024 - 1] = '\0';
                    i++;   // Skip the next string.
                    break; // j
                }
            } else if (argv[i][j] == 'K') {
                apply_flow_bc = 1;
            } else if ((argv[i][j] == 'h') || // (argv[i][j] == 'H')
                       (argv[i][j] == '?')) {
                usage();
            } else {
                printf("Warning:  Unknown switch -%c.\n", argv[i][j]);
            }
        }
    }

    if (startindex == 0) {
        // Set a temporary filename for debugging output.
        strcpy(infilename, "tetgen-tmpfile");
    } else {
        if (infilename[0] == '\0') {
            // No input file name. Print the syntax and exit.
            syntax();
            terminatetetgen(NULL, 0);
        }
        // Recognize the object from file extension if it is available.
        if (!strcmp(&infilename[strlen(infilename) - 5], ".node")) {
            infilename[strlen(infilename) - 5] = '\0';
            object = NODES;
        } else if (!strcmp(&infilename[strlen(infilename) - 5], ".poly")) {
            infilename[strlen(infilename) - 5] = '\0';
            object = POLY;
            plc = 1;
        } else if (!strcmp(&infilename[strlen(infilename) - 6], ".smesh")) {
            infilename[strlen(infilename) - 6] = '\0';
            object = POLY;
            plc = 1;
        } else if (!strcmp(&infilename[strlen(infilename) - 4], ".off")) {
            infilename[strlen(infilename) - 4] = '\0';
            object = OFF;
            plc = 1;
        } else if (!strcmp(&infilename[strlen(infilename) - 4], ".ply")) {
            infilename[strlen(infilename) - 4] = '\0';
            object = PLY;
            plc = 1;
        } else if (!strcmp(&infilename[strlen(infilename) - 4], ".stl")) {
            infilename[strlen(infilename) - 4] = '\0';
            object = STL;
            plc = 1;
        } else if (!strcmp(&infilename[strlen(infilename) - 5], ".mesh")) {
            infilename[strlen(infilename) - 5] = '\0';
            object = MEDIT;
            if (!refine) plc = 1;
        } else if (!strcmp(&infilename[strlen(infilename) - 4], ".vtk")) {
            infilename[strlen(infilename) - 4] = '\0';
            object = VTK;
            plc = 1;
        } else if (!strcmp(&infilename[strlen(infilename) - 4], ".ele")) {
            infilename[strlen(infilename) - 4] = '\0';
            object = MESH;
            refine = 1;
        } else if (!strcmp(&infilename[strlen(infilename) - 4], ".neu")) {
            infilename[strlen(infilename) - 4] = '\0';
            object = NEU_MESH;
            refine = 1;
        }
    }

    if (nobisect && (!plc && !refine)) { // -Y
        plc = 1;                         // Default -p option.
    }
    if (quality && (!plc && !refine)) { // -q
        plc = 1;                        // Default -p option.
    }
    if (diagnose && !plc) { // -d
        plc = 1;
    }
    if (refine && !quality) { // -r only
        // Reconstruct a mesh, no mesh optimization.
        optlevel = 0;
    }
    if (insertaddpoints && (optlevel == 0)) { // with -i option
        optlevel = 2;
    }
    if (coarsen && (optlevel == 0)) { // with -R option
        optlevel = 2;
    }

    // Detect improper combinations of switches.
    if ((refine || plc) && weighted) {
        printf("Error:  Switches -w cannot use together with -p or -r.\n");
        return false;
    }

    if (convex) { // -c
        if (plc && !regionattrib) {
            // -A (region attribute) is needed for marking exterior tets (-1).
            regionattrib = 1;
        }
    }

    // Note: -A must not used together with -r option.
    // Be careful not to add an extra attribute to each element unless the
    //   input supports it (PLC in, but not refining a preexisting mesh).
    if (refine || !plc) {
        regionattrib = 0;
    }
    // Be careful not to allocate space for element area constraints that
    //   will never be assigned any value (other than the default -1.0).
    if (!refine && !plc) {
        varvolume = 0;
    }
    // If '-a' or '-aa' is in use, enable '-q' option too.
    if (fixedvolume || varvolume) {
        if (quality == 0) {
            quality = 1;
            if (!plc && !refine) {
                plc = 1; // enable -p.
            }
        }
    }
    // No user-specified dihedral angle bound. Use default ones.
    if (!quality) {
        if (optmaxdihedral < 179.0) {
            if (nobisect) { // with -Y option
                optmaxdihedral = 179.0;
            } else { // -p only
                optmaxdihedral = 179.999;
            }
        }
        if (optminsmtdihed < 179.999) {
            optminsmtdihed = 179.999;
        }
        if (optminslidihed < 179.999) {
            optminslidihed = 179.999;
        }
    }

    increment = 0;
    strcpy(workstring, infilename);
    j = 1;
    while (workstring[j] != '\0') {
        if ((workstring[j] == '.') && (workstring[j + 1] != '\0')) {
            increment = j + 1;
        }
        j++;
    }
    meshnumber = 0;
    if (increment > 0) {
        j = increment;
        do {
            if ((workstring[j] >= '0') && (workstring[j] <= '9')) {
                meshnumber = meshnumber * 10 + (int)(workstring[j] - '0');
            } else {
                increment = 0;
            }
            j++;
        } while (workstring[j] != '\0');
    }
    if (noiterationnum) {
        strcpy(outfilename, infilename);
    } else if (increment == 0) {
        strcpy(outfilename, infilename);
        strcat(outfilename, ".1");
    } else {
        workstring[increment] = '%';
        workstring[increment + 1] = 'd';
        workstring[increment + 2] = '\0';
        sprintf(outfilename, workstring, meshnumber + 1);
    }
    // Additional input file name has the end ".a".
    strcpy(addinfilename, infilename);
    strcat(addinfilename, ".a");
    // Background filename has the form "*.b.ele", "*.b.node", ...
    strcpy(bgmeshfilename, infilename);
    strcat(bgmeshfilename, ".b");

    return true;
}

////                                                                       ////
////                                                                       ////
//// behavior_cxx /////////////////////////////////////////////////////////////

//// mempool_cxx //////////////////////////////////////////////////////////////
////                                                                       ////
////                                                                       ////

// Initialize fast lookup tables for mesh maniplulation primitives.

int tetgenmesh::bondtbl[12][12] = {
    {
        0,
    },
};
int tetgenmesh::enexttbl[12] = {
    0,
};
int tetgenmesh::eprevtbl[12] = {
    0,
};
int tetgenmesh::enextesymtbl[12] = {
    0,
};
int tetgenmesh::eprevesymtbl[12] = {
    0,
};
int tetgenmesh::eorgoppotbl[12] = {
    0,
};
int tetgenmesh::edestoppotbl[12] = {
    0,
};
int tetgenmesh::fsymtbl[12][12] = {
    {
        0,
    },
};
int tetgenmesh::facepivot1[12] = {
    0,
};
int tetgenmesh::facepivot2[12][12] = {
    {
        0,
    },
};
int tetgenmesh::tsbondtbl[12][6] = {
    {
        0,
    },
};
int tetgenmesh::stbondtbl[12][6] = {
    {
        0,
    },
};
int tetgenmesh::tspivottbl[12][6] = {
    {
        0,
    },
};
int tetgenmesh::stpivottbl[12][6] = {
    {
        0,
    },
};

// Table 'esymtbl' takes an directed edge (version) as input, returns the
//   inversed edge (version) of it.

int tetgenmesh::esymtbl[12] = {9, 6, 11, 4, 3, 7, 1, 5, 10, 0, 8, 2};

// The following four tables give the 12 permutations of the set {0,1,2,3}.
//   An offset 4 is added to each element for a direct access of the points
//   in the tetrahedron data structure.

int tetgenmesh::orgpivot[12] = {7, 7, 5, 5, 6, 4, 4, 6, 5, 6, 7, 4};
int tetgenmesh::destpivot[12] = {6, 4, 4, 6, 5, 6, 7, 4, 7, 7, 5, 5};
int tetgenmesh::apexpivot[12] = {5, 6, 7, 4, 7, 7, 5, 5, 6, 4, 4, 6};
int tetgenmesh::oppopivot[12] = {4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7};

// The twelve versions correspond to six undirected edges. The following two
//   tables map a version to an undirected edge and vice versa.

int tetgenmesh::ver2edge[12] = {0, 1, 2, 3, 3, 5, 1, 5, 4, 0, 4, 2};
int tetgenmesh::edge2ver[6] = {0, 1, 2, 3, 8, 5};

// Edge versions whose apex or opposite may be dummypoint.

int tetgenmesh::epivot[12] = {4, 5, 2, 11, 4, 5, 2, 11, 4, 5, 2, 11};

// Table 'snextpivot' takes an edge version as input, returns the next edge
//   version in the same edge ring.

int tetgenmesh::snextpivot[6] = {2, 5, 4, 1, 0, 3};

// The following three tables give the 6 permutations of the set {0,1,2}.
//   An offset 3 is added to each element for a direct access of the points
//   in the triangle data structure.

int tetgenmesh::sorgpivot[6] = {3, 4, 4, 5, 5, 3};
int tetgenmesh::sdestpivot[6] = {4, 3, 5, 4, 3, 5};
int tetgenmesh::sapexpivot[6] = {5, 5, 3, 3, 4, 4};

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// inittable()    Initialize the look-up tables.                             //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::inittables() {
    int soffset, toffset;
    int i, j;

    // i = t1.ver; j = t2.ver;
    for (i = 0; i < 12; i++) {
        for (j = 0; j < 12; j++) {
            bondtbl[i][j] = (j & 3) + (((i & 12) + (j & 12)) % 12);
        }
    }

    // i = t1.ver; j = t2.ver
    for (i = 0; i < 12; i++) {
        for (j = 0; j < 12; j++) {
            fsymtbl[i][j] = (j + 12 - (i & 12)) % 12;
        }
    }

    for (i = 0; i < 12; i++) {
        facepivot1[i] = (esymtbl[i] & 3);
    }

    for (i = 0; i < 12; i++) {
        for (j = 0; j < 12; j++) {
            facepivot2[i][j] = fsymtbl[esymtbl[i]][j];
        }
    }

    for (i = 0; i < 12; i++) {
        enexttbl[i] = (i + 4) % 12;
        eprevtbl[i] = (i + 8) % 12;
    }

    for (i = 0; i < 12; i++) {
        enextesymtbl[i] = esymtbl[enexttbl[i]];
        eprevesymtbl[i] = esymtbl[eprevtbl[i]];
    }

    for (i = 0; i < 12; i++) {
        eorgoppotbl[i] = eprevtbl[esymtbl[enexttbl[i]]];
        edestoppotbl[i] = enexttbl[esymtbl[eprevtbl[i]]];
    }

    // i = t.ver, j = s.shver
    for (i = 0; i < 12; i++) {
        for (j = 0; j < 6; j++) {
            if ((j & 1) == 0) {
                soffset = (6 - ((i & 12) >> 1)) % 6;
                toffset = (12 - ((j & 6) << 1)) % 12;
            } else {
                soffset = (i & 12) >> 1;
                toffset = (j & 6) << 1;
            }
            tsbondtbl[i][j] = (j & 1) + (((j & 6) + soffset) % 6);
            stbondtbl[i][j] = (i & 3) + (((i & 12) + toffset) % 12);
        }
    }

    // i = t.ver, j = s.shver
    for (i = 0; i < 12; i++) {
        for (j = 0; j < 6; j++) {
            if ((j & 1) == 0) {
                soffset = (i & 12) >> 1;
                toffset = (j & 6) << 1;
            } else {
                soffset = (6 - ((i & 12) >> 1)) % 6;
                toffset = (12 - ((j & 6) << 1)) % 12;
            }
            tspivottbl[i][j] = (j & 1) + (((j & 6) + soffset) % 6);
            stpivottbl[i][j] = (i & 3) + (((i & 12) + toffset) % 12);
        }
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// restart()    Deallocate all objects in this pool.                         //
//                                                                           //
// The pool returns to a fresh state, like after it was initialized, except  //
// that no memory is freed to the operating system.  Rather, the previously  //
// allocated blocks are ready to be used.                                    //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::arraypool::restart() { objects = 0l; }

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// poolinit()    Initialize an arraypool for allocation of objects.          //
//                                                                           //
// Before the pool may be used, it must be initialized by this procedure.    //
// After initialization, memory can be allocated and freed in this pool.     //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::arraypool::poolinit(int sizeofobject, int log2objperblk) {
    // Each object must be at least one byte long.
    objectbytes = sizeofobject > 1 ? sizeofobject : 1;

    log2objectsperblock = log2objperblk;
    // Compute the number of objects in each block.
    objectsperblock = ((int)1) << log2objectsperblock;
    objectsperblockmark = objectsperblock - 1;

    // No memory has been allocated.
    totalmemory = 0l;
    // The top array has not been allocated yet.
    toparray = (char**)NULL;
    toparraylen = 0;

    // Ready all indices to be allocated.
    restart();
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// arraypool()    The constructor and destructor.                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

tetgenmesh::arraypool::arraypool(int sizeofobject, int log2objperblk) {
    poolinit(sizeofobject, log2objperblk);
}

tetgenmesh::arraypool::~arraypool() {
    int i;

    // Has anything been allocated at all?
    if (toparray != (char**)NULL) {
        // Walk through the top array.
        for (i = 0; i < toparraylen; i++) {
            // Check every pointer; NULLs may be scattered randomly.
            if (toparray[i] != (char*)NULL) {
                // Free an allocated block.
                free((void*)toparray[i]);
            }
        }
        // Free the top array.
        free((void*)toparray);
    }

    // The top array is no longer allocated.
    toparray = (char**)NULL;
    toparraylen = 0;
    objects = 0;
    totalmemory = 0;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// getblock()    Return (and perhaps create) the block containing the object //
//               with a given index.                                         //
//                                                                           //
// This function takes care of allocating or resizing the top array if nece- //
// ssary, and of allocating the block if it hasn't yet been allocated.       //
//                                                                           //
// Return a pointer to the beginning of the block (NOT the object).          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

char* tetgenmesh::arraypool::getblock(int objectindex) {
    char** newarray;
    char* block;
    int newsize;
    int topindex;
    int i;

    // Compute the index in the top array (upper bits).
    topindex = objectindex >> log2objectsperblock;
    // Does the top array need to be allocated or resized?
    if (toparray == (char**)NULL) {
        // Allocate the top array big enough to hold 'topindex', and NULL out
        //   its contents.
        newsize = topindex + 128;
        toparray = (char**)malloc((size_t)(newsize * sizeof(char*)));
        toparraylen = newsize;
        for (i = 0; i < newsize; i++) {
            toparray[i] = (char*)NULL;
        }
        // Account for the memory.
        totalmemory = newsize * (uintptr_t)sizeof(char*);
    } else if (topindex >= toparraylen) {
        // Resize the top array, making sure it holds 'topindex'.
        newsize = 3 * toparraylen;
        if (topindex >= newsize) {
            newsize = topindex + 128;
        }
        // Allocate the new array, copy the contents, NULL out the rest, and
        //   free the old array.
        newarray = (char**)malloc((size_t)(newsize * sizeof(char*)));
        for (i = 0; i < toparraylen; i++) {
            newarray[i] = toparray[i];
        }
        for (i = toparraylen; i < newsize; i++) {
            newarray[i] = (char*)NULL;
        }
        free(toparray);
        // Account for the memory.
        totalmemory += (newsize - toparraylen) * sizeof(char*);
        toparray = newarray;
        toparraylen = newsize;
    }

    // Find the block, or learn that it hasn't been allocated yet.
    block = toparray[topindex];
    if (block == (char*)NULL) {
        // Allocate a block at this index.
        block = (char*)malloc((size_t)(objectsperblock * objectbytes));
        toparray[topindex] = block;
        // Account for the memory.
        totalmemory += objectsperblock * objectbytes;
    }

    // Return a pointer to the block.
    return block;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// lookup()    Return the pointer to the object with a given index, or NULL  //
//             if the object's block doesn't exist yet.                      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void* tetgenmesh::arraypool::lookup(int objectindex) {
    char* block;
    int topindex;

    // Has the top array been allocated yet?
    if (toparray == (char**)NULL) {
        return (void*)NULL;
    }

    // Compute the index in the top array (upper bits).
    topindex = objectindex >> log2objectsperblock;
    // Does the top index fit in the top array?
    if (topindex >= toparraylen) {
        return (void*)NULL;
    }

    // Find the block, or learn that it hasn't been allocated yet.
    block = toparray[topindex];
    if (block == (char*)NULL) {
        return (void*)NULL;
    }

    // Compute a pointer to the object with the given index.  Note that
    //   'objectsperblock' is a power of two, so the & operation is a bit mask
    //   that preserves the lower bits.
    return (void*)(block + (objectindex & (objectsperblock - 1)) * objectbytes);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// newindex()    Allocate space for a fresh object from the pool.            //
//                                                                           //
// 'newptr' returns a pointer to the new object (it must not be a NULL).     //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::arraypool::newindex(void** newptr) {
    // Allocate an object at index 'firstvirgin'.
    int newindex = objects;
    *newptr = (void*)(getblock(objects) + (objects & (objectsperblock - 1)) * objectbytes);
    objects++;

    return newindex;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// memorypool()   The constructors of memorypool.                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

tetgenmesh::memorypool::memorypool() {
    firstblock = nowblock = (void**)NULL;
    nextitem = (void*)NULL;
    deaditemstack = (void*)NULL;
    pathblock = (void**)NULL;
    pathitem = (void*)NULL;
    alignbytes = 0;
    itembytes = itemwords = 0;
    itemsperblock = 0;
    items = maxitems = 0l;
    unallocateditems = 0;
    pathitemsleft = 0;
}

tetgenmesh::memorypool::memorypool(int bytecount, int itemcount, int wsize, int alignment) {
    poolinit(bytecount, itemcount, wsize, alignment);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// ~memorypool()   Free to the operating system all memory taken by a pool.  //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

tetgenmesh::memorypool::~memorypool() {
    while (firstblock != (void**)NULL) {
        nowblock = (void**)*(firstblock);
        free(firstblock);
        firstblock = nowblock;
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// poolinit()    Initialize a pool of memory for allocation of items.        //
//                                                                           //
// A `pool' is created whose records have size at least `bytecount'.  Items  //
// will be allocated in `itemcount'-item blocks.  Each item is assumed to be //
// a collection of words, and either pointers or floating-point values are   //
// assumed to be the "primary" word type.  (The "primary" word type is used  //
// to determine alignment of items.)  If `alignment' isn't zero, all items   //
// will be `alignment'-byte aligned in memory.  `alignment' must be either a //
// multiple or a factor of the primary word size;  powers of two are safe.   //
// `alignment' is normally used to create a few unused bits at the bottom of //
// each item's pointer, in which information may be stored.                  //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::memorypool::poolinit(int bytecount, int itemcount, int wordsize, int alignment) {
    // Find the proper alignment, which must be at least as large as:
    //   - The parameter `alignment'.
    //   - The primary word type, to avoid unaligned accesses.
    //   - sizeof(void *), so the stack of dead items can be maintained
    //       without unaligned accesses.
    if (alignment > wordsize) {
        alignbytes = alignment;
    } else {
        alignbytes = wordsize;
    }
    if ((int)sizeof(void*) > alignbytes) {
        alignbytes = (int)sizeof(void*);
    }
    itemwords = ((bytecount + alignbytes - 1) / alignbytes) * (alignbytes / wordsize);
    itembytes = itemwords * wordsize;
    itemsperblock = itemcount;

    // Allocate a block of items.  Space for `itemsperblock' items and one
    //   pointer (to point to the next block) are allocated, as well as space
    //   to ensure alignment of the items.
    firstblock = (void**)malloc(itemsperblock * itembytes + sizeof(void*) + alignbytes);
    if (firstblock == (void**)NULL) {
        terminatetetgen(NULL, 1);
    }
    // Set the next block pointer to NULL.
    *(firstblock) = (void*)NULL;
    restart();
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// restart()   Deallocate all items in this pool.                            //
//                                                                           //
// The pool is returned to its starting state, except that no memory is      //
// freed to the operating system.  Rather, the previously allocated blocks   //
// are ready to be reused.                                                   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::memorypool::restart() {
    uintptr_t alignptr;

    items = 0;
    maxitems = 0;

    // Set the currently active block.
    nowblock = firstblock;
    // Find the first item in the pool.  Increment by the size of (void *).
    alignptr = (uintptr_t)(nowblock + 1);
    // Align the item on an `alignbytes'-byte boundary.
    nextitem = (void*)(alignptr + (uintptr_t)alignbytes - (alignptr % (uintptr_t)alignbytes));
    // There are lots of unallocated items left in this block.
    unallocateditems = itemsperblock;
    // The stack of deallocated items is empty.
    deaditemstack = (void*)NULL;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// alloc()   Allocate space for an item.                                     //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void* tetgenmesh::memorypool::alloc() {
    void* newitem;
    void** newblock;
    uintptr_t alignptr;

    // First check the linked list of dead items.  If the list is not
    //   empty, allocate an item from the list rather than a fresh one.
    if (deaditemstack != (void*)NULL) {
        newitem = deaditemstack; // Take first item in list.
        deaditemstack = *(void**)deaditemstack;
    } else {
        // Check if there are any free items left in the current block.
        if (unallocateditems == 0) {
            // Check if another block must be allocated.
            if (*nowblock == (void*)NULL) {
                // Allocate a new block of items, pointed to by the previous block.
                newblock = (void**)malloc(itemsperblock * itembytes + sizeof(void*) + alignbytes);
                if (newblock == (void**)NULL) {
                    terminatetetgen(NULL, 1);
                }
                *nowblock = (void*)newblock;
                // The next block pointer is NULL.
                *newblock = (void*)NULL;
            }
            // Move to the new block.
            nowblock = (void**)*nowblock;
            // Find the first item in the block.
            //   Increment by the size of (void *).
            alignptr = (uintptr_t)(nowblock + 1);
            // Align the item on an `alignbytes'-byte boundary.
            nextitem =
                (void*)(alignptr + (uintptr_t)alignbytes - (alignptr % (uintptr_t)alignbytes));
            // There are lots of unallocated items left in this block.
            unallocateditems = itemsperblock;
        }
        // Allocate a new item.
        newitem = nextitem;
        // Advance `nextitem' pointer to next free item in block.
        nextitem = (void*)((uintptr_t)nextitem + itembytes);
        unallocateditems--;
        maxitems++;
    }
    items++;
    return newitem;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// dealloc()   Deallocate space for an item.                                 //
//                                                                           //
// The deallocated space is stored in a queue for later reuse.               //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::memorypool::dealloc(void* dyingitem) {
    // Push freshly killed item onto stack.
    *((void**)dyingitem) = deaditemstack;
    deaditemstack = dyingitem;
    items--;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// traversalinit()   Prepare to traverse the entire list of items.           //
//                                                                           //
// This routine is used in conjunction with traverse().                      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::memorypool::traversalinit() {
    uintptr_t alignptr;

    // Begin the traversal in the first block.
    pathblock = firstblock;
    // Find the first item in the block.  Increment by the size of (void *).
    alignptr = (uintptr_t)(pathblock + 1);
    // Align with item on an `alignbytes'-byte boundary.
    pathitem = (void*)(alignptr + (uintptr_t)alignbytes - (alignptr % (uintptr_t)alignbytes));
    // Set the number of items left in the current block.
    pathitemsleft = itemsperblock;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// traverse()   Find the next item in the list.                              //
//                                                                           //
// This routine is used in conjunction with traversalinit().  Be forewarned  //
// that this routine successively returns all items in the list, including   //
// deallocated ones on the deaditemqueue. It's up to you to figure out which //
// ones are actually dead.  It can usually be done more space-efficiently by //
// a routine that knows something about the structure of the item.           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void* tetgenmesh::memorypool::traverse() {
    void* newitem;
    uintptr_t alignptr;

    // Stop upon exhausting the list of items.
    if (pathitem == nextitem) {
        return (void*)NULL;
    }
    // Check whether any untraversed items remain in the current block.
    if (pathitemsleft == 0) {
        // Find the next block.
        pathblock = (void**)*pathblock;
        // Find the first item in the block.  Increment by the size of (void *).
        alignptr = (uintptr_t)(pathblock + 1);
        // Align with item on an `alignbytes'-byte boundary.
        pathitem = (void*)(alignptr + (uintptr_t)alignbytes - (alignptr % (uintptr_t)alignbytes));
        // Set the number of items left in the current block.
        pathitemsleft = itemsperblock;
    }
    newitem = pathitem;
    // Find the next item in the block.
    pathitem = (void*)((uintptr_t)pathitem + itembytes);
    pathitemsleft--;
    return newitem;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// makeindex2pointmap()    Create a map from index to vertices.              //
//                                                                           //
// 'idx2verlist' returns the created map.  Traverse all vertices, a pointer  //
// to each vertex is set into the array.  The pointer to the first vertex is //
// saved in 'idx2verlist[in->firstnumber]'.                                  //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::makeindex2pointmap(point*& idx2verlist) {
    point pointloop;
    int idx;

    if (b->verbose > 1) {
        printf("  Constructing mapping from indices to points.\n");
    }

    idx2verlist = new point[points->items + 1];

    points->traversalinit();
    pointloop = pointtraverse();
    idx = in->firstnumber;
    while (pointloop != (point)NULL) {
        idx2verlist[idx++] = pointloop;
        pointloop = pointtraverse();
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// makesubfacemap()    Create a map from vertex to subfaces incident at it.  //
//                                                                           //
// The map is returned in two arrays 'idx2faclist' and 'facperverlist'.  All //
// subfaces incident at i-th vertex (i is counted from 0) are found in the   //
// array facperverlist[j], where idx2faclist[i] <= j < idx2faclist[i + 1].   //
// Each entry in facperverlist[j] is a subface whose origin is the vertex.   //
//                                                                           //
// NOTE: These two arrays will be created inside this routine, don't forget  //
// to free them after using.                                                 //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::makepoint2submap(memorypool* pool, int*& idx2faclist, face*& facperverlist) {
    face shloop;
    int i, j, k;

    if (b->verbose > 1) {
        printf("  Making a map from points to subfaces.\n");
    }

    // Initialize 'idx2faclist'.
    idx2faclist = new int[points->items + 1];
    for (i = 0; i < points->items + 1; i++)
        idx2faclist[i] = 0;

    // Loop all subfaces, counter the number of subfaces incident at a vertex.
    pool->traversalinit();
    shloop.sh = shellfacetraverse(pool);
    while (shloop.sh != (shellface*)NULL) {
        // Increment the number of incident subfaces for each vertex.
        j = pointmark((point)shloop.sh[3]) - in->firstnumber;
        idx2faclist[j]++;
        j = pointmark((point)shloop.sh[4]) - in->firstnumber;
        idx2faclist[j]++;
        // Skip the third corner if it is a segment.
        if (shloop.sh[5] != NULL) {
            j = pointmark((point)shloop.sh[5]) - in->firstnumber;
            idx2faclist[j]++;
        }
        shloop.sh = shellfacetraverse(pool);
    }

    // Calculate the total length of array 'facperverlist'.
    j = idx2faclist[0];
    idx2faclist[0] = 0; // Array starts from 0 element.
    for (i = 0; i < points->items; i++) {
        k = idx2faclist[i + 1];
        idx2faclist[i + 1] = idx2faclist[i] + j;
        j = k;
    }

    // The total length is in the last unit of idx2faclist.
    facperverlist = new face[idx2faclist[i]];

    // Loop all subfaces again, remember the subfaces at each vertex.
    pool->traversalinit();
    shloop.sh = shellfacetraverse(pool);
    while (shloop.sh != (shellface*)NULL) {
        j = pointmark((point)shloop.sh[3]) - in->firstnumber;
        shloop.shver = 0; // save the origin.
        facperverlist[idx2faclist[j]] = shloop;
        idx2faclist[j]++;
        // Is it a subface or a subsegment?
        if (shloop.sh[5] != NULL) {
            j = pointmark((point)shloop.sh[4]) - in->firstnumber;
            shloop.shver = 2; // save the origin.
            facperverlist[idx2faclist[j]] = shloop;
            idx2faclist[j]++;
            j = pointmark((point)shloop.sh[5]) - in->firstnumber;
            shloop.shver = 4; // save the origin.
            facperverlist[idx2faclist[j]] = shloop;
            idx2faclist[j]++;
        } else {
            j = pointmark((point)shloop.sh[4]) - in->firstnumber;
            shloop.shver = 1; // save the origin.
            facperverlist[idx2faclist[j]] = shloop;
            idx2faclist[j]++;
        }
        shloop.sh = shellfacetraverse(pool);
    }

    // Contents in 'idx2faclist' are shifted, now shift them back.
    for (i = points->items - 1; i >= 0; i--) {
        idx2faclist[i + 1] = idx2faclist[i];
    }
    idx2faclist[0] = 0;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// tetrahedrondealloc()    Deallocate space for a tet., marking it dead.     //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::tetrahedrondealloc(tetrahedron* dyingtetrahedron) {
    // Set tetrahedron's vertices to NULL. This makes it possible to detect
    //   dead tetrahedra when traversing the list of all tetrahedra.
    dyingtetrahedron[4] = (tetrahedron)NULL;

    // Dealloc the space to subfaces/subsegments.
    if (dyingtetrahedron[8] != NULL) {
        tet2segpool->dealloc((shellface*)dyingtetrahedron[8]);
    }
    if (dyingtetrahedron[9] != NULL) {
        tet2subpool->dealloc((shellface*)dyingtetrahedron[9]);
    }

    tetrahedrons->dealloc((void*)dyingtetrahedron);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// tetrahedrontraverse()    Traverse the tetrahedra, skipping dead ones.     //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

tetgenmesh::tetrahedron* tetgenmesh::tetrahedrontraverse() {
    tetrahedron* newtetrahedron;

    do {
        newtetrahedron = (tetrahedron*)tetrahedrons->traverse();
        if (newtetrahedron == (tetrahedron*)NULL) {
            return (tetrahedron*)NULL;
        }
    } while ((newtetrahedron[4] == (tetrahedron)NULL) || ((point)newtetrahedron[7] == dummypoint));
    return newtetrahedron;
}

tetgenmesh::tetrahedron* tetgenmesh::alltetrahedrontraverse() {
    tetrahedron* newtetrahedron;

    do {
        newtetrahedron = (tetrahedron*)tetrahedrons->traverse();
        if (newtetrahedron == (tetrahedron*)NULL) {
            return (tetrahedron*)NULL;
        }
    } while (newtetrahedron[4] == (tetrahedron)NULL); // Skip dead ones.
    return newtetrahedron;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// shellfacedealloc()    Deallocate space for a shellface, marking it dead.  //
//                       Used both for dealloc a subface and subsegment.     //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::shellfacedealloc(memorypool* pool, shellface* dyingsh) {
    // Set shellface's vertices to NULL. This makes it possible to detect dead
    //   shellfaces when traversing the list of all shellfaces.
    dyingsh[3] = (shellface)NULL;
    pool->dealloc((void*)dyingsh);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// shellfacetraverse()    Traverse the subfaces, skipping dead ones. Used    //
//                        for both subfaces and subsegments pool traverse.   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

tetgenmesh::shellface* tetgenmesh::shellfacetraverse(memorypool* pool) {
    shellface* newshellface;

    do {
        newshellface = (shellface*)pool->traverse();
        if (newshellface == (shellface*)NULL) {
            return (shellface*)NULL;
        }
    } while (newshellface[3] == (shellface)NULL); // Skip dead ones.
    return newshellface;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// pointdealloc()    Deallocate space for a point, marking it dead.          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::pointdealloc(point dyingpoint) {
    // Mark the point as dead. This  makes it possible to detect dead points
    //   when traversing the list of all points.
    setpointtype(dyingpoint, DEADVERTEX);
    points->dealloc((void*)dyingpoint);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// pointtraverse()    Traverse the points, skipping dead ones.               //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

tetgenmesh::point tetgenmesh::pointtraverse() {
    point newpoint;

    do {
        newpoint = (point)points->traverse();
        if (newpoint == (point)NULL) {
            return (point)NULL;
        }
    } while (pointtype(newpoint) == DEADVERTEX); // Skip dead ones.
    return newpoint;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// maketetrahedron()    Create a new tetrahedron.                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::maketetrahedron(triface* newtet) {
    newtet->tet = (tetrahedron*)tetrahedrons->alloc();

    // Initialize the four adjoining tetrahedra to be "outer space".
    newtet->tet[0] = NULL;
    newtet->tet[1] = NULL;
    newtet->tet[2] = NULL;
    newtet->tet[3] = NULL;
    // Four NULL vertices.
    newtet->tet[4] = NULL;
    newtet->tet[5] = NULL;
    newtet->tet[6] = NULL;
    newtet->tet[7] = NULL;
    // No attached segments and subfaces yet.
    newtet->tet[8] = NULL;
    newtet->tet[9] = NULL;
    // Initialize the marker (clear all flags).
    setelemmarker(newtet->tet, 0);
    for (int i = 0; i < numelemattrib; i++) {
        setelemattribute(newtet->tet, i, 0.0);
    }
    if (b->varvolume) {
        setvolumebound(newtet->tet, -1.0);
    }

    // Initialize the version to be Zero.
    newtet->ver = 11;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// makeshellface()    Create a new shellface with version zero. Used for     //
//                    both subfaces and subsegments.                         //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::makeshellface(memorypool* pool, face* newface) {
    newface->sh = (shellface*)pool->alloc();

    // No adjointing subfaces.
    newface->sh[0] = NULL;
    newface->sh[1] = NULL;
    newface->sh[2] = NULL;
    // Three NULL vertices.
    newface->sh[3] = NULL;
    newface->sh[4] = NULL;
    newface->sh[5] = NULL;
    // No adjoining subsegments.
    newface->sh[6] = NULL;
    newface->sh[7] = NULL;
    newface->sh[8] = NULL;
    // No adjoining tetrahedra.
    newface->sh[9] = NULL;
    newface->sh[10] = NULL;
    if (checkconstraints) {
        // Initialize the maximum area bound.
        setareabound(*newface, 0.0);
    }
    // Set the boundary marker to zero.
    setshellmark(*newface, 0);
    // Clear the infection and marktest bits.
    ((int*)(newface->sh))[shmarkindex + 1] = 0;
    if (useinsertradius) {
        setfacetindex(*newface, 0);
    }

    newface->shver = 0;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// makepoint()    Create a new point.                                        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::makepoint(point* pnewpoint, enum verttype vtype) {
    int i;

    *pnewpoint = (point)points->alloc();

    // Initialize the point attributes.
    for (i = 0; i < numpointattrib; i++) {
        (*pnewpoint)[3 + i] = 0.0;
    }
    // Initialize the metric tensor.
    for (i = 0; i < sizeoftensor; i++) {
        (*pnewpoint)[pointmtrindex + i] = 0.0;
    }
    setpoint2tet(*pnewpoint, NULL);
    setpoint2ppt(*pnewpoint, NULL);
    if (b->plc || b->refine) {
        // Initialize the point-to-simplex field.
        setpoint2sh(*pnewpoint, NULL);
        if (b->metric && (bgm != NULL)) {
            setpoint2bgmtet(*pnewpoint, NULL);
        }
    }
    // Initialize the point marker (starting from in->firstnumber).
    setpointmark(*pnewpoint, (int)(points->items) - (!in->firstnumber));
    // Clear all flags.
    ((int*)(*pnewpoint))[pointmarkindex + 1] = 0;
    // Initialize (set) the point type.
    setpointtype(*pnewpoint, vtype);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// initializepools()    Calculate the sizes of the point, tetrahedron, and   //
//                      subface. Initialize their memory pools.              //
//                                                                           //
// This routine also computes the indices 'pointmarkindex', 'point2simindex',//
// 'point2pbcptindex', 'elemattribindex', and 'volumeboundindex'.  They are  //
// used to find values within each point and tetrahedron, respectively.      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::initializepools() {
    int pointsize = 0, elesize = 0, shsize = 0;
    int i;

    if (b->verbose) {
        printf("  Initializing memorypools.\n");
        printf("  tetrahedron per block: %d.\n", b->tetrahedraperblock);
    }

    inittables();

    // There are three input point lists available, which are in, addin,
    //   and bgm->in. These point lists may have different number of
    //   attributes. Decide the maximum number.
    numpointattrib = in->numberofpointattributes;
    if (bgm != NULL) {
        if (bgm->in->numberofpointattributes > numpointattrib) {
            numpointattrib = bgm->in->numberofpointattributes;
        }
    }
    if (addin != NULL) {
        if (addin->numberofpointattributes > numpointattrib) {
            numpointattrib = addin->numberofpointattributes;
        }
    }
    if (b->weighted || b->flipinsert) { // -w or -L.
        // The internal number of point attribute needs to be at least 1
        //   (for storing point weights).
        if (numpointattrib == 0) {
            numpointattrib = 1;
        }
    }

    // Default varconstraint = 0;
    if (in->segmentconstraintlist || in->facetconstraintlist) {
        checkconstraints = 1;
    }
    if (b->plc || b->refine) {
        // Save the insertion radius for Steiner points if boundaries
        //   are allowed be split.
        if (!b->nobisect || checkconstraints) {
            useinsertradius = 1;
        }
    }

    // The index within each point at which its metric tensor is found.
    // Each vertex has three coordinates.
    if (b->psc) {
        // '-s' option (PSC), the u,v coordinates are provided.
        pointmtrindex = 5 + numpointattrib;
        // The index within each point at which its u, v coordinates are found.
        // Comment: They are saved after the list of point attributes.
        pointparamindex = pointmtrindex - 2;
    } else {
        pointmtrindex = 3 + numpointattrib;
    }
    // For '-m' option. A tensor field is provided (*.mtr or *.b.mtr file).
    if (b->metric) {
        // Decide the size (1, 3, or 6) of the metric tensor.
        if (bgm != (tetgenmesh*)NULL) {
            // A background mesh is allocated. It may not exist though.
            sizeoftensor =
                (bgm->in != (tetgenio*)NULL) ? bgm->in->numberofpointmtrs : in->numberofpointmtrs;
        } else {
            // No given background mesh - Itself is a background mesh.
            sizeoftensor = in->numberofpointmtrs;
        }
        // Make sure sizeoftensor is at least 1.
        sizeoftensor = (sizeoftensor > 0) ? sizeoftensor : 1;
    } else {
        // For '-q' option. Make sure to have space for saving a scalar value.
        sizeoftensor = b->quality ? 1 : 0;
    }
    if (useinsertradius) {
        // Increase a space (REAL) for saving point insertion radius, it is
        //   saved directly after the metric.
        sizeoftensor++;
    }
    pointinsradiusindex = pointmtrindex + sizeoftensor - 1;
    // The index within each point at which an element pointer is found, where
    //   the index is measured in pointers. Ensure the index is aligned to a
    //   sizeof(tetrahedron)-byte address.
    point2simindex = ((pointmtrindex + sizeoftensor) * sizeof(REAL) + sizeof(tetrahedron) - 1) /
                     sizeof(tetrahedron);
    if (b->plc || b->refine || b->voroout) {
        // Increase the point size by three pointers, which are:
        //   - a pointer to a tet, read by point2tet();
        //   - a pointer to a parent point, read by point2ppt()).
        //   - a pointer to a subface or segment, read by point2sh();
        if (b->metric && (bgm != (tetgenmesh*)NULL)) {
            // Increase one pointer into the background mesh, point2bgmtet().
            pointsize = (point2simindex + 4) * sizeof(tetrahedron);
        } else {
            pointsize = (point2simindex + 3) * sizeof(tetrahedron);
        }
    } else {
        // Increase the point size by two pointer, which are:
        //   - a pointer to a tet, read by point2tet();
        //   - a pointer to a parent point, read by point2ppt()). -- Used by btree.
        pointsize = (point2simindex + 2) * sizeof(tetrahedron);
    }
    // The index within each point at which the boundary marker is found,
    //   Ensure the point marker is aligned to a sizeof(int)-byte address.
    pointmarkindex = (pointsize + sizeof(int) - 1) / sizeof(int);
    // Now point size is the ints (indicated by pointmarkindex) plus:
    //   - an integer for boundary marker;
    //   - an integer for vertex type;
    //   - an integer for geometry tag (optional, -s option).
    pointsize = (pointmarkindex + 2 + (b->psc ? 1 : 0)) * sizeof(tetrahedron);

    // Initialize the pool of vertices.
    points = new memorypool(pointsize, b->vertexperblock, sizeof(REAL), 0);

    if (b->verbose) {
        printf("  Size of a point: %d bytes.\n", points->itembytes);
    }

    // Initialize the infinite vertex.
    dummypoint = (point) new char[pointsize];
    // Initialize all fields of this point.
    dummypoint[0] = 0.0;
    dummypoint[1] = 0.0;
    dummypoint[2] = 0.0;
    for (i = 0; i < numpointattrib; i++) {
        dummypoint[3 + i] = 0.0;
    }
    // Initialize the metric tensor.
    for (i = 0; i < sizeoftensor; i++) {
        dummypoint[pointmtrindex + i] = 0.0;
    }
    setpoint2tet(dummypoint, NULL);
    setpoint2ppt(dummypoint, NULL);
    if (b->plc || b->psc || b->refine) {
        // Initialize the point-to-simplex field.
        setpoint2sh(dummypoint, NULL);
        if (b->metric && (bgm != NULL)) {
            setpoint2bgmtet(dummypoint, NULL);
        }
    }
    // Initialize the point marker (starting from in->firstnumber).
    setpointmark(dummypoint, -1); // The unique marker for dummypoint.
    // Clear all flags.
    ((int*)(dummypoint))[pointmarkindex + 1] = 0;
    // Initialize (set) the point type.
    setpointtype(dummypoint, UNUSEDVERTEX); // Does not matter.

    // The number of bytes occupied by a tetrahedron is varying by the user-
    //   specified options. The contents of the first 12 pointers are listed
    //   in the following table:
    //     [0]  |__ neighbor at f0 __|
    //     [1]  |__ neighbor at f1 __|
    //     [2]  |__ neighbor at f2 __|
    //     [3]  |__ neighbor at f3 __|
    //     [4]  |_____ vertex p0 ____|
    //     [5]  |_____ vertex p1 ____|
    //     [6]  |_____ vertex p2 ____|
    //     [7]  |_____ vertex p3 ____|
    //     [8]  |__ segments array __| (used by -p)
    //     [9]  |__ subfaces array __| (used by -p)
    //    [10]  |_____ reserved _____|
    //    [11]  |___ elem marker ____| (used as an integer)

    elesize = 12 * sizeof(tetrahedron);

    // The index to find the element markers. An integer containing varies
    //   flags and element counter.
    if (!(sizeof(int) <= sizeof(tetrahedron)) || ((sizeof(tetrahedron) % sizeof(int)))) {
        terminatetetgen(this, 2);
    }
    elemmarkerindex = (elesize - sizeof(tetrahedron)) / sizeof(int);

    // The actual number of element attributes. Note that if the
    //   `b->regionattrib' flag is set, an additional attribute will be added.
    numelemattrib = in->numberoftetrahedronattributes + (b->regionattrib > 0);

    // The index within each element at which its attributes are found, where
    //   the index is measured in REALs.
    elemattribindex = (elesize + sizeof(REAL) - 1) / sizeof(REAL);
    // The index within each element at which the maximum volume bound is
    //   found, where the index is measured in REALs.
    volumeboundindex = elemattribindex + numelemattrib;
    // If element attributes or an constraint are needed, increase the number
    //   of bytes occupied by an element.
    if (b->varvolume) {
        elesize = (volumeboundindex + 1) * sizeof(REAL);
    } else if (numelemattrib > 0) {
        elesize = volumeboundindex * sizeof(REAL);
    }

    // Having determined the memory size of an element, initialize the pool.
    tetrahedrons = new memorypool(elesize, b->tetrahedraperblock, sizeof(void*), 16);

    if (b->verbose) {
        printf("  Size of a tetrahedron: %d (%d) bytes.\n", elesize, tetrahedrons->itembytes);
    }

    if (b->plc || b->refine) { // if (b->useshelles) {
        // The number of bytes occupied by a subface.  The list of pointers
        //   stored in a subface are: three to other subfaces, three to corners,
        //   three to subsegments, two to tetrahedra.
        shsize = 11 * sizeof(shellface);
        // The index within each subface at which the maximum area bound is
        //   found, where the index is measured in REALs.
        areaboundindex = (shsize + sizeof(REAL) - 1) / sizeof(REAL);
        // If -q switch is in use, increase the number of bytes occupied by
        //   a subface for saving maximum area bound.
        if (checkconstraints) {
            shsize = (areaboundindex + 1) * sizeof(REAL);
        } else {
            shsize = areaboundindex * sizeof(REAL);
        }
        // The index within subface at which the facet marker is found. Ensure
        //   the marker is aligned to a sizeof(int)-byte address.
        shmarkindex = (shsize + sizeof(int) - 1) / sizeof(int);
        // Increase the number of bytes by two or three integers, one for facet
        //   marker, one for shellface type and flags, and optionally one
        //   for storing facet index (for mesh refinement).
        shsize = (shmarkindex + 2 + useinsertradius) * sizeof(shellface);

        // Initialize the pool of subfaces. Each subface record is eight-byte
        //   aligned so it has room to store an edge version (from 0 to 5) in
        //   the least three bits.
        subfaces = new memorypool(shsize, b->shellfaceperblock, sizeof(void*), 8);

        if (b->verbose) {
            printf("  Size of a shellface: %d (%d) bytes.\n", shsize, subfaces->itembytes);
        }

        // Initialize the pool of subsegments. The subsegment's record is same
        //   with subface.
        subsegs = new memorypool(shsize, b->shellfaceperblock, sizeof(void*), 8);

        // Initialize the pool for tet-subseg connections.
        tet2segpool = new memorypool(6 * sizeof(shellface), b->shellfaceperblock, sizeof(void*), 0);
        // Initialize the pool for tet-subface connections.
        tet2subpool = new memorypool(4 * sizeof(shellface), b->shellfaceperblock, sizeof(void*), 0);

        // Initialize arraypools for segment & facet recovery.
        subsegstack = new arraypool(sizeof(face), 10);
        subfacstack = new arraypool(sizeof(face), 10);
        subvertstack = new arraypool(sizeof(point), 8);

        // Initialize arraypools for surface point insertion/deletion.
        caveshlist = new arraypool(sizeof(face), 8);
        caveshbdlist = new arraypool(sizeof(face), 8);
        cavesegshlist = new arraypool(sizeof(face), 4);

        cavetetshlist = new arraypool(sizeof(face), 8);
        cavetetseglist = new arraypool(sizeof(face), 8);
        caveencshlist = new arraypool(sizeof(face), 8);
        caveencseglist = new arraypool(sizeof(face), 8);
    }

    // Initialize the pools for flips.
    flippool = new memorypool(sizeof(badface), 1024, sizeof(void*), 0);
    unflipqueue = new arraypool(sizeof(badface), 10);

    // Initialize the arraypools for point insertion.
    cavetetlist = new arraypool(sizeof(triface), 10);
    cavebdrylist = new arraypool(sizeof(triface), 10);
    caveoldtetlist = new arraypool(sizeof(triface), 10);
    cavetetvertlist = new arraypool(sizeof(point), 10);
}

////                                                                       ////
////                                                                       ////
//// mempool_cxx //////////////////////////////////////////////////////////////

//// geom_cxx /////////////////////////////////////////////////////////////////
////                                                                       ////
////                                                                       ////

// PI is the ratio of a circle's circumference to its diameter.
REAL tetgenmesh::PI = 3.14159265358979323846264338327950288419716939937510582;

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// insphere_s()    Insphere test with symbolic perturbation.                 //
//                                                                           //
// Given four points pa, pb, pc, and pd, test if the point pe lies inside or //
// outside the circumscribed sphere of the four points.                      //
//                                                                           //
// Here we assume that the 3d orientation of the point sequence {pa, pb, pc, //
// pd} is positive (NOT zero), i.e., pd lies above the plane passing through //
// points pa, pb, and pc. Otherwise, the returned sign is flipped.           //
//                                                                           //
// Return a positive value (> 0) if pe lies inside, a negative value (< 0)   //
// if pe lies outside the sphere, the returned value will not be zero.       //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

REAL tetgenmesh::insphere_s(REAL* pa, REAL* pb, REAL* pc, REAL* pd, REAL* pe) {
    REAL sign;

    sign = insphere(pa, pb, pc, pd, pe);
    if (sign != 0.0) {
        return sign;
    }

    // Symbolic perturbation.
    point pt[5], swappt;
    REAL oriA, oriB;
    int swaps, count;
    int n, i;

    pt[0] = pa;
    pt[1] = pb;
    pt[2] = pc;
    pt[3] = pd;
    pt[4] = pe;

    // Sort the five points such that their indices are in the increasing
    //   order. An optimized bubble sort algorithm is used, i.e., it has
    //   the worst case O(n^2) runtime, but it is usually much faster.
    swaps = 0; // Record the total number of swaps.
    n = 5;
    do {
        count = 0;
        n = n - 1;
        for (i = 0; i < n; i++) {
            if (pointmark(pt[i]) > pointmark(pt[i + 1])) {
                swappt = pt[i];
                pt[i] = pt[i + 1];
                pt[i + 1] = swappt;
                count++;
            }
        }
        swaps += count;
    } while (count > 0); // Continue if some points are swapped.

    oriA = orient3d(pt[1], pt[2], pt[3], pt[4]);
    if (oriA != 0.0) {
        // Flip the sign if there are odd number of swaps.
        if ((swaps % 2) != 0) oriA = -oriA;
        return oriA;
    }

    oriB = -orient3d(pt[0], pt[2], pt[3], pt[4]);
    if (oriB == 0.0) {
        terminatetetgen(this, 2);
    }
    // Flip the sign if there are odd number of swaps.
    if ((swaps % 2) != 0) oriB = -oriB;
    return oriB;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// orient4d_s()    4d orientation test with symbolic perturbation.           //
//                                                                           //
// Given four lifted points pa', pb', pc', and pd' in R^4,test if the lifted //
// point pe' in R^4 lies below or above the hyperplane passing through the   //
// four points pa', pb', pc', and pd'.                                       //
//                                                                           //
// Here we assume that the 3d orientation of the point sequence {pa, pb, pc, //
// pd} is positive (NOT zero), i.e., pd lies above the plane passing through //
// the points pa, pb, and pc. Otherwise, the returned sign is flipped.       //
//                                                                           //
// Return a positive value (> 0) if pe' lies below, a negative value (< 0)   //
// if pe' lies above the hyperplane, the returned value should not be zero.  //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

REAL tetgenmesh::orient4d_s(REAL* pa, REAL* pb, REAL* pc, REAL* pd, REAL* pe, REAL aheight,
                            REAL bheight, REAL cheight, REAL dheight, REAL eheight) {
    REAL sign;

    sign = orient4d(pa, pb, pc, pd, pe, aheight, bheight, cheight, dheight, eheight);
    if (sign != 0.0) {
        return sign;
    }

    // Symbolic perturbation.
    point pt[5], swappt;
    REAL oriA, oriB;
    int swaps, count;
    int n, i;

    pt[0] = pa;
    pt[1] = pb;
    pt[2] = pc;
    pt[3] = pd;
    pt[4] = pe;

    // Sort the five points such that their indices are in the increasing
    //   order. An optimized bubble sort algorithm is used, i.e., it has
    //   the worst case O(n^2) runtime, but it is usually much faster.
    swaps = 0; // Record the total number of swaps.
    n = 5;
    do {
        count = 0;
        n = n - 1;
        for (i = 0; i < n; i++) {
            if (pointmark(pt[i]) > pointmark(pt[i + 1])) {
                swappt = pt[i];
                pt[i] = pt[i + 1];
                pt[i + 1] = swappt;
                count++;
            }
        }
        swaps += count;
    } while (count > 0); // Continue if some points are swapped.

    oriA = orient3d(pt[1], pt[2], pt[3], pt[4]);
    if (oriA != 0.0) {
        // Flip the sign if there are odd number of swaps.
        if ((swaps % 2) != 0) oriA = -oriA;
        return oriA;
    }

    oriB = -orient3d(pt[0], pt[2], pt[3], pt[4]);
    if (oriB == 0.0) {
        terminatetetgen(this, 2);
    }
    // Flip the sign if there are odd number of swaps.
    if ((swaps % 2) != 0) oriB = -oriB;
    return oriB;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// tri_edge_test()    Triangle-edge intersection test.                       //
//                                                                           //
// This routine takes a triangle T (with vertices A, B, C) and an edge E (P, //
// Q) in 3D, and tests if they intersect each other.                         //
//                                                                           //
// If the point 'R' is not NULL, it lies strictly above the plane defined by //
// A, B, C. It is used in test when T and E are coplanar.                    //
//                                                                           //
// If T and E intersect each other, they may intersect in different ways. If //
// 'level' > 0, their intersection type will be reported 'types' and 'pos'.  //
//                                                                           //
// The return value indicates one of the following cases:                    //
//   - 0, T and E are disjoint.                                              //
//   - 1, T and E intersect each other.                                      //
//   - 2, T and E are not coplanar. They intersect at a single point.        //
//   - 4, T and E are coplanar. They intersect at a single point or a line   //
//        segment (if types[1] != DISJOINT).                                 //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#define SETVECTOR3(V, a0, a1, a2)                                                                  \
    (V)[0] = (a0);                                                                                 \
    (V)[1] = (a1);                                                                                 \
    (V)[2] = (a2)

#define SWAP2(a0, a1, tmp)                                                                         \
    (tmp) = (a0);                                                                                  \
    (a0) = (a1);                                                                                   \
    (a1) = (tmp)

int tetgenmesh::tri_edge_2d(point A, point B, point C, point P, point Q, point R, int level,
                            int* types, int* pos) {
    point U[3], V[3]; // The permuted vectors of points.
    int pu[3], pv[3]; // The original positions of points.
    REAL abovept[3];
    REAL sA, sB, sC;
    REAL s1, s2, s3, s4;
    int z1;

    if (R == NULL) {
        // Calculate a lift point.
        if (1) {
            REAL n[3], len;
            // Calculate a lift point, saved in dummypoint.
            facenormal(A, B, C, n, 1, NULL);
            len = sqrt(dot(n, n));
            if (len != 0) {
                n[0] /= len;
                n[1] /= len;
                n[2] /= len;
                len = distance(A, B);
                len += distance(B, C);
                len += distance(C, A);
                len /= 3.0;
                R = abovept; // dummypoint;
                R[0] = A[0] + len * n[0];
                R[1] = A[1] + len * n[1];
                R[2] = A[2] + len * n[2];
            } else {
                // The triangle [A,B,C] is (nearly) degenerate, i.e., it is (close)
                //   to a line.  We need a line-line intersection test.
                // !!! A non-save return value.!!!
                return 0; // DISJOINT
            }
        }
    }

    // Test A's, B's, and C's orientations wrt plane PQR.
    sA = orient3d(P, Q, R, A);
    sB = orient3d(P, Q, R, B);
    sC = orient3d(P, Q, R, C);

    if (sA < 0) {
        if (sB < 0) {
            if (sC < 0) { // (---).
                return 0;
            } else {
                if (sC > 0) { // (--+).
                    // All points are in the right positions.
                    SETVECTOR3(U, A, B, C); // I3
                    SETVECTOR3(V, P, Q, R); // I2
                    SETVECTOR3(pu, 0, 1, 2);
                    SETVECTOR3(pv, 0, 1, 2);
                    z1 = 0;
                } else {                    // (--0).
                    SETVECTOR3(U, A, B, C); // I3
                    SETVECTOR3(V, P, Q, R); // I2
                    SETVECTOR3(pu, 0, 1, 2);
                    SETVECTOR3(pv, 0, 1, 2);
                    z1 = 1;
                }
            }
        } else {
            if (sB > 0) {
                if (sC < 0) {               // (-+-).
                    SETVECTOR3(U, C, A, B); // PT = ST
                    SETVECTOR3(V, P, Q, R); // I2
                    SETVECTOR3(pu, 2, 0, 1);
                    SETVECTOR3(pv, 0, 1, 2);
                    z1 = 0;
                } else {
                    if (sC > 0) {               // (-++).
                        SETVECTOR3(U, B, C, A); // PT = ST x ST
                        SETVECTOR3(V, Q, P, R); // PL = SL
                        SETVECTOR3(pu, 1, 2, 0);
                        SETVECTOR3(pv, 1, 0, 2);
                        z1 = 0;
                    } else {                    // (-+0).
                        SETVECTOR3(U, C, A, B); // PT = ST
                        SETVECTOR3(V, P, Q, R); // I2
                        SETVECTOR3(pu, 2, 0, 1);
                        SETVECTOR3(pv, 0, 1, 2);
                        z1 = 2;
                    }
                }
            } else {
                if (sC < 0) {               // (-0-).
                    SETVECTOR3(U, C, A, B); // PT = ST
                    SETVECTOR3(V, P, Q, R); // I2
                    SETVECTOR3(pu, 2, 0, 1);
                    SETVECTOR3(pv, 0, 1, 2);
                    z1 = 1;
                } else {
                    if (sC > 0) {               // (-0+).
                        SETVECTOR3(U, B, C, A); // PT = ST x ST
                        SETVECTOR3(V, Q, P, R); // PL = SL
                        SETVECTOR3(pu, 1, 2, 0);
                        SETVECTOR3(pv, 1, 0, 2);
                        z1 = 2;
                    } else {                    // (-00).
                        SETVECTOR3(U, B, C, A); // PT = ST x ST
                        SETVECTOR3(V, Q, P, R); // PL = SL
                        SETVECTOR3(pu, 1, 2, 0);
                        SETVECTOR3(pv, 1, 0, 2);
                        z1 = 3;
                    }
                }
            }
        }
    } else {
        if (sA > 0) {
            if (sB < 0) {
                if (sC < 0) {               // (+--).
                    SETVECTOR3(U, B, C, A); // PT = ST x ST
                    SETVECTOR3(V, P, Q, R); // I2
                    SETVECTOR3(pu, 1, 2, 0);
                    SETVECTOR3(pv, 0, 1, 2);
                    z1 = 0;
                } else {
                    if (sC > 0) {               // (+-+).
                        SETVECTOR3(U, C, A, B); // PT = ST
                        SETVECTOR3(V, Q, P, R); // PL = SL
                        SETVECTOR3(pu, 2, 0, 1);
                        SETVECTOR3(pv, 1, 0, 2);
                        z1 = 0;
                    } else {                    // (+-0).
                        SETVECTOR3(U, C, A, B); // PT = ST
                        SETVECTOR3(V, Q, P, R); // PL = SL
                        SETVECTOR3(pu, 2, 0, 1);
                        SETVECTOR3(pv, 1, 0, 2);
                        z1 = 2;
                    }
                }
            } else {
                if (sB > 0) {
                    if (sC < 0) {               // (++-).
                        SETVECTOR3(U, A, B, C); // I3
                        SETVECTOR3(V, Q, P, R); // PL = SL
                        SETVECTOR3(pu, 0, 1, 2);
                        SETVECTOR3(pv, 1, 0, 2);
                        z1 = 0;
                    } else {
                        if (sC > 0) { // (+++).
                            return 0;
                        } else {                    // (++0).
                            SETVECTOR3(U, A, B, C); // I3
                            SETVECTOR3(V, Q, P, R); // PL = SL
                            SETVECTOR3(pu, 0, 1, 2);
                            SETVECTOR3(pv, 1, 0, 2);
                            z1 = 1;
                        }
                    }
                } else {                        // (+0#)
                    if (sC < 0) {               // (+0-).
                        SETVECTOR3(U, B, C, A); // PT = ST x ST
                        SETVECTOR3(V, P, Q, R); // I2
                        SETVECTOR3(pu, 1, 2, 0);
                        SETVECTOR3(pv, 0, 1, 2);
                        z1 = 2;
                    } else {
                        if (sC > 0) {               // (+0+).
                            SETVECTOR3(U, C, A, B); // PT = ST
                            SETVECTOR3(V, Q, P, R); // PL = SL
                            SETVECTOR3(pu, 2, 0, 1);
                            SETVECTOR3(pv, 1, 0, 2);
                            z1 = 1;
                        } else {                    // (+00).
                            SETVECTOR3(U, B, C, A); // PT = ST x ST
                            SETVECTOR3(V, P, Q, R); // I2
                            SETVECTOR3(pu, 1, 2, 0);
                            SETVECTOR3(pv, 0, 1, 2);
                            z1 = 3;
                        }
                    }
                }
            }
        } else {
            if (sB < 0) {
                if (sC < 0) {               // (0--).
                    SETVECTOR3(U, B, C, A); // PT = ST x ST
                    SETVECTOR3(V, P, Q, R); // I2
                    SETVECTOR3(pu, 1, 2, 0);
                    SETVECTOR3(pv, 0, 1, 2);
                    z1 = 1;
                } else {
                    if (sC > 0) {               // (0-+).
                        SETVECTOR3(U, A, B, C); // I3
                        SETVECTOR3(V, P, Q, R); // I2
                        SETVECTOR3(pu, 0, 1, 2);
                        SETVECTOR3(pv, 0, 1, 2);
                        z1 = 2;
                    } else {                    // (0-0).
                        SETVECTOR3(U, C, A, B); // PT = ST
                        SETVECTOR3(V, Q, P, R); // PL = SL
                        SETVECTOR3(pu, 2, 0, 1);
                        SETVECTOR3(pv, 1, 0, 2);
                        z1 = 3;
                    }
                }
            } else {
                if (sB > 0) {
                    if (sC < 0) {               // (0+-).
                        SETVECTOR3(U, A, B, C); // I3
                        SETVECTOR3(V, Q, P, R); // PL = SL
                        SETVECTOR3(pu, 0, 1, 2);
                        SETVECTOR3(pv, 1, 0, 2);
                        z1 = 2;
                    } else {
                        if (sC > 0) {               // (0++).
                            SETVECTOR3(U, B, C, A); // PT = ST x ST
                            SETVECTOR3(V, Q, P, R); // PL = SL
                            SETVECTOR3(pu, 1, 2, 0);
                            SETVECTOR3(pv, 1, 0, 2);
                            z1 = 1;
                        } else {                    // (0+0).
                            SETVECTOR3(U, C, A, B); // PT = ST
                            SETVECTOR3(V, P, Q, R); // I2
                            SETVECTOR3(pu, 2, 0, 1);
                            SETVECTOR3(pv, 0, 1, 2);
                            z1 = 3;
                        }
                    }
                } else {                        // (00#)
                    if (sC < 0) {               // (00-).
                        SETVECTOR3(U, A, B, C); // I3
                        SETVECTOR3(V, Q, P, R); // PL = SL
                        SETVECTOR3(pu, 0, 1, 2);
                        SETVECTOR3(pv, 1, 0, 2);
                        z1 = 3;
                    } else {
                        if (sC > 0) {               // (00+).
                            SETVECTOR3(U, A, B, C); // I3
                            SETVECTOR3(V, P, Q, R); // I2
                            SETVECTOR3(pu, 0, 1, 2);
                            SETVECTOR3(pv, 0, 1, 2);
                            z1 = 3;
                        } else { // (000)
                            // Not possible unless ABC is degenerate.
                            // Avoiding compiler warnings.
                            SETVECTOR3(U, A, B, C); // I3
                            SETVECTOR3(V, P, Q, R); // I2
                            SETVECTOR3(pu, 0, 1, 2);
                            SETVECTOR3(pv, 0, 1, 2);
                            z1 = 4;
                        }
                    }
                }
            }
        }
    }

    s1 = orient3d(U[0], U[2], R, V[1]); // A, C, R, Q
    s2 = orient3d(U[1], U[2], R, V[0]); // B, C, R, P

    if (s1 > 0) {
        return 0;
    }
    if (s2 < 0) {
        return 0;
    }

    if (level == 0) {
        return 1; // They are intersected.
    }

    if (z1 == 1) {
        if (s1 == 0) { // (0###)
            // C = Q.
            types[0] = (int)SHAREVERT;
            pos[0] = pu[2]; // C
            pos[1] = pv[1]; // Q
            types[1] = (int)DISJOINT;
        } else {
            if (s2 == 0) { // (#0##)
                // C = P.
                types[0] = (int)SHAREVERT;
                pos[0] = pu[2]; // C
                pos[1] = pv[0]; // P
                types[1] = (int)DISJOINT;
            } else { // (-+##)
                // C in [P, Q].
                types[0] = (int)ACROSSVERT;
                pos[0] = pu[2]; // C
                pos[1] = pv[0]; // [P, Q]
                types[1] = (int)DISJOINT;
            }
        }
        return 4;
    }

    s3 = orient3d(U[0], U[2], R, V[0]); // A, C, R, P
    s4 = orient3d(U[1], U[2], R, V[1]); // B, C, R, Q

    if (z1 == 0) { // (tritri-03)
        if (s1 < 0) {
            if (s3 > 0) {
                if (s4 > 0) {
                    // [P, Q] overlaps [k, l] (-+++).
                    types[0] = (int)ACROSSEDGE;
                    pos[0] = pu[2]; // [C, A]
                    pos[1] = pv[0]; // [P, Q]
                    types[1] = (int)TOUCHFACE;
                    pos[2] = 3;     // [A, B, C]
                    pos[3] = pv[1]; // Q
                } else {
                    if (s4 == 0) {
                        // Q = l, [P, Q] contains [k, l] (-++0).
                        types[0] = (int)ACROSSEDGE;
                        pos[0] = pu[2]; // [C, A]
                        pos[1] = pv[0]; // [P, Q]
                        types[1] = (int)TOUCHEDGE;
                        pos[2] = pu[1]; // [B, C]
                        pos[3] = pv[1]; // Q
                    } else {            // s4 < 0
                        // [P, Q] contains [k, l] (-++-).
                        types[0] = (int)ACROSSEDGE;
                        pos[0] = pu[2]; // [C, A]
                        pos[1] = pv[0]; // [P, Q]
                        types[1] = (int)ACROSSEDGE;
                        pos[2] = pu[1]; // [B, C]
                        pos[3] = pv[0]; // [P, Q]
                    }
                }
            } else {
                if (s3 == 0) {
                    if (s4 > 0) {
                        // P = k, [P, Q] in [k, l] (-+0+).
                        types[0] = (int)TOUCHEDGE;
                        pos[0] = pu[2]; // [C, A]
                        pos[1] = pv[0]; // P
                        types[1] = (int)TOUCHFACE;
                        pos[2] = 3;     // [A, B, C]
                        pos[3] = pv[1]; // Q
                    } else {
                        if (s4 == 0) {
                            // [P, Q] = [k, l] (-+00).
                            types[0] = (int)TOUCHEDGE;
                            pos[0] = pu[2]; // [C, A]
                            pos[1] = pv[0]; // P
                            types[1] = (int)TOUCHEDGE;
                            pos[2] = pu[1]; // [B, C]
                            pos[3] = pv[1]; // Q
                        } else {
                            // P = k, [P, Q] contains [k, l] (-+0-).
                            types[0] = (int)TOUCHEDGE;
                            pos[0] = pu[2]; // [C, A]
                            pos[1] = pv[0]; // P
                            types[1] = (int)ACROSSEDGE;
                            pos[2] = pu[1]; // [B, C]
                            pos[3] = pv[0]; // [P, Q]
                        }
                    }
                } else { // s3 < 0
                    if (s2 > 0) {
                        if (s4 > 0) {
                            // [P, Q] in [k, l] (-+-+).
                            types[0] = (int)TOUCHFACE;
                            pos[0] = 3;     // [A, B, C]
                            pos[1] = pv[0]; // P
                            types[1] = (int)TOUCHFACE;
                            pos[2] = 3;     // [A, B, C]
                            pos[3] = pv[1]; // Q
                        } else {
                            if (s4 == 0) {
                                // Q = l, [P, Q] in [k, l] (-+-0).
                                types[0] = (int)TOUCHFACE;
                                pos[0] = 3;     // [A, B, C]
                                pos[1] = pv[0]; // P
                                types[1] = (int)TOUCHEDGE;
                                pos[2] = pu[1]; // [B, C]
                                pos[3] = pv[1]; // Q
                            } else {            // s4 < 0
                                // [P, Q] overlaps [k, l] (-+--).
                                types[0] = (int)TOUCHFACE;
                                pos[0] = 3;     // [A, B, C]
                                pos[1] = pv[0]; // P
                                types[1] = (int)ACROSSEDGE;
                                pos[2] = pu[1]; // [B, C]
                                pos[3] = pv[0]; // [P, Q]
                            }
                        }
                    } else { // s2 == 0
                        // P = l (#0##).
                        types[0] = (int)TOUCHEDGE;
                        pos[0] = pu[1]; // [B, C]
                        pos[1] = pv[0]; // P
                        types[1] = (int)DISJOINT;
                    }
                }
            }
        } else { // s1 == 0
            // Q = k (0####)
            types[0] = (int)TOUCHEDGE;
            pos[0] = pu[2]; // [C, A]
            pos[1] = pv[1]; // Q
            types[1] = (int)DISJOINT;
        }
    } else if (z1 == 2) { // (tritri-23)
        if (s1 < 0) {
            if (s3 > 0) {
                if (s4 > 0) {
                    // [P, Q] overlaps [A, l] (-+++).
                    types[0] = (int)ACROSSVERT;
                    pos[0] = pu[0]; // A
                    pos[1] = pv[0]; // [P, Q]
                    types[1] = (int)TOUCHFACE;
                    pos[2] = 3;     // [A, B, C]
                    pos[3] = pv[1]; // Q
                } else {
                    if (s4 == 0) {
                        // Q = l, [P, Q] contains [A, l] (-++0).
                        types[0] = (int)ACROSSVERT;
                        pos[0] = pu[0]; // A
                        pos[1] = pv[0]; // [P, Q]
                        types[1] = (int)TOUCHEDGE;
                        pos[2] = pu[1]; // [B, C]
                        pos[3] = pv[1]; // Q
                    } else {            // s4 < 0
                        // [P, Q] contains [A, l] (-++-).
                        types[0] = (int)ACROSSVERT;
                        pos[0] = pu[0]; // A
                        pos[1] = pv[0]; // [P, Q]
                        types[1] = (int)ACROSSEDGE;
                        pos[2] = pu[1]; // [B, C]
                        pos[3] = pv[0]; // [P, Q]
                    }
                }
            } else {
                if (s3 == 0) {
                    if (s4 > 0) {
                        // P = A, [P, Q] in [A, l] (-+0+).
                        types[0] = (int)SHAREVERT;
                        pos[0] = pu[0]; // A
                        pos[1] = pv[0]; // P
                        types[1] = (int)TOUCHFACE;
                        pos[2] = 3;     // [A, B, C]
                        pos[3] = pv[1]; // Q
                    } else {
                        if (s4 == 0) {
                            // [P, Q] = [A, l] (-+00).
                            types[0] = (int)SHAREVERT;
                            pos[0] = pu[0]; // A
                            pos[1] = pv[0]; // P
                            types[1] = (int)TOUCHEDGE;
                            pos[2] = pu[1]; // [B, C]
                            pos[3] = pv[1]; // Q
                        } else {            // s4 < 0
                            // Q = l, [P, Q] in [A, l] (-+0-).
                            types[0] = (int)SHAREVERT;
                            pos[0] = pu[0]; // A
                            pos[1] = pv[0]; // P
                            types[1] = (int)ACROSSEDGE;
                            pos[2] = pu[1]; // [B, C]
                            pos[3] = pv[0]; // [P, Q]
                        }
                    }
                } else { // s3 < 0
                    if (s2 > 0) {
                        if (s4 > 0) {
                            // [P, Q] in [A, l] (-+-+).
                            types[0] = (int)TOUCHFACE;
                            pos[0] = 3;     // [A, B, C]
                            pos[1] = pv[0]; // P
                            types[0] = (int)TOUCHFACE;
                            pos[0] = 3;     // [A, B, C]
                            pos[1] = pv[1]; // Q
                        } else {
                            if (s4 == 0) {
                                // Q = l, [P, Q] in [A, l] (-+-0).
                                types[0] = (int)TOUCHFACE;
                                pos[0] = 3;     // [A, B, C]
                                pos[1] = pv[0]; // P
                                types[0] = (int)TOUCHEDGE;
                                pos[0] = pu[1]; // [B, C]
                                pos[1] = pv[1]; // Q
                            } else {            // s4 < 0
                                // [P, Q] overlaps [A, l] (-+--).
                                types[0] = (int)TOUCHFACE;
                                pos[0] = 3;     // [A, B, C]
                                pos[1] = pv[0]; // P
                                types[0] = (int)ACROSSEDGE;
                                pos[0] = pu[1]; // [B, C]
                                pos[1] = pv[0]; // [P, Q]
                            }
                        }
                    } else { // s2 == 0
                        // P = l (#0##).
                        types[0] = (int)TOUCHEDGE;
                        pos[0] = pu[1]; // [B, C]
                        pos[1] = pv[0]; // P
                        types[1] = (int)DISJOINT;
                    }
                }
            }
        } else { // s1 == 0
            // Q = A (0###).
            types[0] = (int)SHAREVERT;
            pos[0] = pu[0]; // A
            pos[1] = pv[1]; // Q
            types[1] = (int)DISJOINT;
        }
    } else if (z1 == 3) { // (tritri-33)
        if (s1 < 0) {
            if (s3 > 0) {
                if (s4 > 0) {
                    // [P, Q] overlaps [A, B] (-+++).
                    types[0] = (int)ACROSSVERT;
                    pos[0] = pu[0]; // A
                    pos[1] = pv[0]; // [P, Q]
                    types[1] = (int)TOUCHEDGE;
                    pos[2] = pu[0]; // [A, B]
                    pos[3] = pv[1]; // Q
                } else {
                    if (s4 == 0) {
                        // Q = B, [P, Q] contains [A, B] (-++0).
                        types[0] = (int)ACROSSVERT;
                        pos[0] = pu[0]; // A
                        pos[1] = pv[0]; // [P, Q]
                        types[1] = (int)SHAREVERT;
                        pos[2] = pu[1]; // B
                        pos[3] = pv[1]; // Q
                    } else {            // s4 < 0
                        // [P, Q] contains [A, B] (-++-).
                        types[0] = (int)ACROSSVERT;
                        pos[0] = pu[0]; // A
                        pos[1] = pv[0]; // [P, Q]
                        types[1] = (int)ACROSSVERT;
                        pos[2] = pu[1]; // B
                        pos[3] = pv[0]; // [P, Q]
                    }
                }
            } else {
                if (s3 == 0) {
                    if (s4 > 0) {
                        // P = A, [P, Q] in [A, B] (-+0+).
                        types[0] = (int)SHAREVERT;
                        pos[0] = pu[0]; // A
                        pos[1] = pv[0]; // P
                        types[1] = (int)TOUCHEDGE;
                        pos[2] = pu[0]; // [A, B]
                        pos[3] = pv[1]; // Q
                    } else {
                        if (s4 == 0) {
                            // [P, Q] = [A, B] (-+00).
                            types[0] = (int)SHAREEDGE;
                            pos[0] = pu[0]; // [A, B]
                            pos[1] = pv[0]; // [P, Q]
                            types[1] = (int)DISJOINT;
                        } else { // s4 < 0
                            // P= A, [P, Q] in [A, B] (-+0-).
                            types[0] = (int)SHAREVERT;
                            pos[0] = pu[0]; // A
                            pos[1] = pv[0]; // P
                            types[1] = (int)ACROSSVERT;
                            pos[2] = pu[1]; // B
                            pos[3] = pv[0]; // [P, Q]
                        }
                    }
                } else { // s3 < 0
                    if (s2 > 0) {
                        if (s4 > 0) {
                            // [P, Q] in [A, B] (-+-+).
                            types[0] = (int)TOUCHEDGE;
                            pos[0] = pu[0]; // [A, B]
                            pos[1] = pv[0]; // P
                            types[1] = (int)TOUCHEDGE;
                            pos[2] = pu[0]; // [A, B]
                            pos[3] = pv[1]; // Q
                        } else {
                            if (s4 == 0) {
                                // Q = B, [P, Q] in [A, B] (-+-0).
                                types[0] = (int)TOUCHEDGE;
                                pos[0] = pu[0]; // [A, B]
                                pos[1] = pv[0]; // P
                                types[1] = (int)SHAREVERT;
                                pos[2] = pu[1]; // B
                                pos[3] = pv[1]; // Q
                            } else {            // s4 < 0
                                // [P, Q] overlaps [A, B] (-+--).
                                types[0] = (int)TOUCHEDGE;
                                pos[0] = pu[0]; // [A, B]
                                pos[1] = pv[0]; // P
                                types[1] = (int)ACROSSVERT;
                                pos[2] = pu[1]; // B
                                pos[3] = pv[0]; // [P, Q]
                            }
                        }
                    } else { // s2 == 0
                        // P = B (#0##).
                        types[0] = (int)SHAREVERT;
                        pos[0] = pu[1]; // B
                        pos[1] = pv[0]; // P
                        types[1] = (int)DISJOINT;
                    }
                }
            }
        } else { // s1 == 0
            // Q = A (0###).
            types[0] = (int)SHAREVERT;
            pos[0] = pu[0]; // A
            pos[1] = pv[1]; // Q
            types[1] = (int)DISJOINT;
        }
    }

    return 4;
}

int tetgenmesh::tri_edge_tail(point A, point B, point C, point P, point Q, point R, REAL sP,
                              REAL sQ, int level, int* types, int* pos) {
    point U[3], V[3]; //, Ptmp;
    int pu[3], pv[3]; //, itmp;
    REAL s1, s2, s3;
    int z1;

    if (sP < 0) {
        if (sQ < 0) { // (--) disjoint
            return 0;
        } else {
            if (sQ > 0) { // (-+)
                SETVECTOR3(U, A, B, C);
                SETVECTOR3(V, P, Q, R);
                SETVECTOR3(pu, 0, 1, 2);
                SETVECTOR3(pv, 0, 1, 2);
                z1 = 0;
            } else { // (-0)
                SETVECTOR3(U, A, B, C);
                SETVECTOR3(V, P, Q, R);
                SETVECTOR3(pu, 0, 1, 2);
                SETVECTOR3(pv, 0, 1, 2);
                z1 = 1;
            }
        }
    } else {
        if (sP > 0) { // (+-)
            if (sQ < 0) {
                SETVECTOR3(U, A, B, C);
                SETVECTOR3(V, Q, P, R); // P and Q are flipped.
                SETVECTOR3(pu, 0, 1, 2);
                SETVECTOR3(pv, 1, 0, 2);
                z1 = 0;
            } else {
                if (sQ > 0) { // (++) disjoint
                    return 0;
                } else {                    // (+0)
                    SETVECTOR3(U, B, A, C); // A and B are flipped.
                    SETVECTOR3(V, P, Q, R);
                    SETVECTOR3(pu, 1, 0, 2);
                    SETVECTOR3(pv, 0, 1, 2);
                    z1 = 1;
                }
            }
        } else {          // sP == 0
            if (sQ < 0) { // (0-)
                SETVECTOR3(U, A, B, C);
                SETVECTOR3(V, Q, P, R); // P and Q are flipped.
                SETVECTOR3(pu, 0, 1, 2);
                SETVECTOR3(pv, 1, 0, 2);
                z1 = 1;
            } else {
                if (sQ > 0) {               // (0+)
                    SETVECTOR3(U, B, A, C); // A and B are flipped.
                    SETVECTOR3(V, Q, P, R); // P and Q are flipped.
                    SETVECTOR3(pu, 1, 0, 2);
                    SETVECTOR3(pv, 1, 0, 2);
                    z1 = 1;
                } else { // (00)
                    // A, B, C, P, and Q are coplanar.
                    z1 = 2;
                }
            }
        }
    }

    if (z1 == 2) {
        // The triangle and the edge are coplanar.
        return tri_edge_2d(A, B, C, P, Q, R, level, types, pos);
    }

    s1 = orient3d(U[0], U[1], V[0], V[1]);
    if (s1 < 0) {
        return 0;
    }

    s2 = orient3d(U[1], U[2], V[0], V[1]);
    if (s2 < 0) {
        return 0;
    }

    s3 = orient3d(U[2], U[0], V[0], V[1]);
    if (s3 < 0) {
        return 0;
    }

    if (level == 0) {
        return 1; // The are intersected.
    }

    types[1] = (int)DISJOINT; // No second intersection point.

    if (z1 == 0) {
        if (s1 > 0) {
            if (s2 > 0) {
                if (s3 > 0) { // (+++)
                    // [P, Q] passes interior of [A, B, C].
                    types[0] = (int)ACROSSFACE;
                    pos[0] = 3; // interior of [A, B, C]
                    pos[1] = 0; // [P, Q]
                } else {        // s3 == 0 (++0)
                    // [P, Q] intersects [C, A].
                    types[0] = (int)ACROSSEDGE;
                    pos[0] = pu[2]; // [C, A]
                    pos[1] = 0;     // [P, Q]
                }
            } else {          // s2 == 0
                if (s3 > 0) { // (+0+)
                    // [P, Q] intersects [B, C].
                    types[0] = (int)ACROSSEDGE;
                    pos[0] = pu[1]; // [B, C]
                    pos[1] = 0;     // [P, Q]
                } else {            // s3 == 0 (+00)
                    // [P, Q] passes C.
                    types[0] = (int)ACROSSVERT;
                    pos[0] = pu[2]; // C
                    pos[1] = 0;     // [P, Q]
                }
            }
        } else { // s1 == 0
            if (s2 > 0) {
                if (s3 > 0) { // (0++)
                    // [P, Q] intersects [A, B].
                    types[0] = (int)ACROSSEDGE;
                    pos[0] = pu[0]; // [A, B]
                    pos[1] = 0;     // [P, Q]
                } else {            // s3 == 0 (0+0)
                    // [P, Q] passes A.
                    types[0] = (int)ACROSSVERT;
                    pos[0] = pu[0]; // A
                    pos[1] = 0;     // [P, Q]
                }
            } else {          // s2 == 0
                if (s3 > 0) { // (00+)
                    // [P, Q] passes B.
                    types[0] = (int)ACROSSVERT;
                    pos[0] = pu[1]; // B
                    pos[1] = 0;     // [P, Q]
                }
            }
        }
    } else { // z1 == 1
        if (s1 > 0) {
            if (s2 > 0) {
                if (s3 > 0) { // (+++)
                    // Q lies in [A, B, C].
                    types[0] = (int)TOUCHFACE;
                    pos[0] = 0;     // [A, B, C]
                    pos[1] = pv[1]; // Q
                } else {            // s3 == 0 (++0)
                    // Q lies on [C, A].
                    types[0] = (int)TOUCHEDGE;
                    pos[0] = pu[2]; // [C, A]
                    pos[1] = pv[1]; // Q
                }
            } else {          // s2 == 0
                if (s3 > 0) { // (+0+)
                    // Q lies on [B, C].
                    types[0] = (int)TOUCHEDGE;
                    pos[0] = pu[1]; // [B, C]
                    pos[1] = pv[1]; // Q
                } else {            // s3 == 0 (+00)
                    // Q = C.
                    types[0] = (int)SHAREVERT;
                    pos[0] = pu[2]; // C
                    pos[1] = pv[1]; // Q
                }
            }
        } else { // s1 == 0
            if (s2 > 0) {
                if (s3 > 0) { // (0++)
                    // Q lies on [A, B].
                    types[0] = (int)TOUCHEDGE;
                    pos[0] = pu[0]; // [A, B]
                    pos[1] = pv[1]; // Q
                } else {            // s3 == 0 (0+0)
                    // Q = A.
                    types[0] = (int)SHAREVERT;
                    pos[0] = pu[0]; // A
                    pos[1] = pv[1]; // Q
                }
            } else {          // s2 == 0
                if (s3 > 0) { // (00+)
                    // Q = B.
                    types[0] = (int)SHAREVERT;
                    pos[0] = pu[1]; // B
                    pos[1] = pv[1]; // Q
                }
            }
        }
    }

    // T and E intersect in a single point.
    return 2;
}

int tetgenmesh::tri_edge_test(point A, point B, point C, point P, point Q, point R, int level,
                              int* types, int* pos) {
    REAL sP, sQ;

    // Test the locations of P and Q with respect to ABC.
    sP = orient3d(A, B, C, P);
    sQ = orient3d(A, B, C, Q);

    return tri_edge_tail(A, B, C, P, Q, R, sP, sQ, level, types, pos);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// tri_tri_inter()    Test whether two triangle (abc) and (opq) are          //
//                    intersecting or not.                                   //
//                                                                           //
// Return 0 if they are disjoint. Otherwise, return 1. 'type' returns one of //
// the four cases: SHAREVERTEX, SHAREEDGE, SHAREFACE, and INTERSECT.         //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::tri_edge_inter_tail(REAL* A, REAL* B, REAL* C, REAL* P, REAL* Q, REAL s_p,
                                    REAL s_q) {
    int types[2], pos[4];
    int ni; // =0, 2, 4

    ni = tri_edge_tail(A, B, C, P, Q, NULL, s_p, s_q, 1, types, pos);

    if (ni > 0) {
        if (ni == 2) {
            // Get the intersection type.
            if (types[0] == (int)SHAREVERT) {
                return (int)SHAREVERT;
            } else {
                return (int)INTERSECT;
            }
        } else if (ni == 4) {
            // There may be two intersections.
            if (types[0] == (int)SHAREVERT) {
                if (types[1] == (int)DISJOINT) {
                    return (int)SHAREVERT;
                } else {
                    return (int)INTERSECT;
                }
            } else {
                if (types[0] == (int)SHAREEDGE) {
                    return (int)SHAREEDGE;
                } else {
                    return (int)INTERSECT;
                }
            }
        }
    }

    return (int)DISJOINT;
}

int tetgenmesh::tri_tri_inter(REAL* A, REAL* B, REAL* C, REAL* O, REAL* P, REAL* Q) {
    REAL s_o, s_p, s_q;
    REAL s_a, s_b, s_c;

    s_o = orient3d(A, B, C, O);
    s_p = orient3d(A, B, C, P);
    s_q = orient3d(A, B, C, Q);
    if ((s_o * s_p > 0.0) && (s_o * s_q > 0.0)) {
        // o, p, q are all in the same halfspace of ABC.
        return 0; // DISJOINT;
    }

    s_a = orient3d(O, P, Q, A);
    s_b = orient3d(O, P, Q, B);
    s_c = orient3d(O, P, Q, C);
    if ((s_a * s_b > 0.0) && (s_a * s_c > 0.0)) {
        // a, b, c are all in the same halfspace of OPQ.
        return 0; // DISJOINT;
    }

    int abcop, abcpq, abcqo;
    int shareedge = 0;

    abcop = tri_edge_inter_tail(A, B, C, O, P, s_o, s_p);
    if (abcop == (int)INTERSECT) {
        return (int)INTERSECT;
    } else if (abcop == (int)SHAREEDGE) {
        shareedge++;
    }
    abcpq = tri_edge_inter_tail(A, B, C, P, Q, s_p, s_q);
    if (abcpq == (int)INTERSECT) {
        return (int)INTERSECT;
    } else if (abcpq == (int)SHAREEDGE) {
        shareedge++;
    }
    abcqo = tri_edge_inter_tail(A, B, C, Q, O, s_q, s_o);
    if (abcqo == (int)INTERSECT) {
        return (int)INTERSECT;
    } else if (abcqo == (int)SHAREEDGE) {
        shareedge++;
    }
    if (shareedge == 3) {
        // opq are coincident with abc.
        return (int)SHAREFACE;
    }

    // Continue to detect whether opq and abc are intersecting or not.
    int opqab, opqbc, opqca;

    opqab = tri_edge_inter_tail(O, P, Q, A, B, s_a, s_b);
    if (opqab == (int)INTERSECT) {
        return (int)INTERSECT;
    }
    opqbc = tri_edge_inter_tail(O, P, Q, B, C, s_b, s_c);
    if (opqbc == (int)INTERSECT) {
        return (int)INTERSECT;
    }
    opqca = tri_edge_inter_tail(O, P, Q, C, A, s_c, s_a);
    if (opqca == (int)INTERSECT) {
        return (int)INTERSECT;
    }

    // At this point, two triangles are not intersecting and not coincident.
    //   They may be share an edge, or share a vertex, or disjoint.
    if (abcop == (int)SHAREEDGE) {
        // op is coincident with an edge of abc.
        return (int)SHAREEDGE;
    }
    if (abcpq == (int)SHAREEDGE) {
        // pq is coincident with an edge of abc.
        return (int)SHAREEDGE;
    }
    if (abcqo == (int)SHAREEDGE) {
        // qo is coincident with an edge of abc.
        return (int)SHAREEDGE;
    }

    // They may share a vertex or disjoint.
    if (abcop == (int)SHAREVERT) {
        return (int)SHAREVERT;
    }
    if (abcpq == (int)SHAREVERT) {
        // q is the coincident vertex.
        return (int)SHAREVERT;
    }

    // They are disjoint.
    return (int)DISJOINT;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// lu_decmp()    Compute the LU decomposition of a matrix.                   //
//                                                                           //
// Compute the LU decomposition of a (non-singular) square matrix A using    //
// partial pivoting and implicit row exchanges.  The result is:              //
//     A = P * L * U,                                                        //
// where P is a permutation matrix, L is unit lower triangular, and U is     //
// upper triangular.  The factored form of A is used in combination with     //
// 'lu_solve()' to solve linear equations: Ax = b, or invert a matrix.       //
//                                                                           //
// The inputs are a square matrix 'lu[N..n+N-1][N..n+N-1]', it's size is 'n'.//
// On output, 'lu' is replaced by the LU decomposition of a rowwise permuta- //
// tion of itself, 'ps[N..n+N-1]' is an output vector that records the row   //
// permutation effected by the partial pivoting, effectively,  'ps' array    //
// tells the user what the permutation matrix P is; 'd' is output as +1/-1   //
// depending on whether the number of row interchanges was even or odd,      //
// respectively.                                                             //
//                                                                           //
// Return true if the LU decomposition is successfully computed, otherwise,  //
// return false in case that A is a singular matrix.                         //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenmesh::lu_decmp(REAL lu[4][4], int n, int* ps, REAL* d, int N) {
    REAL scales[4];
    REAL pivot, biggest, mult, tempf;
    int pivotindex = 0;
    int i, j, k;

    *d = 1.0; // No row interchanges yet.

    for (i = N; i < n + N; i++) { // For each row.
        // Find the largest element in each row for row equilibration
        biggest = 0.0;
        for (j = N; j < n + N; j++)
            if (biggest < (tempf = fabs(lu[i][j]))) biggest = tempf;
        if (biggest != 0.0)
            scales[i] = 1.0 / biggest;
        else {
            scales[i] = 0.0;
            return false; // Zero row: singular matrix.
        }
        ps[i] = i; // Initialize pivot sequence.
    }

    for (k = N; k < n + N - 1; k++) { // For each column.
        // Find the largest element in each column to pivot around.
        biggest = 0.0;
        for (i = k; i < n + N; i++) {
            if (biggest < (tempf = fabs(lu[ps[i]][k]) * scales[ps[i]])) {
                biggest = tempf;
                pivotindex = i;
            }
        }
        if (biggest == 0.0) {
            return false; // Zero column: singular matrix.
        }
        if (pivotindex != k) { // Update pivot sequence.
            j = ps[k];
            ps[k] = ps[pivotindex];
            ps[pivotindex] = j;
            *d = -(*d); // ...and change the parity of d.
        }

        // Pivot, eliminating an extra variable  each time
        pivot = lu[ps[k]][k];
        for (i = k + 1; i < n + N; i++) {
            lu[ps[i]][k] = mult = lu[ps[i]][k] / pivot;
            if (mult != 0.0) {
                for (j = k + 1; j < n + N; j++)
                    lu[ps[i]][j] -= mult * lu[ps[k]][j];
            }
        }
    }

    // (lu[ps[n + N - 1]][n + N - 1] == 0.0) ==> A is singular.
    return lu[ps[n + N - 1]][n + N - 1] != 0.0;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// lu_solve()    Solves the linear equation:  Ax = b,  after the matrix A    //
//               has been decomposed into the lower and upper triangular     //
//               matrices L and U, where A = LU.                             //
//                                                                           //
// 'lu[N..n+N-1][N..n+N-1]' is input, not as the matrix 'A' but rather as    //
// its LU decomposition, computed by the routine 'lu_decmp'; 'ps[N..n+N-1]'  //
// is input as the permutation vector returned by 'lu_decmp';  'b[N..n+N-1]' //
// is input as the right-hand side vector, and returns with the solution     //
// vector. 'lu', 'n', and 'ps' are not modified by this routine and can be   //
// left in place for successive calls with different right-hand sides 'b'.   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::lu_solve(REAL lu[4][4], int n, int* ps, REAL* b, int N) {
    int i, j;
    REAL X[4], dot;

    for (i = N; i < n + N; i++)
        X[i] = 0.0;

    // Vector reduction using U triangular matrix.
    for (i = N; i < n + N; i++) {
        dot = 0.0;
        for (j = N; j < i + N; j++)
            dot += lu[ps[i]][j] * X[j];
        X[i] = b[ps[i]] - dot;
    }

    // Back substitution, in L triangular matrix.
    for (i = n + N - 1; i >= N; i--) {
        dot = 0.0;
        for (j = i + 1; j < n + N; j++)
            dot += lu[ps[i]][j] * X[j];
        X[i] = (X[i] - dot) / lu[ps[i]][i];
    }

    for (i = N; i < n + N; i++)
        b[i] = X[i];
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// incircle3d()    3D in-circle test.                                        //
//                                                                           //
// Return a negative value if pd is inside the circumcircle of the triangle  //
// pa, pb, and pc.                                                           //
//                                                                           //
// IMPORTANT: It assumes that [a,b] is the common edge, i.e., the two input  //
// triangles are [a,b,c] and [b,a,d].                                        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

REAL tetgenmesh::incircle3d(point pa, point pb, point pc, point pd) {
    REAL area2[2], n1[3], n2[3], c[3];
    REAL sign, r, d;

    // Calculate the areas of the two triangles [a, b, c] and [b, a, d].
    facenormal(pa, pb, pc, n1, 1, NULL);
    area2[0] = dot(n1, n1);
    facenormal(pb, pa, pd, n2, 1, NULL);
    area2[1] = dot(n2, n2);

    if (area2[0] > area2[1]) {
        // Choose [a, b, c] as the base triangle.
        circumsphere(pa, pb, pc, NULL, c, &r);
        d = distance(c, pd);
    } else {
        // Choose [b, a, d] as the base triangle.
        if (area2[1] > 0) {
            circumsphere(pb, pa, pd, NULL, c, &r);
            d = distance(c, pc);
        } else {
            // The four points are collinear. This case only happens on the boundary.
            return 0; // Return "not inside".
        }
    }

    sign = d - r;
    if (fabs(sign) / r < b->epsilon) {
        sign = 0;
    }

    return sign;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// facenormal()    Calculate the normal of the face.                         //
//                                                                           //
// The normal of the face abc can be calculated by the cross product of 2 of //
// its 3 edge vectors.  A better choice of two edge vectors will reduce the  //
// numerical error during the calculation.  Burdakov proved that the optimal //
// basis problem is equivalent to the minimum spanning tree problem with the //
// edge length be the functional, see Burdakov, "A greedy algorithm for the  //
// optimal basis problem", BIT 37:3 (1997), 591-599. If 'pivot' > 0, the two //
// short edges in abc are chosen for the calculation.                        //
//                                                                           //
// If 'lav' is not NULL and if 'pivot' is set, the average edge length of    //
// the edges of the face [a,b,c] is returned.                                //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::facenormal(point pa, point pb, point pc, REAL* n, int pivot, REAL* lav) {
    REAL v1[3], v2[3], v3[3], *pv1, *pv2;
    REAL L1, L2, L3;

    v1[0] = pb[0] - pa[0]; // edge vector v1: a->b
    v1[1] = pb[1] - pa[1];
    v1[2] = pb[2] - pa[2];
    v2[0] = pa[0] - pc[0]; // edge vector v2: c->a
    v2[1] = pa[1] - pc[1];
    v2[2] = pa[2] - pc[2];

    // Default, normal is calculated by: v1 x (-v2) (see Fig. fnormal).
    if (pivot > 0) {
        // Choose edge vectors by Burdakov's algorithm.
        v3[0] = pc[0] - pb[0]; // edge vector v3: b->c
        v3[1] = pc[1] - pb[1];
        v3[2] = pc[2] - pb[2];
        L1 = dot(v1, v1);
        L2 = dot(v2, v2);
        L3 = dot(v3, v3);
        // Sort the three edge lengths.
        if (L1 < L2) {
            if (L2 < L3) {
                pv1 = v1;
                pv2 = v2; // n = v1 x (-v2).
            } else {
                pv1 = v3;
                pv2 = v1; // n = v3 x (-v1).
            }
        } else {
            if (L1 < L3) {
                pv1 = v1;
                pv2 = v2; // n = v1 x (-v2).
            } else {
                pv1 = v2;
                pv2 = v3; // n = v2 x (-v3).
            }
        }
        if (lav) {
            // return the average edge length.
            *lav = (sqrt(L1) + sqrt(L2) + sqrt(L3)) / 3.0;
        }
    } else {
        pv1 = v1;
        pv2 = v2; // n = v1 x (-v2).
    }

    // Calculate the face normal.
    cross(pv1, pv2, n);
    // Inverse the direction;
    n[0] = -n[0];
    n[1] = -n[1];
    n[2] = -n[2];
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// shortdistance()    Returns the shortest distance from point p to a line   //
//                    defined by two points e1 and e2.                       //
//                                                                           //
// First compute the projection length l_p of the vector v1 = p - e1 along   //
// the vector v2 = e2 - e1. Then Pythagoras' Theorem is used to compute the  //
// shortest distance.                                                        //
//                                                                           //
// This routine allows that p is collinear with the line. In this case, the  //
// return value is zero. The two points e1 and e2 should not be identical.   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

REAL tetgenmesh::shortdistance(REAL* p, REAL* e1, REAL* e2) {
    REAL v1[3], v2[3];
    REAL len, l_p;

    v1[0] = e2[0] - e1[0];
    v1[1] = e2[1] - e1[1];
    v1[2] = e2[2] - e1[2];
    v2[0] = p[0] - e1[0];
    v2[1] = p[1] - e1[1];
    v2[2] = p[2] - e1[2];

    len = sqrt(dot(v1, v1));

    v1[0] /= len;
    v1[1] /= len;
    v1[2] /= len;
    l_p = dot(v1, v2);

    return sqrt(dot(v2, v2) - l_p * l_p);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// triarea()    Return the area of a triangle.                               //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

REAL tetgenmesh::triarea(REAL* pa, REAL* pb, REAL* pc) {
    REAL A[4][4];

    // Compute the coefficient matrix A (3x3).
    A[0][0] = pb[0] - pa[0];
    A[0][1] = pb[1] - pa[1];
    A[0][2] = pb[2] - pa[2]; // vector V1 (pa->pb)
    A[1][0] = pc[0] - pa[0];
    A[1][1] = pc[1] - pa[1];
    A[1][2] = pc[2] - pa[2]; // vector V2 (pa->pc)

    cross(A[0], A[1], A[2]); // vector V3 (V1 X V2)

    return 0.5 * sqrt(dot(A[2], A[2])); // The area of [a,b,c].
}

REAL tetgenmesh::orient3dfast(REAL* pa, REAL* pb, REAL* pc, REAL* pd) {
    REAL adx, bdx, cdx;
    REAL ady, bdy, cdy;
    REAL adz, bdz, cdz;

    adx = pa[0] - pd[0];
    bdx = pb[0] - pd[0];
    cdx = pc[0] - pd[0];
    ady = pa[1] - pd[1];
    bdy = pb[1] - pd[1];
    cdy = pc[1] - pd[1];
    adz = pa[2] - pd[2];
    bdz = pb[2] - pd[2];
    cdz = pc[2] - pd[2];

    return adx * (bdy * cdz - bdz * cdy) + bdx * (cdy * adz - cdz * ady) +
           cdx * (ady * bdz - adz * bdy);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// interiorangle()    Return the interior angle (0 - 2 * PI) between vectors //
//                    o->p1 and o->p2.                                       //
//                                                                           //
// 'n' is the normal of the plane containing face (o, p1, p2).  The interior //
// angle is the total angle rotating from o->p1 around n to o->p2.  Exchange //
// the position of p1 and p2 will get the complement angle of the other one. //
// i.e., interiorangle(o, p1, p2) = 2 * PI - interiorangle(o, p2, p1).  Set  //
// 'n' be NULL if you only want the interior angle between 0 - PI.           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

REAL tetgenmesh::interiorangle(REAL* o, REAL* p1, REAL* p2, REAL* n) {
    REAL v1[3], v2[3], np[3];
    REAL theta, costheta, lenlen;
    REAL ori, len1, len2;

    // Get the interior angle (0 - PI) between o->p1, and o->p2.
    v1[0] = p1[0] - o[0];
    v1[1] = p1[1] - o[1];
    v1[2] = p1[2] - o[2];
    v2[0] = p2[0] - o[0];
    v2[1] = p2[1] - o[1];
    v2[2] = p2[2] - o[2];
    len1 = sqrt(dot(v1, v1));
    len2 = sqrt(dot(v2, v2));
    lenlen = len1 * len2;

    costheta = dot(v1, v2) / lenlen;
    if (costheta > 1.0) {
        costheta = 1.0; // Roundoff.
    } else if (costheta < -1.0) {
        costheta = -1.0; // Roundoff.
    }
    theta = acos(costheta);
    if (n != NULL) {
        // Get a point above the face (o, p1, p2);
        np[0] = o[0] + n[0];
        np[1] = o[1] + n[1];
        np[2] = o[2] + n[2];
        // Adjust theta (0 - 2 * PI).
        ori = orient3d(p1, o, np, p2);
        if (ori > 0.0) {
            theta = 2 * PI - theta;
        }
    }

    return theta;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// projpt2edge()    Return the projection point from a point to an edge.     //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::projpt2edge(REAL* p, REAL* e1, REAL* e2, REAL* prj) {
    REAL v1[3], v2[3];
    REAL len, l_p;

    v1[0] = e2[0] - e1[0];
    v1[1] = e2[1] - e1[1];
    v1[2] = e2[2] - e1[2];
    v2[0] = p[0] - e1[0];
    v2[1] = p[1] - e1[1];
    v2[2] = p[2] - e1[2];

    len = sqrt(dot(v1, v1));
    v1[0] /= len;
    v1[1] /= len;
    v1[2] /= len;
    l_p = dot(v1, v2);

    prj[0] = e1[0] + l_p * v1[0];
    prj[1] = e1[1] + l_p * v1[1];
    prj[2] = e1[2] + l_p * v1[2];
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// projpt2face()    Return the projection point from a point to a face.      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::projpt2face(REAL* p, REAL* f1, REAL* f2, REAL* f3, REAL* prj) {
    REAL fnormal[3], v1[3];
    REAL len, dist;

    // Get the unit face normal.
    facenormal(f1, f2, f3, fnormal, 1, NULL);
    len = sqrt(fnormal[0] * fnormal[0] + fnormal[1] * fnormal[1] + fnormal[2] * fnormal[2]);
    fnormal[0] /= len;
    fnormal[1] /= len;
    fnormal[2] /= len;
    // Get the vector v1 = |p - f1|.
    v1[0] = p[0] - f1[0];
    v1[1] = p[1] - f1[1];
    v1[2] = p[2] - f1[2];
    // Get the project distance.
    dist = dot(fnormal, v1);

    // Get the project point.
    prj[0] = p[0] - dist * fnormal[0];
    prj[1] = p[1] - dist * fnormal[1];
    prj[2] = p[2] - dist * fnormal[2];
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// tetalldihedral()    Get all (six) dihedral angles of a tet.               //
//                                                                           //
// If 'cosdd' is not NULL, it returns the cosines of the 6 dihedral angles,  //
// the edge indices are given in the global array 'edge2ver'. If 'cosmaxd'   //
// (or 'cosmind') is not NULL, it returns the cosine of the maximal (or      //
// minimal) dihedral angle.                                                  //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenmesh::tetalldihedral(point pa, point pb, point pc, point pd, REAL* cosdd, REAL* cosmaxd,
                                REAL* cosmind) {
    REAL N[4][3], vol, cosd, len;
    int f1 = 0, f2 = 0, i, j;

    vol = 0; // Check if the tet is valid or not.

    // Get four normals of faces of the tet.
    tetallnormal(pa, pb, pc, pd, N, &vol);

    if (vol > 0) {
        // Normalize the normals.
        for (i = 0; i < 4; i++) {
            len = sqrt(dot(N[i], N[i]));
            if (len != 0.0) {
                for (j = 0; j < 3; j++)
                    N[i][j] /= len;
            } else {
                // There are degeneracies, such as duplicated vertices.
                vol = 0; // assert(0);
            }
        }
    }

    if (vol <= 0) { // if (vol == 0.0) {
        // A degenerated tet or an inverted tet.
        facenormal(pc, pb, pd, N[0], 1, NULL);
        facenormal(pa, pc, pd, N[1], 1, NULL);
        facenormal(pb, pa, pd, N[2], 1, NULL);
        facenormal(pa, pb, pc, N[3], 1, NULL);
        // Normalize the normals.
        for (i = 0; i < 4; i++) {
            len = sqrt(dot(N[i], N[i]));
            if (len != 0.0) {
                for (j = 0; j < 3; j++)
                    N[i][j] /= len;
            } else {
                // There are degeneracies, such as duplicated vertices.
                break; // Not a valid normal.
            }
        }
        if (i < 4) {
            // Do not calculate dihedral angles.
            // Set all angles be 0 degree. There will be no quality optimization for
            //   this tet! Use volume optimization to correct it.
            if (cosdd != NULL) {
                for (i = 0; i < 6; i++) {
                    cosdd[i] = -1.0; // 180 degree.
                }
            }
            // This tet has zero volume.
            if (cosmaxd != NULL) {
                *cosmaxd = -1.0; // 180 degree.
            }
            if (cosmind != NULL) {
                *cosmind = -1.0; // 180 degree.
            }
            return false;
        }
    }

    // Calculate the cosine of the dihedral angles of the edges.
    for (i = 0; i < 6; i++) {
        switch (i) {
        case 0:
            f1 = 0;
            f2 = 1;
            break; // [c,d].
        case 1:
            f1 = 1;
            f2 = 2;
            break; // [a,d].
        case 2:
            f1 = 2;
            f2 = 3;
            break; // [a,b].
        case 3:
            f1 = 0;
            f2 = 3;
            break; // [b,c].
        case 4:
            f1 = 2;
            f2 = 0;
            break; // [b,d].
        case 5:
            f1 = 1;
            f2 = 3;
            break; // [a,c].
        }
        cosd = -dot(N[f1], N[f2]);
        if (cosd < -1.0) cosd = -1.0; // Rounding.
        if (cosd > 1.0) cosd = 1.0;   // Rounding.
        if (cosdd) cosdd[i] = cosd;
        if (cosmaxd || cosmind) {
            if (i == 0) {
                if (cosmaxd) *cosmaxd = cosd;
                if (cosmind) *cosmind = cosd;
            } else {
                if (cosmaxd) *cosmaxd = cosd < *cosmaxd ? cosd : *cosmaxd;
                if (cosmind) *cosmind = cosd > *cosmind ? cosd : *cosmind;
            }
        }
    }

    return true;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// tetallnormal()    Get the in-normals of the four faces of a given tet.    //
//                                                                           //
// Let tet be abcd. N[4][3] returns the four normals, which are: N[0] cbd,   //
// N[1] acd, N[2] bad, N[3] abc (exactly corresponding to the face indices   //
// of the mesh data structure). These normals are unnormalized.              //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::tetallnormal(point pa, point pb, point pc, point pd, REAL N[4][3], REAL* volume) {
    REAL A[4][4], rhs[4], D;
    int indx[4];
    int i, j;

    // get the entries of A[3][3].
    for (i = 0; i < 3; i++)
        A[0][i] = pa[i] - pd[i]; // d->a vec
    for (i = 0; i < 3; i++)
        A[1][i] = pb[i] - pd[i]; // d->b vec
    for (i = 0; i < 3; i++)
        A[2][i] = pc[i] - pd[i]; // d->c vec

    // Compute the inverse of matrix A, to get 3 normals of the 4 faces.
    if (lu_decmp(A, 3, indx, &D, 0)) { // Decompose the matrix just once.
        if (volume != NULL) {
            // Get the volume of the tet.
            *volume = fabs((A[indx[0]][0] * A[indx[1]][1] * A[indx[2]][2])) / 6.0;
        }
        for (j = 0; j < 3; j++) {
            for (i = 0; i < 3; i++)
                rhs[i] = 0.0;
            rhs[j] = 1.0; // Positive means the inside direction
            lu_solve(A, 3, indx, rhs, 0);
            for (i = 0; i < 3; i++)
                N[j][i] = rhs[i];
        }
        // Get the fourth normal by summing up the first three.
        for (i = 0; i < 3; i++)
            N[3][i] = -N[0][i] - N[1][i] - N[2][i];
    } else {
        // The tet is degenerated.
        if (volume != NULL) {
            *volume = 0;
        }
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// tetaspectratio()    Calculate the aspect ratio of the tetrahedron.        //
//                                                                           //
// The aspect ratio of a tet is L/h, where L is the longest edge length, and //
// h is the shortest height of the tet.                                      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

REAL tetgenmesh::tetaspectratio(point pa, point pb, point pc, point pd) {
    REAL V[6][3], edgelength[6], longlen;
    REAL vda[3], vdb[3], vdc[3];
    REAL N[4][3], A[4][4], rhs[4], D;
    REAL H[4], volume, minheightinv;
    int indx[4];
    int i, j;

    // Set the edge vectors: V[0], ..., V[5]
    for (i = 0; i < 3; i++)
        V[0][i] = pa[i] - pd[i];
    for (i = 0; i < 3; i++)
        V[1][i] = pb[i] - pd[i];
    for (i = 0; i < 3; i++)
        V[2][i] = pc[i] - pd[i];
    for (i = 0; i < 3; i++)
        V[3][i] = pb[i] - pa[i];
    for (i = 0; i < 3; i++)
        V[4][i] = pc[i] - pb[i];
    for (i = 0; i < 3; i++)
        V[5][i] = pa[i] - pc[i];

    // Get the squares of the edge lengths.
    for (i = 0; i < 6; i++)
        edgelength[i] = dot(V[i], V[i]);

    // Calculate the longest and shortest edge length.
    longlen = edgelength[0];
    for (i = 1; i < 6; i++) {
        longlen = edgelength[i] > longlen ? edgelength[i] : longlen;
    }

    // Set the matrix A = [vda, vdb, vdc]^T.
    for (i = 0; i < 3; i++)
        A[0][i] = vda[i] = pa[i] - pd[i];
    for (i = 0; i < 3; i++)
        A[1][i] = vdb[i] = pb[i] - pd[i];
    for (i = 0; i < 3; i++)
        A[2][i] = vdc[i] = pc[i] - pd[i];
    // Lu-decompose the matrix A.
    lu_decmp(A, 3, indx, &D, 0);
    // Get the volume of abcd.
    volume = (A[indx[0]][0] * A[indx[1]][1] * A[indx[2]][2]) / 6.0;
    // Check if it is zero.
    if (volume == 0.0) return 1.0e+200; // A degenerate tet.

    // Compute the 4 face normals (N[0], ..., N[3]).
    for (j = 0; j < 3; j++) {
        for (i = 0; i < 3; i++)
            rhs[i] = 0.0;
        rhs[j] = 1.0; // Positive means the inside direction
        lu_solve(A, 3, indx, rhs, 0);
        for (i = 0; i < 3; i++)
            N[j][i] = rhs[i];
    }
    // Get the fourth normal by summing up the first three.
    for (i = 0; i < 3; i++)
        N[3][i] = -N[0][i] - N[1][i] - N[2][i];
    // Normalized the normals.
    for (i = 0; i < 4; i++) {
        // H[i] is the inverse of the height of its corresponding face.
        H[i] = sqrt(dot(N[i], N[i]));
        // if (H[i] > 0.0) {
        //   for (j = 0; j < 3; j++) N[i][j] /= H[i];
        // }
    }
    // Get the radius of the inscribed sphere.
    // insradius = 1.0 / (H[0] + H[1] + H[2] + H[3]);
    // Get the biggest H[i] (corresponding to the smallest height).
    minheightinv = H[0];
    for (i = 1; i < 4; i++) {
        if (H[i] > minheightinv) minheightinv = H[i];
    }

    return sqrt(longlen) * minheightinv;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// circumsphere()    Calculate the smallest circumsphere (center and radius) //
//                   of the given three or four points.                      //
//                                                                           //
// The circumsphere of four points (a tetrahedron) is unique if they are not //
// degenerate. If 'pd = NULL', the smallest circumsphere of three points is  //
// the diametral sphere of the triangle if they are not degenerate.          //
//                                                                           //
// Return TRUE if the input points are not degenerate and the circumcenter   //
// and circumradius are returned in 'cent' and 'radius' respectively if they //
// are not NULLs.  Otherwise, return FALSE, the four points are co-planar.   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenmesh::circumsphere(REAL* pa, REAL* pb, REAL* pc, REAL* pd, REAL* cent, REAL* radius) {
    REAL A[4][4], rhs[4], D;
    int indx[4];

    // Compute the coefficient matrix A (3x3).
    A[0][0] = pb[0] - pa[0];
    A[0][1] = pb[1] - pa[1];
    A[0][2] = pb[2] - pa[2];
    A[1][0] = pc[0] - pa[0];
    A[1][1] = pc[1] - pa[1];
    A[1][2] = pc[2] - pa[2];
    if (pd != NULL) {
        A[2][0] = pd[0] - pa[0];
        A[2][1] = pd[1] - pa[1];
        A[2][2] = pd[2] - pa[2];
    } else {
        cross(A[0], A[1], A[2]);
    }

    // Compute the right hand side vector b (3x1).
    rhs[0] = 0.5 * dot(A[0], A[0]);
    rhs[1] = 0.5 * dot(A[1], A[1]);
    if (pd != NULL) {
        rhs[2] = 0.5 * dot(A[2], A[2]);
    } else {
        rhs[2] = 0.0;
    }

    // Solve the 3 by 3 equations use LU decomposition with partial pivoting
    //   and backward and forward substitute..
    if (!lu_decmp(A, 3, indx, &D, 0)) {
        if (radius != (REAL*)NULL) *radius = 0.0;
        return false;
    }
    lu_solve(A, 3, indx, rhs, 0);
    if (cent != (REAL*)NULL) {
        cent[0] = pa[0] + rhs[0];
        cent[1] = pa[1] + rhs[1];
        cent[2] = pa[2] + rhs[2];
    }
    if (radius != (REAL*)NULL) {
        *radius = sqrt(rhs[0] * rhs[0] + rhs[1] * rhs[1] + rhs[2] * rhs[2]);
    }
    return true;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// orthosphere()    Calulcate the orthosphere of four weighted points.       //
//                                                                           //
// A weighted point (p, P^2) can be interpreted as a sphere centered at the  //
// point 'p' with a radius 'P'. The 'height' of 'p' is pheight = p[0]^2 +    //
// p[1]^2 + p[2]^2 - P^2.                                                    //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenmesh::orthosphere(REAL* pa, REAL* pb, REAL* pc, REAL* pd, REAL aheight, REAL bheight,
                             REAL cheight, REAL dheight, REAL* orthocent, REAL* radius) {
    REAL A[4][4], rhs[4], D;
    int indx[4];

    // Set the coefficient matrix A (4 x 4).
    A[0][0] = 1.0;
    A[0][1] = pa[0];
    A[0][2] = pa[1];
    A[0][3] = pa[2];
    A[1][0] = 1.0;
    A[1][1] = pb[0];
    A[1][2] = pb[1];
    A[1][3] = pb[2];
    A[2][0] = 1.0;
    A[2][1] = pc[0];
    A[2][2] = pc[1];
    A[2][3] = pc[2];
    A[3][0] = 1.0;
    A[3][1] = pd[0];
    A[3][2] = pd[1];
    A[3][3] = pd[2];

    // Set the right hand side vector (4 x 1).
    rhs[0] = 0.5 * aheight;
    rhs[1] = 0.5 * bheight;
    rhs[2] = 0.5 * cheight;
    rhs[3] = 0.5 * dheight;

    // Solve the 4 by 4 equations use LU decomposition with partial pivoting
    //   and backward and forward substitute..
    if (!lu_decmp(A, 4, indx, &D, 0)) {
        if (radius != (REAL*)NULL) *radius = 0.0;
        return false;
    }
    lu_solve(A, 4, indx, rhs, 0);

    if (orthocent != (REAL*)NULL) {
        orthocent[0] = rhs[1];
        orthocent[1] = rhs[2];
        orthocent[2] = rhs[3];
    }
    if (radius != (REAL*)NULL) {
        // rhs[0] = - rheight / 2;
        // rheight  = - 2 * rhs[0];
        //          =  r[0]^2 + r[1]^2 + r[2]^2 - radius^2
        // radius^2 = r[0]^2 + r[1]^2 + r[2]^2 -rheight
        //          = r[0]^2 + r[1]^2 + r[2]^2 + 2 * rhs[0]
        *radius = sqrt(rhs[1] * rhs[1] + rhs[2] * rhs[2] + rhs[3] * rhs[3] + 2.0 * rhs[0]);
    }
    return true;
}

void tetgenmesh::tetcircumcenter(point tetorg, point tetdest, point tetfapex, point tettapex,
                                 REAL* circumcenter, REAL* radius) {
    REAL xot, yot, zot, xdt, ydt, zdt, xft, yft, zft;
    REAL otlength, dtlength, ftlength;
    REAL xcrossdf, ycrossdf, zcrossdf;
    REAL xcrossfo, ycrossfo, zcrossfo;
    REAL xcrossod, ycrossod, zcrossod;
    REAL denominator;
    REAL xct, yct, zct;

    // tetcircumcentercount++;

    /* Use coordinates relative to the apex of the tetrahedron. */
    xot = tetorg[0] - tettapex[0];
    yot = tetorg[1] - tettapex[1];
    zot = tetorg[2] - tettapex[2];
    xdt = tetdest[0] - tettapex[0];
    ydt = tetdest[1] - tettapex[1];
    zdt = tetdest[2] - tettapex[2];
    xft = tetfapex[0] - tettapex[0];
    yft = tetfapex[1] - tettapex[1];
    zft = tetfapex[2] - tettapex[2];
    /* Squares of lengths of the origin, destination, and face apex edges. */
    otlength = xot * xot + yot * yot + zot * zot;
    dtlength = xdt * xdt + ydt * ydt + zdt * zdt;
    ftlength = xft * xft + yft * yft + zft * zft;
    /* Cross products of the origin, destination, and face apex vectors. */
    xcrossdf = ydt * zft - yft * zdt;
    ycrossdf = zdt * xft - zft * xdt;
    zcrossdf = xdt * yft - xft * ydt;
    xcrossfo = yft * zot - yot * zft;
    ycrossfo = zft * xot - zot * xft;
    zcrossfo = xft * yot - xot * yft;
    xcrossod = yot * zdt - ydt * zot;
    ycrossod = zot * xdt - zdt * xot;
    zcrossod = xot * ydt - xdt * yot;

    /* Calculate the denominator of all the formulae. */
    // if (noexact) {
    //  denominator = 0.5 / (xot * xcrossdf + yot * ycrossdf + zot * zcrossdf);
    //} else {
    /* Use the orient3d() routine to ensure a positive (and    */
    /*   reasonably accurate) result, avoiding any possibility */
    /*   of division by zero.                                  */
    denominator = 0.5 / orient3d(tetorg, tetdest, tetfapex, tettapex);
    /* Don't count the above as an orientation test. */
    // orientcount--;
    //}

    /* Calculate offset (from apex) of circumcenter. */
    xct = (otlength * xcrossdf + dtlength * xcrossfo + ftlength * xcrossod) * denominator;
    yct = (otlength * ycrossdf + dtlength * ycrossfo + ftlength * ycrossod) * denominator;
    zct = (otlength * zcrossdf + dtlength * zcrossfo + ftlength * zcrossod) * denominator;

    circumcenter[0] = xct + tettapex[0];
    circumcenter[1] = yct + tettapex[1];
    circumcenter[2] = zct + tettapex[2];

    if (radius != NULL) {
        *radius = sqrt(xct * xct + yct * yct + zct * zct);
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// planelineint()    Calculate the intersection of a line and a plane.       //
//                                                                           //
// The equation of a plane (points P are on the plane with normal N and P3   //
// on the plane) can be written as: N dot (P - P3) = 0. The equation of the  //
// line (points P on the line passing through P1 and P2) can be written as:  //
// P = P1 + u (P2 - P1). The intersection of these two occurs when:          //
//   N dot (P1 + u (P2 - P1)) = N dot P3.                                    //
// Solving for u gives:                                                      //
//         N dot (P3 - P1)                                                   //
//   u = ------------------.                                                 //
//         N dot (P2 - P1)                                                   //
// If the denominator is 0 then N (the normal to the plane) is perpendicular //
// to the line.  Thus the line is either parallel to the plane and there are //
// no solutions or the line is on the plane in which case there are an infi- //
// nite number of solutions.                                                 //
//                                                                           //
// The plane is given by three points pa, pb, and pc, e1 and e2 defines the  //
// line. If u is non-zero, The intersection point (if exists) returns in ip. //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::planelineint(REAL* pa, REAL* pb, REAL* pc, REAL* e1, REAL* e2, REAL* ip, REAL* u) {
    REAL n[3], det, det1;

    // Calculate N.
    facenormal(pa, pb, pc, n, 1, NULL);
    // Calculate N dot (e2 - e1).
    det = n[0] * (e2[0] - e1[0]) + n[1] * (e2[1] - e1[1]) + n[2] * (e2[2] - e1[2]);
    if (det != 0.0) {
        // Calculate N dot (pa - e1)
        det1 = n[0] * (pa[0] - e1[0]) + n[1] * (pa[1] - e1[1]) + n[2] * (pa[2] - e1[2]);
        *u = det1 / det;
        ip[0] = e1[0] + *u * (e2[0] - e1[0]);
        ip[1] = e1[1] + *u * (e2[1] - e1[1]);
        ip[2] = e1[2] + *u * (e2[2] - e1[2]);
    } else {
        *u = 0.0;
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// linelineint()    Calculate the intersection(s) of two line segments.      //
//                                                                           //
// Calculate the line segment [P, Q] that is the shortest route between two  //
// lines from A to B and C to D. Calculate also the values of tp and tq      //
// where: P = A + tp (B - A), and Q = C + tq (D - C).                        //
//                                                                           //
// Return 1 if the line segment exists. Otherwise, return 0.                 //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::linelineint(REAL* A, REAL* B, REAL* C, REAL* D, REAL* P, REAL* Q, REAL* tp,
                            REAL* tq) {
    REAL vab[3], vcd[3], vca[3];
    REAL vab_vab, vcd_vcd, vab_vcd;
    REAL vca_vab, vca_vcd;
    REAL det, eps;
    int i;

    for (i = 0; i < 3; i++) {
        vab[i] = B[i] - A[i];
        vcd[i] = D[i] - C[i];
        vca[i] = A[i] - C[i];
    }

    vab_vab = dot(vab, vab);
    vcd_vcd = dot(vcd, vcd);
    vab_vcd = dot(vab, vcd);

    det = vab_vab * vcd_vcd - vab_vcd * vab_vcd;
    // Round the result.
    eps = det / (fabs(vab_vab * vcd_vcd) + fabs(vab_vcd * vab_vcd));
    if (eps < b->epsilon) {
        return 0;
    }

    vca_vab = dot(vca, vab);
    vca_vcd = dot(vca, vcd);

    *tp = (vcd_vcd * (-vca_vab) + vab_vcd * vca_vcd) / det;
    *tq = (vab_vcd * (-vca_vab) + vab_vab * vca_vcd) / det;

    for (i = 0; i < 3; i++)
        P[i] = A[i] + (*tp) * vab[i];
    for (i = 0; i < 3; i++)
        Q[i] = C[i] + (*tq) * vcd[i];

    return 1;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// tetprismvol()    Calculate the volume of a tetrahedral prism in 4D.       //
//                                                                           //
// A tetrahedral prism is a convex uniform polychoron (four dimensional poly-//
// tope). It has 6 polyhedral cells: 2 tetrahedra connected by 4 triangular  //
// prisms. It has 14 faces: 8 triangular and 6 square. It has 16 edges and 8 //
// vertices. (Wikipedia).                                                    //
//                                                                           //
// Let 'p0', ..., 'p3' be four affinely independent points in R^3. They form //
// the lower tetrahedral facet of the prism.  The top tetrahedral facet is   //
// formed by four vertices, 'p4', ..., 'p7' in R^4, which is obtained by     //
// lifting each vertex of the lower facet into R^4 by a weight (height).  A  //
// canonical choice of the weights is the square of Euclidean norm of of the //
// points (vectors).                                                         //
//                                                                           //
//                                                                           //
// The return value is (4!) 24 times of the volume of the tetrahedral prism. //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

REAL tetgenmesh::tetprismvol(REAL* p0, REAL* p1, REAL* p2, REAL* p3) {
    REAL *p4, *p5, *p6, *p7;
    REAL w4, w5, w6, w7;
    REAL vol[4];

    p4 = p0;
    p5 = p1;
    p6 = p2;
    p7 = p3;

    // TO DO: these weights can be pre-calculated!
    w4 = dot(p0, p0);
    w5 = dot(p1, p1);
    w6 = dot(p2, p2);
    w7 = dot(p3, p3);

    // Calculate the volume of the tet-prism.
    vol[0] = orient4d(p5, p6, p4, p3, p7, w5, w6, w4, 0, w7);
    vol[1] = orient4d(p3, p6, p2, p0, p1, 0, w6, 0, 0, 0);
    vol[2] = orient4d(p4, p6, p3, p0, p1, w4, w6, 0, 0, 0);
    vol[3] = orient4d(p6, p5, p4, p3, p1, w6, w5, w4, 0, 0);

    return fabs(vol[0]) + fabs(vol[1]) + fabs(vol[2]) + fabs(vol[3]);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// calculateabovepoint()    Calculate a point above a facet in 'dummypoint'. //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenmesh::calculateabovepoint(arraypool* facpoints, point* ppa, point* ppb, point* ppc) {
    point *ppt, pa, pb, pc;
    REAL v1[3], v2[3], n[3];
    REAL lab, len, A, area;
    REAL x, y, z;
    int i;

    ppt = (point*)fastlookup(facpoints, 0);
    pa = *ppt;      // a is the first point.
    pb = pc = NULL; // Avoid compiler warnings.

    // Get a point b s.t. the length of [a, b] is maximal.
    lab = 0;
    for (i = 1; i < facpoints->objects; i++) {
        ppt = (point*)fastlookup(facpoints, i);
        x = (*ppt)[0] - pa[0];
        y = (*ppt)[1] - pa[1];
        z = (*ppt)[2] - pa[2];
        len = x * x + y * y + z * z;
        if (len > lab) {
            lab = len;
            pb = *ppt;
        }
    }
    lab = sqrt(lab);
    if (lab == 0) {
        if (!b->quiet) {
            printf("Warning:  All points of a facet are coincident with %d.\n", pointmark(pa));
        }
        return false;
    }

    // Get a point c s.t. the area of [a, b, c] is maximal.
    v1[0] = pb[0] - pa[0];
    v1[1] = pb[1] - pa[1];
    v1[2] = pb[2] - pa[2];
    A = 0;
    for (i = 1; i < facpoints->objects; i++) {
        ppt = (point*)fastlookup(facpoints, i);
        v2[0] = (*ppt)[0] - pa[0];
        v2[1] = (*ppt)[1] - pa[1];
        v2[2] = (*ppt)[2] - pa[2];
        cross(v1, v2, n);
        area = dot(n, n);
        if (area > A) {
            A = area;
            pc = *ppt;
        }
    }
    if (A == 0) {
        // All points are collinear. No above point.
        if (!b->quiet) {
            printf("Warning:  All points of a facet are collinaer with [%d, %d].\n", pointmark(pa),
                   pointmark(pb));
        }
        return false;
    }

    // Calculate an above point of this facet.
    facenormal(pa, pb, pc, n, 1, NULL);
    len = sqrt(dot(n, n));
    n[0] /= len;
    n[1] /= len;
    n[2] /= len;
    lab /= 2.0; // Half the maximal length.
    dummypoint[0] = pa[0] + lab * n[0];
    dummypoint[1] = pa[1] + lab * n[1];
    dummypoint[2] = pa[2] + lab * n[2];

    if (ppa != NULL) {
        // Return the three points.
        *ppa = pa;
        *ppb = pb;
        *ppc = pc;
    }

    return true;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Calculate an above point. It lies above the plane containing  the subface //
//   [a,b,c], and save it in dummypoint. Moreover, the vector pa->dummypoint //
//   is the normal of the plane.                                             //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::calculateabovepoint4(point pa, point pb, point pc, point pd) {
    REAL n1[3], n2[3], *norm;
    REAL len, len1, len2;

    // Select a base.
    facenormal(pa, pb, pc, n1, 1, NULL);
    len1 = sqrt(dot(n1, n1));
    facenormal(pa, pb, pd, n2, 1, NULL);
    len2 = sqrt(dot(n2, n2));
    if (len1 > len2) {
        norm = n1;
        len = len1;
    } else {
        norm = n2;
        len = len2;
    }
    norm[0] /= len;
    norm[1] /= len;
    norm[2] /= len;
    len = distance(pa, pb);
    dummypoint[0] = pa[0] + len * norm[0];
    dummypoint[1] = pa[1] + len * norm[1];
    dummypoint[2] = pa[2] + len * norm[2];
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// report_overlapping_facets()    Report two overlapping facets.             //
//                                                                           //
// Two subfaces, f1 [a, b, c] and f2 [a, b, d], share the same edge [a, b].  //
// 'dihedang' is the dihedral angle between these two facets. It must less   //
// than the variable 'b->facet_overlap_angle_tol'.                           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::report_overlapping_facets(face* f1, face* f2, REAL dihedang) {
    point pa, pb, pc, pd;

    pa = sorg(*f1);
    pb = sdest(*f1);
    pc = sapex(*f1);
    pd = sapex(*f2);

    if (pc != pd) {
        printf("Found two %s self-intersecting facets.\n", dihedang > 0 ? "nearly" : "exactly");
        printf("  1st: [%d, %d, %d] #%d\n", pointmark(pa), pointmark(pb), pointmark(pc),
               shellmark(*f1));
        printf("  2nd: [%d, %d, %d] #%d\n", pointmark(pa), pointmark(pb), pointmark(pd),
               shellmark(*f2));
        if (dihedang > 0) {
            printf("The dihedral angle between them is %g degree.\n", dihedang / PI * 180.0);
            printf("Hint:  You may use -p/# to decrease the dihedral angle");
            printf("  tolerance %g (degree).\n", b->facet_overlap_ang_tol);
        }
    } else {
        if (shellmark(*f1) != shellmark(*f2)) {
            // Two identical faces from two different facet.
            printf("Found two overlapping facets.\n");
        } else {
            printf("Found two duplicated facets.\n");
        }
        printf("  1st: [%d, %d, %d] #%d\n", pointmark(pa), pointmark(pb), pointmark(pc),
               shellmark(*f1));
        printf("  2nd: [%d, %d, %d] #%d\n", pointmark(pa), pointmark(pb), pointmark(pd),
               shellmark(*f2));
    }

    // Return the information
    sevent.e_type = 6;
    sevent.f_marker1 = shellmark(*f1);
    sevent.f_vertices1[0] = pointmark(pa);
    sevent.f_vertices1[1] = pointmark(pb);
    sevent.f_vertices1[2] = pointmark(pc);
    sevent.f_marker2 = shellmark(*f2);
    sevent.f_vertices2[0] = pointmark(pa);
    sevent.f_vertices2[1] = pointmark(pb);
    sevent.f_vertices2[2] = pointmark(pd);

    terminatetetgen(this, 3);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// report_selfint_edge()    Report a self-intersection at an edge.           //
//                                                                           //
// The edge 'e1'->'e2' and the tetrahedron 'itet' intersect. 'dir' indicates //
// that the edge intersects the tet at its origin vertex (ACROSSVERTEX), or  //
// its current face (ACROSSFACE), or its current edge (ACROSSEDGE).          //
// If 'iedge' is not NULL, it is either a segment or a subface that contains //
// the edge 'e1'->'e2'.  It is used to report the geometry entity.           //
//                                                                           //
// Since it is a self-intersection, the vertex, edge or face of 'itet' that  //
// is intersecting with this edge must be an input vertex, a segment, or a   //
// subface, respectively.                                                    //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::report_selfint_edge(point e1, point e2, face* iedge, triface* itet,
                                    enum interresult dir) {
    point forg = NULL, fdest = NULL, fapex = NULL;
    int etype = 0, geomtag = 0, facemark = 0;

    if (iedge != NULL) {
        if (iedge->sh[5] != NULL) {
            etype = 2; // A subface
            forg = e1;
            fdest = e2;
            fapex = sapex(*iedge);
            facemark = shellmark(*iedge);
        } else {
            etype = 1; // A segment
            forg = farsorg(*iedge);
            fdest = farsdest(*iedge);
            // Get a facet containing this segment.
            face parentsh;
            spivot(*iedge, parentsh);
            if (parentsh.sh != NULL) {
                facemark = shellmark(parentsh);
            }
        }
        geomtag = shellmark(*iedge);
    }

    if (dir == SHAREEDGE) {
        // Two edges (segments) are coincide.
        face colseg;
        tsspivot1(*itet, colseg);
        if (etype == 1) {
            if (colseg.sh != iedge->sh) {
                face parentsh;
                spivot(colseg, parentsh);
                printf("PLC Error:  Two segments are overlapping.\n");
                printf("  Segment 1: [%d, %d] #%d (%d)\n", pointmark(sorg(colseg)),
                       pointmark(sdest(colseg)), shellmark(colseg),
                       parentsh.sh ? shellmark(parentsh) : 0);
                printf("  Segment 2: [%d, %d] #%d (%d)\n", pointmark(forg), pointmark(fdest),
                       geomtag, facemark);
                sevent.e_type = 4;
                sevent.f_marker1 = (parentsh.sh ? shellmark(parentsh) : 0);
                sevent.s_marker1 = shellmark(colseg);
                sevent.f_vertices1[0] = pointmark(sorg(colseg));
                sevent.f_vertices1[1] = pointmark(sdest(colseg));
                sevent.f_vertices1[2] = 0;
                sevent.f_marker2 = facemark;
                sevent.s_marker2 = geomtag;
                sevent.f_vertices2[0] = pointmark(forg);
                sevent.f_vertices2[1] = pointmark(fdest);
                sevent.f_vertices2[2] = 0;
            } else {
                // Two identical segments. Why report it?
                terminatetetgen(this, 2);
            }
        } else if (etype == 2) {
            printf("PLC Error:  A segment lies in a facet.\n");
            printf("  Segment: [%d, %d] #%d\n", pointmark(sorg(colseg)), pointmark(sdest(colseg)),
                   shellmark(colseg));
            printf("  Facet:   [%d,%d,%d] #%d\n", pointmark(forg), pointmark(fdest),
                   pointmark(fapex), geomtag);
            sevent.e_type = 5;
            sevent.f_marker1 = 0;
            sevent.s_marker1 = shellmark(colseg);
            sevent.f_vertices1[0] = pointmark(sorg(colseg));
            sevent.f_vertices1[1] = pointmark(sdest(colseg));
            sevent.f_vertices1[2] = 0;
            sevent.f_marker2 = geomtag;
            sevent.s_marker2 = 0;
            sevent.f_vertices2[0] = pointmark(forg);
            sevent.f_vertices2[1] = pointmark(fdest);
            sevent.f_vertices2[2] = pointmark(fapex);
        }
    } else if (dir == SHAREFACE) {
        // Two triangles (subfaces) are coincide.
        face colface;
        tspivot(*itet, colface);
        if (etype == 2) {
            if (colface.sh != iedge->sh) {
                printf("PLC Error:  Two facets are overlapping.\n");
                printf("  Facet 1:  [%d,%d,%d] #%d\n", pointmark(forg), pointmark(fdest),
                       pointmark(fapex), geomtag);
                printf("  Facet 2:  [%d,%d,%d] #%d\n", pointmark(sorg(colface)),
                       pointmark(sdest(colface)), pointmark(sapex(colface)), shellmark(colface));
                sevent.e_type = 6;
                sevent.f_marker1 = geomtag;
                sevent.s_marker1 = 0;
                sevent.f_vertices1[0] = pointmark(forg);
                sevent.f_vertices1[1] = pointmark(fdest);
                sevent.f_vertices1[2] = pointmark(fapex);
                sevent.f_marker2 = shellmark(colface);
                sevent.s_marker2 = 0;
                sevent.f_vertices2[0] = pointmark(sorg(colface));
                sevent.f_vertices2[1] = pointmark(sdest(colface));
                sevent.f_vertices2[2] = pointmark(sapex(colface));
            } else {
                // Two identical subfaces. Why report it?
                terminatetetgen(this, 2);
            }
        } else {
            terminatetetgen(this, 2);
        }
    } else if (dir == ACROSSVERT) {
        point pp = dest(*itet);
        if ((pointtype(pp) == RIDGEVERTEX) || (pointtype(pp) == FACETVERTEX) ||
            (pointtype(pp) == VOLVERTEX)) {
            if (etype == 1) {
                printf("PLC Error:  A vertex lies in a segment.\n");
                printf("  Vertex:  [%d] (%g,%g,%g).\n", pointmark(pp), pp[0], pp[1], pp[2]);
                printf("  Segment: [%d, %d] #%d (%d)\n", pointmark(forg), pointmark(fdest), geomtag,
                       facemark);
                sevent.e_type = 7;
                sevent.f_marker1 = 0;
                sevent.s_marker1 = 0;
                sevent.f_vertices1[0] = pointmark(pp);
                sevent.f_vertices1[1] = 0;
                sevent.f_vertices1[2] = 0;
                sevent.f_marker2 = facemark;
                sevent.s_marker2 = geomtag;
                sevent.f_vertices2[0] = pointmark(forg);
                sevent.f_vertices2[1] = pointmark(fdest);
                sevent.f_vertices2[2] = 0;
                sevent.int_point[0] = pp[0];
                sevent.int_point[1] = pp[1];
                sevent.int_point[2] = pp[2];
            } else if (etype == 2) {
                printf("PLC Error:  A vertex lies in a facet.\n");
                printf("  Vertex: [%d] (%g,%g,%g).\n", pointmark(pp), pp[0], pp[1], pp[2]);
                printf("  Facet:  [%d,%d,%d] #%d\n", pointmark(forg), pointmark(fdest),
                       pointmark(fapex), geomtag);
                sevent.e_type = 8;
                sevent.f_marker1 = 0;
                sevent.s_marker1 = 0;
                sevent.f_vertices1[0] = pointmark(pp);
                sevent.f_vertices1[1] = 0;
                sevent.f_vertices1[2] = 0;
                sevent.f_marker2 = geomtag;
                sevent.s_marker2 = 0;
                sevent.f_vertices2[0] = pointmark(forg);
                sevent.f_vertices2[1] = pointmark(fdest);
                sevent.f_vertices2[2] = pointmark(fapex);
                sevent.int_point[0] = pp[0];
                sevent.int_point[1] = pp[1];
                sevent.int_point[2] = pp[2];
            }
        } else if (pointtype(pp) == FREESEGVERTEX) {
            face parentseg, parentsh;
            sdecode(point2sh(pp), parentseg);
            spivot(parentseg, parentsh);
            if (parentseg.sh != NULL) {
                point p1 = farsorg(parentseg);
                point p2 = farsdest(parentseg);
                if (etype == 1) {
                    printf("PLC Error:  Two segments intersect at point (%g,%g,%g).\n", pp[0],
                           pp[1], pp[2]);
                    printf("  Segment 1: [%d, %d], #%d (%d)\n", pointmark(forg), pointmark(fdest),
                           geomtag, facemark);
                    printf("  Segment 2: [%d, %d], #%d (%d)\n", pointmark(p1), pointmark(p2),
                           shellmark(parentseg), parentsh.sh ? shellmark(parentsh) : 0);
                    sevent.e_type = 1;
                    sevent.f_marker1 = facemark;
                    sevent.s_marker1 = geomtag;
                    sevent.f_vertices1[0] = pointmark(forg);
                    sevent.f_vertices1[1] = pointmark(fdest);
                    sevent.f_vertices1[2] = 0;
                    sevent.f_marker2 = (parentsh.sh ? shellmark(parentsh) : 0);
                    sevent.s_marker2 = shellmark(parentseg);
                    sevent.f_vertices2[0] = pointmark(p1);
                    sevent.f_vertices2[1] = pointmark(p2);
                    sevent.f_vertices2[2] = 0;
                    sevent.int_point[0] = pp[0];
                    sevent.int_point[1] = pp[1];
                    sevent.int_point[2] = pp[2];
                } else if (etype == 2) {
                    printf("PLC Error:  A segment and a facet intersect at point");
                    printf(" (%g,%g,%g).\n", pp[0], pp[1], pp[2]);
                    printf("  Segment: [%d, %d], #%d (%d)\n", pointmark(p1), pointmark(p2),
                           shellmark(parentseg), parentsh.sh ? shellmark(parentsh) : 0);
                    printf("  Facet:   [%d,%d,%d] #%d\n", pointmark(forg), pointmark(fdest),
                           pointmark(fapex), geomtag);
                    sevent.e_type = 2;
                    sevent.f_marker1 = (parentsh.sh ? shellmark(parentsh) : 0);
                    sevent.s_marker1 = shellmark(parentseg);
                    sevent.f_vertices1[0] = pointmark(p1);
                    sevent.f_vertices1[1] = pointmark(p2);
                    sevent.f_vertices1[2] = 0;
                    sevent.f_marker2 = geomtag;
                    sevent.s_marker2 = 0;
                    sevent.f_vertices2[0] = pointmark(forg);
                    sevent.f_vertices2[1] = pointmark(fdest);
                    sevent.f_vertices2[2] = pointmark(fapex);
                    sevent.int_point[0] = pp[0];
                    sevent.int_point[1] = pp[1];
                    sevent.int_point[2] = pp[2];
                }
            } else {
                terminatetetgen(this, 2); // Report a bug.
            }
        } else if (pointtype(pp) == FREEFACETVERTEX) {
            face parentsh;
            sdecode(point2sh(pp), parentsh);
            if (parentsh.sh != NULL) {
                point p1 = sorg(parentsh);
                point p2 = sdest(parentsh);
                point p3 = sapex(parentsh);
                if (etype == 1) {
                    printf("PLC Error:  A segment and a facet intersect at point");
                    printf(" (%g,%g,%g).\n", pp[0], pp[1], pp[2]);
                    printf("  Segment : [%d, %d], #%d (%d)\n", pointmark(forg), pointmark(fdest),
                           geomtag, facemark);
                    printf("  Facet   : [%d, %d, %d]  #%d.\n", pointmark(p1), pointmark(p2),
                           pointmark(p3), shellmark(parentsh));
                    sevent.e_type = 2;
                    sevent.f_marker1 = facemark;
                    sevent.s_marker1 = geomtag;
                    sevent.f_vertices1[0] = pointmark(forg);
                    sevent.f_vertices1[1] = pointmark(fdest);
                    sevent.f_vertices1[2] = 0;
                    sevent.f_marker2 = shellmark(parentsh);
                    sevent.s_marker2 = 0;
                    sevent.f_vertices2[0] = pointmark(p1);
                    sevent.f_vertices2[1] = pointmark(p2);
                    sevent.f_vertices2[2] = pointmark(p3);
                    sevent.int_point[0] = pp[0];
                    sevent.int_point[1] = pp[1];
                    sevent.int_point[2] = pp[2];
                } else if (etype == 2) {
                    printf("PLC Error:  Two facets intersect at point (%g,%g,%g).\n", pp[0], pp[1],
                           pp[2]);
                    printf("  Facet 1: [%d, %d, %d] #%d.\n", pointmark(forg), pointmark(fdest),
                           pointmark(fapex), geomtag);
                    printf("  Facet 2: [%d, %d, %d] #%d.\n", pointmark(p1), pointmark(p2),
                           pointmark(p3), shellmark(parentsh));
                    sevent.e_type = 3;
                    sevent.f_marker1 = geomtag;
                    sevent.s_marker1 = 0;
                    sevent.f_vertices1[0] = pointmark(forg);
                    sevent.f_vertices1[1] = pointmark(fdest);
                    sevent.f_vertices1[2] = pointmark(fapex);
                    sevent.f_marker2 = shellmark(parentsh);
                    sevent.s_marker2 = 0;
                    sevent.f_vertices2[0] = pointmark(p1);
                    sevent.f_vertices2[1] = pointmark(p2);
                    sevent.f_vertices2[2] = pointmark(p3);
                    sevent.int_point[0] = pp[0];
                    sevent.int_point[1] = pp[1];
                    sevent.int_point[2] = pp[2];
                }
            } else {
                terminatetetgen(this, 2); // Report a bug.
            }
        } else if (pointtype(pp) == FREEVOLVERTEX) {
            // This is not a PLC error.
            // We should shift the vertex.
            // not down yet.
            terminatetetgen(this, 2); // Report a bug.
        } else {
            terminatetetgen(this, 2); // Report a bug.
        }
        terminatetetgen(this, 3);
    } else if (dir == ACROSSEDGE) {
        if (issubseg(*itet)) {
            face checkseg;
            tsspivot1(*itet, checkseg);
            face parentsh;
            spivot(checkseg, parentsh);
            // Calulcate the intersecting point.
            point p1 = sorg(checkseg);
            point p2 = sdest(checkseg);
            REAL P[3], Q[3], tp = 0, tq = 0;
            linelineint(e1, e2, p1, p2, P, Q, &tp, &tq);
            if (etype == 1) {
                printf("PLC Error:  Two segments intersect at point (%g,%g,%g).\n", P[0], P[1],
                       P[2]);
                printf("  Segment 1: [%d, %d] #%d (%d)\n", pointmark(forg), pointmark(fdest),
                       geomtag, facemark);
                printf("  Segment 2: [%d, %d] #%d (%d)\n", pointmark(p1), pointmark(p2),
                       shellmark(checkseg), parentsh.sh ? shellmark(parentsh) : 0);
                sevent.e_type = 1;
                sevent.f_marker1 = facemark;
                sevent.s_marker1 = geomtag;
                sevent.f_vertices1[0] = pointmark(forg);
                sevent.f_vertices1[1] = pointmark(fdest);
                sevent.f_vertices1[2] = 0;
                sevent.f_marker2 = (parentsh.sh ? shellmark(parentsh) : 0);
                sevent.s_marker2 = shellmark(checkseg);
                sevent.f_vertices2[0] = pointmark(p1);
                sevent.f_vertices2[1] = pointmark(p2);
                sevent.f_vertices2[2] = 0;
                sevent.int_point[0] = P[0];
                sevent.int_point[1] = P[1];
                sevent.int_point[2] = P[2];
            } else if (etype == 2) {
                printf("PLC Error:  A segment and a facet intersect at point");
                printf(" (%g,%g,%g).\n", P[0], P[1], P[2]);
                printf("  Segment: [%d, %d] #%d (%d)\n", pointmark(p1), pointmark(p2),
                       shellmark(checkseg), parentsh.sh ? shellmark(parentsh) : 0);
                printf("  Facet:   [%d, %d, %d] #%d.\n", pointmark(forg), pointmark(fdest),
                       pointmark(fapex), geomtag);
                sevent.e_type = 2;
                sevent.f_marker1 = (parentsh.sh ? shellmark(parentsh) : 0);
                sevent.s_marker1 = shellmark(checkseg);
                sevent.f_vertices1[0] = pointmark(p1);
                sevent.f_vertices1[1] = pointmark(p2);
                sevent.f_vertices1[2] = 0;
                sevent.f_marker2 = geomtag;
                sevent.s_marker2 = 0;
                sevent.f_vertices2[0] = pointmark(forg);
                sevent.f_vertices2[1] = pointmark(fdest);
                sevent.f_vertices2[2] = pointmark(fapex);
                sevent.int_point[0] = P[0];
                sevent.int_point[1] = P[1];
                sevent.int_point[2] = P[2];
            }
            terminatetetgen(this, 3);
        }
    } else if (dir == ACROSSFACE) {
        if (issubface(*itet)) {
            face checksh;
            tspivot(*itet, checksh);
            point p1 = sorg(checksh);
            point p2 = sdest(checksh);
            point p3 = sapex(checksh);
            REAL ip[3], u = 0;
            planelineint(p1, p2, p3, e1, e2, ip, &u);
            if (etype == 1) {
                printf("PLC Error:  A segment and a facet intersect at point");
                printf(" (%g,%g,%g).\n", ip[0], ip[1], ip[2]);
                printf("  Segment: [%d, %d] #%d (%d)\n", pointmark(forg), pointmark(fdest), geomtag,
                       facemark);
                printf("  Facet:   [%d, %d, %d] #%d.\n", pointmark(p1), pointmark(p2),
                       pointmark(p3), shellmark(checksh));
                sevent.e_type = 2;
                sevent.f_marker1 = facemark;
                sevent.s_marker1 = geomtag;
                sevent.f_vertices1[0] = pointmark(forg);
                sevent.f_vertices1[1] = pointmark(fdest);
                sevent.f_vertices1[2] = 0;
                sevent.f_marker2 = shellmark(checksh);
                sevent.s_marker2 = 0;
                sevent.f_vertices2[0] = pointmark(p1);
                sevent.f_vertices2[1] = pointmark(p2);
                sevent.f_vertices2[2] = pointmark(p3);
                sevent.int_point[0] = ip[0];
                sevent.int_point[1] = ip[1];
                sevent.int_point[2] = ip[2];
            } else if (etype == 2) {
                printf("PLC Error:  Two facets intersect at point (%g,%g,%g).\n", ip[0], ip[1],
                       ip[2]);
                printf("  Facet 1: [%d, %d, %d] #%d.\n", pointmark(forg), pointmark(fdest),
                       pointmark(fapex), geomtag);
                printf("  Facet 2: [%d, %d, %d] #%d.\n", pointmark(p1), pointmark(p2),
                       pointmark(p3), shellmark(checksh));
                sevent.e_type = 3;
                sevent.f_marker1 = geomtag;
                sevent.s_marker1 = 0;
                sevent.f_vertices1[0] = pointmark(forg);
                sevent.f_vertices1[1] = pointmark(fdest);
                sevent.f_vertices1[2] = pointmark(fapex);
                sevent.f_marker2 = shellmark(checksh);
                sevent.s_marker2 = 0;
                sevent.f_vertices2[0] = pointmark(p1);
                sevent.f_vertices2[1] = pointmark(p2);
                sevent.f_vertices2[2] = pointmark(p3);
                sevent.int_point[0] = ip[0];
                sevent.int_point[1] = ip[1];
                sevent.int_point[2] = ip[2];
            }
            terminatetetgen(this, 3);
        }
    } else {
        // An unknown 'dir'.
        terminatetetgen(this, 2);
    }
    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// report_selfint_face()    Report a self-intersection at a facet.           //
//                                                                           //
// The triangle with vertices 'p1', 'p2', and 'p3' intersects with the edge  //
// of the tetrahedra 'iedge'. The intersection type is reported by 'intflag',//
// 'types', and 'poss'.                                                      //
//                                                                           //
// This routine ASSUMES (1) the triangle (p1,p2,p3) must belong to a facet,  //
// 'sface' is a subface of the same facet; and (2) 'iedge' must be either a  //
// segment or an edge of another facet.                                      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::report_selfint_face(point p1, point p2, point p3, face* sface, triface* iedge,
                                    int intflag, int* types, int* poss) {
    face iface;
    point e1 = NULL, e2 = NULL, e3 = NULL;
    int etype = 0, geomtag = 0, facemark = 0;

    geomtag = shellmark(*sface);

    if (issubface(*iedge)) {
        tspivot(*iedge, iface);
        e1 = sorg(iface);
        e2 = sdest(iface);
        e3 = sapex(iface);
        etype = 2;
        facemark = geomtag;
    } else if (issubseg(*iedge)) {
        tsspivot1(*iedge, iface);
        e1 = farsorg(iface);
        e2 = farsdest(iface);
        etype = 1;
        face parentsh;
        spivot(iface, parentsh);
        facemark = shellmark(parentsh);
    } else {
        terminatetetgen(this, 2);
    }

    if (intflag == 2) {
        // The triangle and the edge intersect only at one point.
        REAL ip[3], u = 0;
        planelineint(p1, p2, p3, e1, e2, ip, &u);
        if ((types[0] == (int)ACROSSFACE) || (types[0] == (int)ACROSSEDGE)) {
            // The triangle and the edge intersect in their interiors.
            if (etype == 1) {
                printf("PLC Error:  A segment and a facet intersect at point");
                printf(" (%g,%g,%g).\n", ip[0], ip[1], ip[2]);
                printf("  Segment: [%d,%d] #%d (%d)\n", pointmark(e1), pointmark(e2),
                       shellmark(iface), facemark);
                printf("  Facet:   [%d,%d,%d] #%d\n", pointmark(p1), pointmark(p2), pointmark(p3),
                       geomtag);
                sevent.e_type = 2;
                sevent.f_marker1 = facemark;
                sevent.s_marker1 = shellmark(iface);
                sevent.f_vertices1[0] = pointmark(e1);
                sevent.f_vertices1[1] = pointmark(e2);
                sevent.f_vertices1[2] = 0;
                sevent.f_marker2 = geomtag;
                sevent.s_marker2 = 0;
                sevent.f_vertices2[0] = pointmark(p1);
                sevent.f_vertices2[1] = pointmark(p2);
                sevent.f_vertices2[2] = pointmark(p3);
                sevent.int_point[0] = ip[0];
                sevent.int_point[1] = ip[1];
                sevent.int_point[2] = ip[2];
            } else {
                printf("PLC Error:  Two facets intersect at point");
                printf(" (%g,%g,%g).\n", ip[0], ip[1], ip[2]);
                printf("  Facet 1: [%d,%d,%d] #%d\n", pointmark(e1), pointmark(e2),
                       pointmark(sorg(iface)), shellmark(iface));
                printf("  Facet 2: [%d,%d,%d] #%d\n", pointmark(p1), pointmark(p2), pointmark(p3),
                       geomtag);
                sevent.e_type = 3;
                sevent.f_marker1 = shellmark(iface);
                sevent.s_marker1 = 0;
                sevent.f_vertices1[0] = pointmark(e1);
                sevent.f_vertices1[1] = pointmark(e2);
                sevent.f_vertices1[2] = pointmark(sorg(iface));
                sevent.f_marker2 = geomtag;
                sevent.s_marker2 = 0;
                sevent.f_vertices2[0] = pointmark(p1);
                sevent.f_vertices2[1] = pointmark(p2);
                sevent.f_vertices2[2] = pointmark(p3);
                sevent.int_point[0] = ip[0];
                sevent.int_point[1] = ip[1];
                sevent.int_point[2] = ip[2];
            }
        } else if (types[0] == (int)ACROSSVERT) {
            // A vertex of the triangle and the edge intersect.
            point crosspt = NULL;
            if (poss[0] == 0) {
                crosspt = p1;
            } else if (poss[0] == 1) {
                crosspt = p2;
            } else if (poss[0] == 2) {
                crosspt = p3;
            } else {
                terminatetetgen(this, 2);
            }
            if (!issteinerpoint(crosspt)) {
                if (etype == 1) {
                    printf("PLC Error:  A vertex and a segment intersect at (%g,%g,%g)\n",
                           crosspt[0], crosspt[1], crosspt[2]);
                    printf("  Vertex:  #%d\n", pointmark(crosspt));
                    printf("  Segment: [%d,%d] #%d (%d)\n", pointmark(e1), pointmark(e2),
                           shellmark(iface), facemark);
                    sevent.e_type = 7;
                    sevent.f_marker1 = 0;
                    sevent.s_marker1 = 0;
                    sevent.f_vertices1[0] = pointmark(crosspt);
                    sevent.f_vertices1[1] = 0;
                    sevent.f_vertices1[2] = 0;
                    sevent.f_marker2 = facemark;
                    sevent.s_marker2 = shellmark(iface);
                    sevent.f_vertices2[0] = pointmark(e1);
                    sevent.f_vertices2[1] = pointmark(e2);
                    sevent.f_vertices2[2] = 0;
                    sevent.int_point[0] = crosspt[0];
                    sevent.int_point[1] = crosspt[1];
                    sevent.int_point[2] = crosspt[2];
                } else {
                    printf("PLC Error:  A vertex and a facet intersect at (%g,%g,%g)\n", crosspt[0],
                           crosspt[1], crosspt[2]);
                    printf("  Vertex:  #%d\n", pointmark(crosspt));
                    printf("  Facet:   [%d,%d,%d] #%d\n", pointmark(p1), pointmark(p2),
                           pointmark(p3), geomtag);
                    sevent.e_type = 8;
                    sevent.f_marker1 = 0;
                    sevent.s_marker1 = 0;
                    sevent.f_vertices1[0] = pointmark(crosspt);
                    sevent.f_vertices1[1] = 0;
                    sevent.f_vertices1[2] = 0;
                    sevent.f_marker2 = geomtag;
                    sevent.s_marker2 = 0;
                    sevent.f_vertices2[0] = pointmark(p1);
                    sevent.f_vertices2[1] = pointmark(p2);
                    sevent.f_vertices2[2] = pointmark(p3);
                    sevent.int_point[0] = crosspt[0];
                    sevent.int_point[1] = crosspt[1];
                    sevent.int_point[2] = crosspt[2];
                }
            } else {
                // It is a Steiner point. To be processed.
                terminatetetgen(this, 2);
            }
        } else if ((types[0] == (int)TOUCHFACE) || (types[0] == (int)TOUCHEDGE)) {
            // The triangle and a vertex of the edge intersect.
            point touchpt = NULL;
            if (poss[1] == 0) {
                touchpt = org(*iedge);
            } else if (poss[1] == 1) {
                touchpt = dest(*iedge);
            } else {
                terminatetetgen(this, 2);
            }
            if (!issteinerpoint(touchpt)) {
                printf("PLC Error:  A vertex and a facet intersect at (%g,%g,%g)\n", touchpt[0],
                       touchpt[1], touchpt[2]);
                printf("  Vertex:  #%d\n", pointmark(touchpt));
                printf("  Facet:   [%d,%d,%d] #%d\n", pointmark(p1), pointmark(p2), pointmark(p3),
                       geomtag);
                sevent.e_type = 8;
                sevent.f_marker1 = 0;
                sevent.s_marker1 = 0;
                sevent.f_vertices1[0] = pointmark(touchpt);
                sevent.f_vertices1[1] = 0;
                sevent.f_vertices1[2] = 0;
                sevent.f_marker2 = geomtag;
                sevent.s_marker2 = 0;
                sevent.f_vertices2[0] = pointmark(p1);
                sevent.f_vertices2[1] = pointmark(p2);
                sevent.f_vertices2[2] = pointmark(p3);
                sevent.int_point[0] = touchpt[0];
                sevent.int_point[1] = touchpt[1];
                sevent.int_point[2] = touchpt[2];
            } else {
                // It is a Steiner point. To be processed.
                terminatetetgen(this, 2);
            }
        } else if (types[0] == (int)SHAREVERT) {
            terminatetetgen(this, 2);
        } else {
            terminatetetgen(this, 2);
        }
    } else if (intflag == 4) {
        if (types[0] == (int)SHAREFACE) {
            printf("PLC Error:  Two facets are overlapping.\n");
            printf("  Facet 1:   [%d,%d,%d] #%d\n", pointmark(e1), pointmark(e2), pointmark(e3),
                   facemark);
            printf("  Facet 2:   [%d,%d,%d] #%d\n", pointmark(p1), pointmark(p2), pointmark(p3),
                   geomtag);
            sevent.e_type = 6;
            sevent.f_marker1 = facemark;
            sevent.s_marker1 = 0;
            sevent.f_vertices1[0] = pointmark(e1);
            sevent.f_vertices1[1] = pointmark(e2);
            sevent.f_vertices1[2] = pointmark(e3);
            sevent.f_marker2 = geomtag;
            sevent.s_marker2 = 0;
            sevent.f_vertices2[0] = pointmark(p1);
            sevent.f_vertices2[1] = pointmark(p2);
            sevent.f_vertices2[2] = pointmark(p3);
        } else {
            terminatetetgen(this, 2);
        }
    } else {
        terminatetetgen(this, 2);
    }

    terminatetetgen(this, 3);
    return 0;
}

////                                                                       ////
////                                                                       ////
//// geom_cxx /////////////////////////////////////////////////////////////////

//// flip_cxx /////////////////////////////////////////////////////////////////
////                                                                       ////
////                                                                       ////

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// flip23()    Perform a 2-to-3 flip (face-to-edge flip).                    //
//                                                                           //
// 'fliptets' is an array of three tets (handles), where the [0] and [1] are  //
// [a,b,c,d] and [b,a,c,e].  The three new tets: [e,d,a,b], [e,d,b,c], and   //
// [e,d,c,a] are returned in [0], [1], and [2] of 'fliptets'.  As a result,  //
// The face [a,b,c] is removed, and the edge [d,e] is created.               //
//                                                                           //
// If 'hullflag' > 0, hull tets may be involved in this flip, i.e., one of   //
// the five vertices may be 'dummypoint'. There are two canonical cases:     //
//   (1) d is 'dummypoint', then all three new tets are hull tets.  If e is  //
//       'dummypoint', we reconfigure e to d, i.e., turn it up-side down.    //
//   (2) c is 'dummypoint', then two new tets: [e,d,b,c] and [e,d,c,a], are  //
//       hull tets. If a or b is 'dummypoint', we reconfigure it to c, i.e., //
//       rotate the three input tets counterclockwisely (right-hand rule)    //
//       until a or b is in c's position.                                    //
//                                                                           //
// If 'fc->enqflag' is set, convex hull faces will be queued for flipping.   //
// In particular, if 'fc->enqflag' is 1, it is called by incrementalflip()   //
// after the insertion of a new point.  It is assumed that 'd' is the new    //
// point. IN this case, only link faces of 'd' are queued.                   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::flip23(triface* fliptets, int hullflag, flipconstraints* fc) {
    triface topcastets[3], botcastets[3];
    triface newface, casface;
    point pa, pb, pc, pd, pe;
    REAL attrib, volume;
    int dummyflag = 0; // range = {-1, 0, 1, 2}.
    int i;

    if (hullflag > 0) {
        // Check if e is dummypoint.
        if (oppo(fliptets[1]) == dummypoint) {
            // Swap the two old tets.
            newface = fliptets[0];
            fliptets[0] = fliptets[1];
            fliptets[1] = newface;
            dummyflag = -1; // d is dummypoint.
        } else {
            // Check if either a or b is dummypoint.
            if (org(fliptets[0]) == dummypoint) {
                dummyflag = 1; // a is dummypoint.
                enextself(fliptets[0]);
                eprevself(fliptets[1]);
            } else if (dest(fliptets[0]) == dummypoint) {
                dummyflag = 2; // b is dummypoint.
                eprevself(fliptets[0]);
                enextself(fliptets[1]);
            } else {
                dummyflag = 0; // either c or d may be dummypoint.
            }
        }
    }

    pa = org(fliptets[0]);
    pb = dest(fliptets[0]);
    pc = apex(fliptets[0]);
    pd = oppo(fliptets[0]);
    pe = oppo(fliptets[1]);

    flip23count++;

    // Get the outer boundary faces.
    for (i = 0; i < 3; i++) {
        fnext(fliptets[0], topcastets[i]);
        enextself(fliptets[0]);
    }
    for (i = 0; i < 3; i++) {
        fnext(fliptets[1], botcastets[i]);
        eprevself(fliptets[1]);
    }

    // Re-use fliptets[0] and fliptets[1].
    fliptets[0].ver = 11;
    fliptets[1].ver = 11;
    setelemmarker(fliptets[0].tet, 0); // Clear all flags.
    setelemmarker(fliptets[1].tet, 0);
    // NOTE: the element attributes and volume constraint remain unchanged.
    if (checksubsegflag) {
        // Dealloc the space to subsegments.
        if (fliptets[0].tet[8] != NULL) {
            tet2segpool->dealloc((shellface*)fliptets[0].tet[8]);
            fliptets[0].tet[8] = NULL;
        }
        if (fliptets[1].tet[8] != NULL) {
            tet2segpool->dealloc((shellface*)fliptets[1].tet[8]);
            fliptets[1].tet[8] = NULL;
        }
    }
    if (checksubfaceflag) {
        // Dealloc the space to subfaces.
        if (fliptets[0].tet[9] != NULL) {
            tet2subpool->dealloc((shellface*)fliptets[0].tet[9]);
            fliptets[0].tet[9] = NULL;
        }
        if (fliptets[1].tet[9] != NULL) {
            tet2subpool->dealloc((shellface*)fliptets[1].tet[9]);
            fliptets[1].tet[9] = NULL;
        }
    }
    // Create a new tet.
    maketetrahedron(&(fliptets[2]));
    // The new tet have the same attributes from the old tet.
    for (i = 0; i < numelemattrib; i++) {
        attrib = elemattribute(fliptets[0].tet, i);
        setelemattribute(fliptets[2].tet, i, attrib);
    }
    if (b->varvolume) {
        volume = volumebound(fliptets[0].tet);
        setvolumebound(fliptets[2].tet, volume);
    }

    if (hullflag > 0) {
        // Check if d is dummytet.
        if (pd != dummypoint) {
            setvertices(fliptets[0], pe, pd, pa, pb); // [e,d,a,b] *
            setvertices(fliptets[1], pe, pd, pb, pc); // [e,d,b,c] *
            // Check if c is dummypoint.
            if (pc != dummypoint) {
                setvertices(fliptets[2], pe, pd, pc, pa); // [e,d,c,a] *
            } else {
                setvertices(fliptets[2], pd, pe, pa, pc); // [d,e,a,c]
                esymself(fliptets[2]);                    // [e,d,c,a] *
            }
            // The hullsize does not change.
        } else {
            // d is dummypoint.
            setvertices(fliptets[0], pa, pb, pe, pd); // [a,b,e,d]
            setvertices(fliptets[1], pb, pc, pe, pd); // [b,c,e,d]
            setvertices(fliptets[2], pc, pa, pe, pd); // [c,a,e,d]
            // Adjust the faces to [e,d,a,b], [e,d,b,c], [e,d,c,a] *
            for (i = 0; i < 3; i++) {
                eprevesymself(fliptets[i]);
                enextself(fliptets[i]);
            }
            // We deleted one hull tet, and created three hull tets.
            hullsize += 2;
        }
    } else {
        setvertices(fliptets[0], pe, pd, pa, pb); // [e,d,a,b] *
        setvertices(fliptets[1], pe, pd, pb, pc); // [e,d,b,c] *
        setvertices(fliptets[2], pe, pd, pc, pa); // [e,d,c,a] *
    }

    if (fc->remove_ndelaunay_edge) { // calc_tetprism_vol
        REAL volneg[2], volpos[3], vol_diff;
        if (pd != dummypoint) {
            if (pc != dummypoint) {
                volpos[0] = tetprismvol(pe, pd, pa, pb);
                volpos[1] = tetprismvol(pe, pd, pb, pc);
                volpos[2] = tetprismvol(pe, pd, pc, pa);
                volneg[0] = tetprismvol(pa, pb, pc, pd);
                volneg[1] = tetprismvol(pb, pa, pc, pe);
            } else { // pc == dummypoint
                volpos[0] = tetprismvol(pe, pd, pa, pb);
                volpos[1] = 0.;
                volpos[2] = 0.;
                volneg[0] = 0.;
                volneg[1] = 0.;
            }
        } else { // pd == dummypoint.
            volpos[0] = 0.;
            volpos[1] = 0.;
            volpos[2] = 0.;
            volneg[0] = 0.;
            volneg[1] = tetprismvol(pb, pa, pc, pe);
        }
        vol_diff = volpos[0] + volpos[1] + volpos[2] - volneg[0] - volneg[1];
        fc->tetprism_vol_sum += vol_diff; // Update the total sum.
    }

    // Bond three new tets together.
    for (i = 0; i < 3; i++) {
        esym(fliptets[i], newface);
        bond(newface, fliptets[(i + 1) % 3]);
    }
    // Bond to top outer boundary faces (at [a,b,c,d]).
    for (i = 0; i < 3; i++) {
        eorgoppo(fliptets[i], newface); // At edges [b,a], [c,b], [a,c].
        bond(newface, topcastets[i]);
    }
    // Bond bottom outer boundary faces (at [b,a,c,e]).
    for (i = 0; i < 3; i++) {
        edestoppo(fliptets[i], newface); // At edges [a,b], [b,c], [c,a].
        bond(newface, botcastets[i]);
    }

    if (checksubsegflag) {
        // Bond subsegments if there are.
        // Each new tet has 5 edges to be checked (except the edge [e,d]).
        face checkseg;
        // The middle three: [a,b], [b,c], [c,a].
        for (i = 0; i < 3; i++) {
            if (issubseg(topcastets[i])) {
                tsspivot1(topcastets[i], checkseg);
                eorgoppo(fliptets[i], newface);
                tssbond1(newface, checkseg);
                sstbond1(checkseg, newface);
                if (fc->chkencflag & 1) {
                    enqueuesubface(badsubsegs, &checkseg);
                }
            }
        }
        // The top three: [d,a], [d,b], [d,c]. Two tets per edge.
        for (i = 0; i < 3; i++) {
            eprev(topcastets[i], casface);
            if (issubseg(casface)) {
                tsspivot1(casface, checkseg);
                enext(fliptets[i], newface);
                tssbond1(newface, checkseg);
                sstbond1(checkseg, newface);
                esym(fliptets[(i + 2) % 3], newface);
                eprevself(newface);
                tssbond1(newface, checkseg);
                sstbond1(checkseg, newface);
                if (fc->chkencflag & 1) {
                    enqueuesubface(badsubsegs, &checkseg);
                }
            }
        }
        // The bot three: [a,e], [b,e], [c,e]. Two tets per edge.
        for (i = 0; i < 3; i++) {
            enext(botcastets[i], casface);
            if (issubseg(casface)) {
                tsspivot1(casface, checkseg);
                eprev(fliptets[i], newface);
                tssbond1(newface, checkseg);
                sstbond1(checkseg, newface);
                esym(fliptets[(i + 2) % 3], newface);
                enextself(newface);
                tssbond1(newface, checkseg);
                sstbond1(checkseg, newface);
                if (fc->chkencflag & 1) {
                    enqueuesubface(badsubsegs, &checkseg);
                }
            }
        }
    } // if (checksubsegflag)

    if (checksubfaceflag) {
        // Bond 6 subfaces if there are.
        face checksh;
        for (i = 0; i < 3; i++) {
            if (issubface(topcastets[i])) {
                tspivot(topcastets[i], checksh);
                eorgoppo(fliptets[i], newface);
                sesymself(checksh);
                tsbond(newface, checksh);
                if (fc->chkencflag & 2) {
                    enqueuesubface(badsubfacs, &checksh);
                }
            }
        }
        for (i = 0; i < 3; i++) {
            if (issubface(botcastets[i])) {
                tspivot(botcastets[i], checksh);
                edestoppo(fliptets[i], newface);
                sesymself(checksh);
                tsbond(newface, checksh);
                if (fc->chkencflag & 2) {
                    enqueuesubface(badsubfacs, &checksh);
                }
            }
        }
    } // if (checksubfaceflag)

    if (fc->chkencflag & 4) {
        // Put three new tets into check list.
        for (i = 0; i < 3; i++) {
            enqueuetetrahedron(&(fliptets[i]));
        }
    }

    // Update the point-to-tet map.
    setpoint2tet(pa, (tetrahedron)fliptets[0].tet);
    setpoint2tet(pb, (tetrahedron)fliptets[0].tet);
    setpoint2tet(pc, (tetrahedron)fliptets[1].tet);
    setpoint2tet(pd, (tetrahedron)fliptets[0].tet);
    setpoint2tet(pe, (tetrahedron)fliptets[0].tet);

    if (hullflag > 0) {
        if (dummyflag != 0) {
            // Restore the original position of the points (for flipnm()).
            if (dummyflag == -1) {
                // Reverse the edge.
                for (i = 0; i < 3; i++) {
                    esymself(fliptets[i]);
                }
                // Swap the last two new tets.
                newface = fliptets[1];
                fliptets[1] = fliptets[2];
                fliptets[2] = newface;
            } else {
                // either a or b were swapped.
                if (dummyflag == 1) {
                    // a is dummypoint.
                    newface = fliptets[0];
                    fliptets[0] = fliptets[2];
                    fliptets[2] = fliptets[1];
                    fliptets[1] = newface;
                } else { // dummyflag == 2
                    // b is dummypoint.
                    newface = fliptets[0];
                    fliptets[0] = fliptets[1];
                    fliptets[1] = fliptets[2];
                    fliptets[2] = newface;
                }
            }
        }
    }

    if (fc->enqflag > 0) {
        // Queue faces which may be locally non-Delaunay.
        for (i = 0; i < 3; i++) {
            eprevesym(fliptets[i], newface);
            flippush(flipstack, &newface);
        }
        if (fc->enqflag > 1) {
            for (i = 0; i < 3; i++) {
                enextesym(fliptets[i], newface);
                flippush(flipstack, &newface);
            }
        }
    }

    recenttet = fliptets[0];
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// flip32()    Perform a 3-to-2 flip (edge-to-face flip).                    //
//                                                                           //
// 'fliptets' is an array of three tets (handles),  which are [e,d,a,b],     //
// [e,d,b,c], and [e,d,c,a].  The two new tets: [a,b,c,d] and [b,a,c,e] are  //
// returned in [0] and [1] of 'fliptets'.  As a result, the edge [e,d] is    //
// replaced by the face [a,b,c].                                             //
//                                                                           //
// If 'hullflag' > 0, hull tets may be involved in this flip, i.e., one of   //
// the five vertices may be 'dummypoint'. There are two canonical cases:     //
//   (1) d is 'dummypoint', then [a,b,c,d] is hull tet. If e is 'dummypoint',//
//       we reconfigure e to d, i.e., turnover it.                           //
//   (2) c is 'dummypoint' then both [a,b,c,d] and [b,a,c,e] are hull tets.  //
//       If a or b is 'dummypoint', we reconfigure it to c, i.e., rotate the //
//       three old tets counterclockwisely (right-hand rule) until a or b    //
//       is in c's position.                                                 //
//                                                                           //
// If 'fc->enqflag' is set, convex hull faces will be queued for flipping.   //
// In particular, if 'fc->enqflag' is 1, it is called by incrementalflip()   //
// after the insertion of a new point.  It is assumed that 'a' is the new    //
// point. In this case, only link faces of 'a' are queued.                   //
//                                                                           //
// If 'checksubfaceflag' is on (global variable), and assume [e,d] is not a  //
// segment. There may be two (interior) subfaces sharing at [e,d], which are //
// [e,d,p] and [e,d,q], where the pair (p,q) may be either (a,b), or (b,c),  //
// or (c,a)  In such case, a 2-to-2 flip is performed on these two subfaces  //
// and two new subfaces [p,q,e] and [p,q,d] are created. They are inserted   //
// back into the tetrahedralization.                                         //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::flip32(triface* fliptets, int hullflag, flipconstraints* fc) {
    triface topcastets[3], botcastets[3];
    triface newface, casface;
    face flipshs[3];
    face checkseg;
    point pa, pb, pc, pd, pe;
    REAL attrib, volume;
    int dummyflag = 0;           // Rangle = {-1, 0, 1, 2}
    int spivot = -1, scount = 0; // for flip22()
    int t1ver;
    int i, j;

    if (hullflag > 0) {
        // Check if e is 'dummypoint'.
        if (org(fliptets[0]) == dummypoint) {
            // Reverse the edge.
            for (i = 0; i < 3; i++) {
                esymself(fliptets[i]);
            }
            // Swap the last two tets.
            newface = fliptets[1];
            fliptets[1] = fliptets[2];
            fliptets[2] = newface;
            dummyflag = -1; // e is dummypoint.
        } else {
            // Check if a or b is the 'dummypoint'.
            if (apex(fliptets[0]) == dummypoint) {
                dummyflag = 1; // a is dummypoint.
                newface = fliptets[0];
                fliptets[0] = fliptets[1];
                fliptets[1] = fliptets[2];
                fliptets[2] = newface;
            } else if (apex(fliptets[1]) == dummypoint) {
                dummyflag = 2; // b is dummypoint.
                newface = fliptets[0];
                fliptets[0] = fliptets[2];
                fliptets[2] = fliptets[1];
                fliptets[1] = newface;
            } else {
                dummyflag = 0; // either c or d may be dummypoint.
            }
        }
    }

    pa = apex(fliptets[0]);
    pb = apex(fliptets[1]);
    pc = apex(fliptets[2]);
    pd = dest(fliptets[0]);
    pe = org(fliptets[0]);

    flip32count++;

    // Get the outer boundary faces.
    for (i = 0; i < 3; i++) {
        eorgoppo(fliptets[i], casface);
        fsym(casface, topcastets[i]);
    }
    for (i = 0; i < 3; i++) {
        edestoppo(fliptets[i], casface);
        fsym(casface, botcastets[i]);
    }

    if (checksubfaceflag) {
        // Check if there are interior subfaces at the edge [e,d].
        for (i = 0; i < 3; i++) {
            tspivot(fliptets[i], flipshs[i]);
            if (flipshs[i].sh != NULL) {
                // Found an interior subface.
                stdissolve(flipshs[i]); // Disconnect the sub-tet bond.
                scount++;
            } else {
                spivot = i;
            }
        }
    }

    // Re-use fliptets[0] and fliptets[1].
    fliptets[0].ver = 11;
    fliptets[1].ver = 11;
    setelemmarker(fliptets[0].tet, 0); // Clear all flags.
    setelemmarker(fliptets[1].tet, 0);
    if (checksubsegflag) {
        // Dealloc the space to subsegments.
        if (fliptets[0].tet[8] != NULL) {
            tet2segpool->dealloc((shellface*)fliptets[0].tet[8]);
            fliptets[0].tet[8] = NULL;
        }
        if (fliptets[1].tet[8] != NULL) {
            tet2segpool->dealloc((shellface*)fliptets[1].tet[8]);
            fliptets[1].tet[8] = NULL;
        }
    }
    if (checksubfaceflag) {
        // Dealloc the space to subfaces.
        if (fliptets[0].tet[9] != NULL) {
            tet2subpool->dealloc((shellface*)fliptets[0].tet[9]);
            fliptets[0].tet[9] = NULL;
        }
        if (fliptets[1].tet[9] != NULL) {
            tet2subpool->dealloc((shellface*)fliptets[1].tet[9]);
            fliptets[1].tet[9] = NULL;
        }
    }
    if (checksubfaceflag) {
        if (scount > 0) {
            // The element attributes and volume constraint must be set correctly.
            // There are two subfaces involved in this flip. The three tets are
            //   separated into two different regions, one may be exterior. The
            //   first region has two tets, and the second region has only one.
            //   The two created tets must be in the same region as the first region.
            //   The element attributes and volume constraint must be set correctly.
            // assert(spivot != -1);
            // The tet fliptets[spivot] is in the first region.
            for (j = 0; j < 2; j++) {
                for (i = 0; i < numelemattrib; i++) {
                    attrib = elemattribute(fliptets[spivot].tet, i);
                    setelemattribute(fliptets[j].tet, i, attrib);
                }
                if (b->varvolume) {
                    volume = volumebound(fliptets[spivot].tet);
                    setvolumebound(fliptets[j].tet, volume);
                }
            }
        }
    }
    // Delete an old tet.
    tetrahedrondealloc(fliptets[2].tet);

    if (hullflag > 0) {
        // Check if c is dummypointc.
        if (pc != dummypoint) {
            // Check if d is dummypoint.
            if (pd != dummypoint) {
                // No hull tet is involved.
            } else {
                // We deleted three hull tets, and created one hull tet.
                hullsize -= 2;
            }
            setvertices(fliptets[0], pa, pb, pc, pd);
            setvertices(fliptets[1], pb, pa, pc, pe);
        } else {
            // c is dummypoint. The two new tets are hull tets.
            setvertices(fliptets[0], pb, pa, pd, pc);
            setvertices(fliptets[1], pa, pb, pe, pc);
            // Adjust badc -> abcd.
            esymself(fliptets[0]);
            // Adjust abec -> bace.
            esymself(fliptets[1]);
            // The hullsize does not change.
        }
    } else {
        setvertices(fliptets[0], pa, pb, pc, pd);
        setvertices(fliptets[1], pb, pa, pc, pe);
    }

    if (fc->remove_ndelaunay_edge) { // calc_tetprism_vol
        REAL volneg[3], volpos[2], vol_diff;
        if (pc != dummypoint) {
            if (pd != dummypoint) {
                volneg[0] = tetprismvol(pe, pd, pa, pb);
                volneg[1] = tetprismvol(pe, pd, pb, pc);
                volneg[2] = tetprismvol(pe, pd, pc, pa);
                volpos[0] = tetprismvol(pa, pb, pc, pd);
                volpos[1] = tetprismvol(pb, pa, pc, pe);
            } else { // pd == dummypoint
                volneg[0] = 0.;
                volneg[1] = 0.;
                volneg[2] = 0.;
                volpos[0] = 0.;
                volpos[1] = tetprismvol(pb, pa, pc, pe);
            }
        } else { // pc == dummypoint.
            volneg[0] = tetprismvol(pe, pd, pa, pb);
            volneg[1] = 0.;
            volneg[2] = 0.;
            volpos[0] = 0.;
            volpos[1] = 0.;
        }
        vol_diff = volpos[0] + volpos[1] - volneg[0] - volneg[1] - volneg[2];
        fc->tetprism_vol_sum += vol_diff; // Update the total sum.
    }

    // Bond abcd <==> bace.
    bond(fliptets[0], fliptets[1]);
    // Bond new faces to top outer boundary faces (at abcd).
    for (i = 0; i < 3; i++) {
        esym(fliptets[0], newface);
        bond(newface, topcastets[i]);
        enextself(fliptets[0]);
    }
    // Bond new faces to bottom outer boundary faces (at bace).
    for (i = 0; i < 3; i++) {
        esym(fliptets[1], newface);
        bond(newface, botcastets[i]);
        eprevself(fliptets[1]);
    }

    if (checksubsegflag) {
        // Bond 9 segments to new (flipped) tets.
        for (i = 0; i < 3; i++) { // edges a->b, b->c, c->a.
            if (issubseg(topcastets[i])) {
                tsspivot1(topcastets[i], checkseg);
                tssbond1(fliptets[0], checkseg);
                sstbond1(checkseg, fliptets[0]);
                tssbond1(fliptets[1], checkseg);
                sstbond1(checkseg, fliptets[1]);
                if (fc->chkencflag & 1) {
                    enqueuesubface(badsubsegs, &checkseg);
                }
            }
            enextself(fliptets[0]);
            eprevself(fliptets[1]);
        }
        // The three top edges.
        for (i = 0; i < 3; i++) { // edges b->d, c->d, a->d.
            esym(fliptets[0], newface);
            eprevself(newface);
            enext(topcastets[i], casface);
            if (issubseg(casface)) {
                tsspivot1(casface, checkseg);
                tssbond1(newface, checkseg);
                sstbond1(checkseg, newface);
                if (fc->chkencflag & 1) {
                    enqueuesubface(badsubsegs, &checkseg);
                }
            }
            enextself(fliptets[0]);
        }
        // The three bot edges.
        for (i = 0; i < 3; i++) { // edges b<-e, c<-e, a<-e.
            esym(fliptets[1], newface);
            enextself(newface);
            eprev(botcastets[i], casface);
            if (issubseg(casface)) {
                tsspivot1(casface, checkseg);
                tssbond1(newface, checkseg);
                sstbond1(checkseg, newface);
                if (fc->chkencflag & 1) {
                    enqueuesubface(badsubsegs, &checkseg);
                }
            }
            eprevself(fliptets[1]);
        }
    } // if (checksubsegflag)

    if (checksubfaceflag) {
        face checksh;
        // Bond the top three casing subfaces.
        for (i = 0; i < 3; i++) { // At edges [b,a], [c,b], [a,c]
            if (issubface(topcastets[i])) {
                tspivot(topcastets[i], checksh);
                esym(fliptets[0], newface);
                sesymself(checksh);
                tsbond(newface, checksh);
                if (fc->chkencflag & 2) {
                    enqueuesubface(badsubfacs, &checksh);
                }
            }
            enextself(fliptets[0]);
        }
        // Bond the bottom three casing subfaces.
        for (i = 0; i < 3; i++) { // At edges [a,b], [b,c], [c,a]
            if (issubface(botcastets[i])) {
                tspivot(botcastets[i], checksh);
                esym(fliptets[1], newface);
                sesymself(checksh);
                tsbond(newface, checksh);
                if (fc->chkencflag & 2) {
                    enqueuesubface(badsubfacs, &checksh);
                }
            }
            eprevself(fliptets[1]);
        }

        if (scount > 0) {
            face flipfaces[2];
            // Perform a 2-to-2 flip in subfaces.
            flipfaces[0] = flipshs[(spivot + 1) % 3];
            flipfaces[1] = flipshs[(spivot + 2) % 3];
            sesymself(flipfaces[1]);
            flip22(flipfaces, 0, fc->chkencflag);
            // Connect the flipped subfaces to flipped tets.
            // First go to the corresponding flipping edge.
            //   Re-use top- and botcastets[0].
            topcastets[0] = fliptets[0];
            botcastets[0] = fliptets[1];
            for (i = 0; i < ((spivot + 1) % 3); i++) {
                enextself(topcastets[0]);
                eprevself(botcastets[0]);
            }
            // Connect the top subface to the top tets.
            esymself(topcastets[0]);
            sesymself(flipfaces[0]);
            // Check if there already exists a subface.
            tspivot(topcastets[0], checksh);
            if (checksh.sh == NULL) {
                tsbond(topcastets[0], flipfaces[0]);
                fsymself(topcastets[0]);
                sesymself(flipfaces[0]);
                tsbond(topcastets[0], flipfaces[0]);
            } else {
                // An invalid 2-to-2 flip. Report a bug.
                terminatetetgen(this, 2);
            }
            // Connect the bot subface to the bottom tets.
            esymself(botcastets[0]);
            sesymself(flipfaces[1]);
            // Check if there already exists a subface.
            tspivot(botcastets[0], checksh);
            if (checksh.sh == NULL) {
                tsbond(botcastets[0], flipfaces[1]);
                fsymself(botcastets[0]);
                sesymself(flipfaces[1]);
                tsbond(botcastets[0], flipfaces[1]);
            } else {
                // An invalid 2-to-2 flip. Report a bug.
                terminatetetgen(this, 2);
            }
        } // if (scount > 0)
    }     // if (checksubfaceflag)

    if (fc->chkencflag & 4) {
        // Put two new tets into check list.
        for (i = 0; i < 2; i++) {
            enqueuetetrahedron(&(fliptets[i]));
        }
    }

    setpoint2tet(pa, (tetrahedron)fliptets[0].tet);
    setpoint2tet(pb, (tetrahedron)fliptets[0].tet);
    setpoint2tet(pc, (tetrahedron)fliptets[0].tet);
    setpoint2tet(pd, (tetrahedron)fliptets[0].tet);
    setpoint2tet(pe, (tetrahedron)fliptets[1].tet);

    if (hullflag > 0) {
        if (dummyflag != 0) {
            // Restore the original position of the points (for flipnm()).
            if (dummyflag == -1) {
                // e were dummypoint. Swap the two new tets.
                newface = fliptets[0];
                fliptets[0] = fliptets[1];
                fliptets[1] = newface;
            } else {
                // a or b was dummypoint.
                if (dummyflag == 1) {
                    eprevself(fliptets[0]);
                    enextself(fliptets[1]);
                } else { // dummyflag == 2
                    enextself(fliptets[0]);
                    eprevself(fliptets[1]);
                }
            }
        }
    }

    if (fc->enqflag > 0) {
        // Queue faces which may be locally non-Delaunay.
        // pa = org(fliptets[0]); // 'a' may be a new vertex.
        enextesym(fliptets[0], newface);
        flippush(flipstack, &newface);
        eprevesym(fliptets[1], newface);
        flippush(flipstack, &newface);
        if (fc->enqflag > 1) {
            // pb = dest(fliptets[0]);
            eprevesym(fliptets[0], newface);
            flippush(flipstack, &newface);
            enextesym(fliptets[1], newface);
            flippush(flipstack, &newface);
            // pc = apex(fliptets[0]);
            esym(fliptets[0], newface);
            flippush(flipstack, &newface);
            esym(fliptets[1], newface);
            flippush(flipstack, &newface);
        }
    }

    recenttet = fliptets[0];
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// flip41()    Perform a 4-to-1 flip (Remove a vertex).                      //
//                                                                           //
// 'fliptets' is an array of four tetrahedra in the star of the removing     //
// vertex 'p'. Let the four vertices in the star of p be a, b, c, and d. The //
// four tets in 'fliptets' are: [p,d,a,b], [p,d,b,c], [p,d,c,a], and [a,b,c, //
// p].  On return, 'fliptets[0]' is the new tet [a,b,c,d].                   //
//                                                                           //
// If 'hullflag' is set (> 0), one of the five vertices may be 'dummypoint'. //
// The 'hullsize' may be changed.  Note that p may be dummypoint.  In this   //
// case, four hull tets are replaced by one real tet.                        //
//                                                                           //
// If 'checksubface' flag is set (>0), it is possible that there are three   //
// interior subfaces connecting at p.  If so, a 3-to-1 flip is performed to  //
// to remove p from the surface triangulation.                               //
//                                                                           //
// If it is called by the routine incrementalflip(), we assume that d is the //
// newly inserted vertex.                                                    //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::flip41(triface* fliptets, int hullflag, flipconstraints* fc) {
    triface topcastets[3], botcastet;
    triface newface, neightet;
    face flipshs[4];
    point pa, pb, pc, pd, pp;
    int dummyflag = 0; // in {0, 1, 2, 3, 4}
    int spivot = -1, scount = 0;
    int t1ver;
    int i;

    pa = org(fliptets[3]);
    pb = dest(fliptets[3]);
    pc = apex(fliptets[3]);
    pd = dest(fliptets[0]);
    pp = org(fliptets[0]); // The removing vertex.

    flip41count++;

    // Get the outer boundary faces.
    for (i = 0; i < 3; i++) {
        enext(fliptets[i], topcastets[i]);
        fnextself(topcastets[i]); // [d,a,b,#], [d,b,c,#], [d,c,a,#]
        enextself(topcastets[i]); // [a,b,d,#], [b,c,d,#], [c,a,d,#]
    }
    fsym(fliptets[3], botcastet); // [b,a,c,#]

    if (checksubfaceflag) {
        // Check if there are three subfaces at 'p'.
        //   Re-use 'newface'.
        for (i = 0; i < 3; i++) {
            fnext(fliptets[3], newface); // [a,b,p,d],[b,c,p,d],[c,a,p,d].
            tspivot(newface, flipshs[i]);
            if (flipshs[i].sh != NULL) {
                spivot = i; // Remember this subface.
                scount++;
            }
            enextself(fliptets[3]);
        }
        if (scount > 0) {
            // There are three subfaces connecting at p.
            if (scount < 3) {
                // The new subface is one of {[a,b,d], [b,c,d], [c,a,d]}.
                // Go to the tet containing the three subfaces.
                fsym(topcastets[spivot], neightet);
                // Get the three subfaces connecting at p.
                for (i = 0; i < 3; i++) {
                    esym(neightet, newface);
                    tspivot(newface, flipshs[i]);
                    eprevself(neightet);
                }
            } else {
                spivot = 3; // The new subface is [a,b,c].
            }
        }
    } // if (checksubfaceflag)

    // Re-use fliptets[0] for [a,b,c,d].
    fliptets[0].ver = 11;
    setelemmarker(fliptets[0].tet, 0); // Clean all flags.
    // NOTE: the element attributes and volume constraint remain unchanged.
    if (checksubsegflag) {
        // Dealloc the space to subsegments.
        if (fliptets[0].tet[8] != NULL) {
            tet2segpool->dealloc((shellface*)fliptets[0].tet[8]);
            fliptets[0].tet[8] = NULL;
        }
    }
    if (checksubfaceflag) {
        // Dealloc the space to subfaces.
        if (fliptets[0].tet[9] != NULL) {
            tet2subpool->dealloc((shellface*)fliptets[0].tet[9]);
            fliptets[0].tet[9] = NULL;
        }
    }
    // Delete the other three tets.
    for (i = 1; i < 4; i++) {
        tetrahedrondealloc(fliptets[i].tet);
    }

    if (pp != dummypoint) {
        // Mark the point pp as unused.
        setpointtype(pp, UNUSEDVERTEX);
        unuverts++;
    }

    // Create the new tet [a,b,c,d].
    if (hullflag > 0) {
        // One of the five vertices may be 'dummypoint'.
        if (pa == dummypoint) {
            // pa is dummypoint.
            setvertices(fliptets[0], pc, pb, pd, pa);
            esymself(fliptets[0]);  // [b,c,a,d]
            eprevself(fliptets[0]); // [a,b,c,d]
            dummyflag = 1;
        } else if (pb == dummypoint) {
            setvertices(fliptets[0], pa, pc, pd, pb);
            esymself(fliptets[0]);  // [c,a,b,d]
            enextself(fliptets[0]); // [a,b,c,d]
            dummyflag = 2;
        } else if (pc == dummypoint) {
            setvertices(fliptets[0], pb, pa, pd, pc);
            esymself(fliptets[0]); // [a,b,c,d]
            dummyflag = 3;
        } else if (pd == dummypoint) {
            setvertices(fliptets[0], pa, pb, pc, pd);
            dummyflag = 4;
        } else {
            setvertices(fliptets[0], pa, pb, pc, pd);
            if (pp == dummypoint) {
                dummyflag = -1;
            } else {
                dummyflag = 0;
            }
        }
        if (dummyflag > 0) {
            // We deleted 3 hull tets, and create 1 hull tet.
            hullsize -= 2;
        } else if (dummyflag < 0) {
            // We deleted 4 hull tets.
            hullsize -= 4;
            // meshedges does not change.
        }
    } else {
        setvertices(fliptets[0], pa, pb, pc, pd);
    }

    if (fc->remove_ndelaunay_edge) { // calc_tetprism_vol
        REAL volneg[4], volpos[1], vol_diff;
        if (dummyflag > 0) {
            if (pa == dummypoint) {
                volneg[0] = 0.;
                volneg[1] = tetprismvol(pp, pd, pb, pc);
                volneg[2] = 0.;
                volneg[3] = 0.;
            } else if (pb == dummypoint) {
                volneg[0] = 0.;
                volneg[1] = 0.;
                volneg[2] = tetprismvol(pp, pd, pc, pa);
                volneg[3] = 0.;
            } else if (pc == dummypoint) {
                volneg[0] = tetprismvol(pp, pd, pa, pb);
                volneg[1] = 0.;
                volneg[2] = 0.;
                volneg[3] = 0.;
            } else { // pd == dummypoint
                volneg[0] = 0.;
                volneg[1] = 0.;
                volneg[2] = 0.;
                volneg[3] = tetprismvol(pa, pb, pc, pp);
            }
            volpos[0] = 0.;
        } else if (dummyflag < 0) {
            volneg[0] = 0.;
            volneg[1] = 0.;
            volneg[2] = 0.;
            volneg[3] = 0.;
            volpos[0] = tetprismvol(pa, pb, pc, pd);
        } else {
            volneg[0] = tetprismvol(pp, pd, pa, pb);
            volneg[1] = tetprismvol(pp, pd, pb, pc);
            volneg[2] = tetprismvol(pp, pd, pc, pa);
            volneg[3] = tetprismvol(pa, pb, pc, pp);
            volpos[0] = tetprismvol(pa, pb, pc, pd);
        }
        vol_diff = volpos[0] - volneg[0] - volneg[1] - volneg[2] - volneg[3];
        fc->tetprism_vol_sum += vol_diff; // Update the total sum.
    }

    // Bond the new tet to adjacent tets.
    for (i = 0; i < 3; i++) {
        esym(fliptets[0], newface); // At faces [b,a,d], [c,b,d], [a,c,d].
        bond(newface, topcastets[i]);
        enextself(fliptets[0]);
    }
    bond(fliptets[0], botcastet);

    if (checksubsegflag) {
        face checkseg;
        // Bond 6 segments (at edges of [a,b,c,d]) if there there are.
        for (i = 0; i < 3; i++) {
            eprev(topcastets[i], newface); // At edges [d,a],[d,b],[d,c].
            if (issubseg(newface)) {
                tsspivot1(newface, checkseg);
                esym(fliptets[0], newface);
                enextself(newface); // At edges [a,d], [b,d], [c,d].
                tssbond1(newface, checkseg);
                sstbond1(checkseg, newface);
                if (fc->chkencflag & 1) {
                    enqueuesubface(badsubsegs, &checkseg);
                }
            }
            enextself(fliptets[0]);
        }
        for (i = 0; i < 3; i++) {
            if (issubseg(topcastets[i])) {
                tsspivot1(topcastets[i], checkseg); // At edges [a,b],[b,c],[c,a].
                tssbond1(fliptets[0], checkseg);
                sstbond1(checkseg, fliptets[0]);
                if (fc->chkencflag & 1) {
                    enqueuesubface(badsubsegs, &checkseg);
                }
            }
            enextself(fliptets[0]);
        }
    }

    if (checksubfaceflag) {
        face checksh;
        // Bond 4 subfaces (at faces of [a,b,c,d]) if there are.
        for (i = 0; i < 3; i++) {
            if (issubface(topcastets[i])) {
                tspivot(topcastets[i], checksh); // At faces [a,b,d],[b,c,d],[c,a,d]
                esym(fliptets[0], newface);      // At faces [b,a,d],[c,b,d],[a,c,d]
                sesymself(checksh);
                tsbond(newface, checksh);
                if (fc->chkencflag & 2) {
                    enqueuesubface(badsubfacs, &checksh);
                }
            }
            enextself(fliptets[0]);
        }
        if (issubface(botcastet)) {
            tspivot(botcastet, checksh); // At face [b,a,c]
            sesymself(checksh);
            tsbond(fliptets[0], checksh);
            if (fc->chkencflag & 2) {
                enqueuesubface(badsubfacs, &checksh);
            }
        }

        if (spivot >= 0) {
            // Perform a 3-to-1 flip in surface triangulation.
            // Depending on the value of 'spivot', the three subfaces are:
            //   - 0: [a,b,p], [b,d,p], [d,a,p]
            //   - 1: [b,c,p], [c,d,p], [d,b,p]
            //   - 2: [c,a,p], [a,d,p], [d,c,p]
            //   - 3: [a,b,p], [b,c,p], [c,a,p]
            // Adjust the three subfaces such that their origins are p, i.e.,
            //   - 3: [p,a,b], [p,b,c], [p,c,a]. (Required by the flip31()).
            for (i = 0; i < 3; i++) {
                senext2self(flipshs[i]);
            }
            flip31(flipshs, 0);
            // Delete the three old subfaces.
            for (i = 0; i < 3; i++) {
                shellfacedealloc(subfaces, flipshs[i].sh);
            }
            if (spivot < 3) {
                // // Bond the new subface to the new tet [a,b,c,d].
                tsbond(topcastets[spivot], flipshs[3]);
                fsym(topcastets[spivot], newface);
                sesym(flipshs[3], checksh);
                tsbond(newface, checksh);
            } else {
                // Bound the new subface [a,b,c] to the new tet [a,b,c,d].
                tsbond(fliptets[0], flipshs[3]);
                fsym(fliptets[0], newface);
                sesym(flipshs[3], checksh);
                tsbond(newface, checksh);
            }
        } // if (spivot > 0)
    }     // if (checksubfaceflag)

    if (fc->chkencflag & 4) {
        enqueuetetrahedron(&(fliptets[0]));
    }

    // Update the point-to-tet map.
    setpoint2tet(pa, (tetrahedron)fliptets[0].tet);
    setpoint2tet(pb, (tetrahedron)fliptets[0].tet);
    setpoint2tet(pc, (tetrahedron)fliptets[0].tet);
    setpoint2tet(pd, (tetrahedron)fliptets[0].tet);

    if (fc->enqflag > 0) {
        // Queue faces which may be locally non-Delaunay.
        flippush(flipstack, &(fliptets[0])); // [a,b,c] (opposite to new point).
        if (fc->enqflag > 1) {
            for (i = 0; i < 3; i++) {
                esym(fliptets[0], newface);
                flippush(flipstack, &newface);
                enextself(fliptets[0]);
            }
        }
    }

    recenttet = fliptets[0];
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// flipnm()    Flip an edge through a sequence of elementary flips.          //
//                                                                           //
// 'abtets' is an array of 'n' tets in the star of edge [a,b].These tets are //
// ordered in a counterclockwise cycle with respect to the vector a->b, i.e.,//
// use the right-hand rule.                                                  //
//                                                                           //
// 'level' (>= 0) indicates the current link level. If 'level > 0', we are   //
// flipping a link edge of an edge [a',b'],  and 'abedgepivot' indicates     //
// which link edge, i.e., [c',b'] or [a',c'], is [a,b]  These two parameters //
// allow us to determine the new tets after a 3-to-2 flip, i.e., tets that   //
// do not inside the reduced star of edge [a',b'].                           //
//                                                                           //
// If the flag 'fc->unflip' is set, this routine un-does the flips performed //
// in flipnm([a,b]) so that the mesh is returned to its original state       //
// before doing the flipnm([a,b]) operation.                                 //
//                                                                           //
// The return value is an integer nn, where nn <= n.  If nn is 2, then the   //
// edge is flipped.  The first and the second tets in 'abtets' are new tets. //
// Otherwise, nn > 2, the edge is not flipped, and nn is the number of tets  //
// in the current star of [a,b].                                             //
//                                                                           //
// ASSUMPTIONS:                                                              //
//  - Neither a nor b is 'dummypoint'.                                       //
//  - [a,b] must not be a segment.                                           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::flipnm(triface* abtets, int n, int level, int abedgepivot, flipconstraints* fc) {
    triface fliptets[3], spintet, flipedge;
    triface *tmpabtets, *parytet;
    point pa, pb, pc, pd, pe, pf;
    REAL ori;
    int hullflag, hulledgeflag;
    int reducflag, rejflag;
    int reflexlinkedgecount;
    int edgepivot;
    int n1, nn;
    int t1ver;
    int i, j;

    pa = org(abtets[0]);
    pb = dest(abtets[0]);

    if (n > 3) {
        // Try to reduce the size of the Star(ab) by flipping a face in it.
        reflexlinkedgecount = 0;

        for (i = 0; i < n; i++) {
            // Let the face of 'abtets[i]' be [a,b,c].
            if (checksubfaceflag) {
                if (issubface(abtets[i])) {
                    continue; // Skip a subface.
                }
            }
            // Do not flip this face if it is involved in two Stars.
            if ((elemcounter(abtets[i]) > 1) || (elemcounter(abtets[(i - 1 + n) % n]) > 1)) {
                continue;
            }

            pc = apex(abtets[i]);
            pd = apex(abtets[(i + 1) % n]);
            pe = apex(abtets[(i - 1 + n) % n]);
            if ((pd == dummypoint) || (pe == dummypoint)) {
                continue; // [a,b,c] is a hull face.
            }

            // Decide whether [a,b,c] is flippable or not.
            reducflag = 0;

            hullflag = (pc == dummypoint); // pc may be dummypoint.
            hulledgeflag = 0;
            if (hullflag == 0) {
                ori = orient3d(pb, pc, pd, pe); // Is [b,c] locally convex?
                if (ori > 0) {
                    ori = orient3d(pc, pa, pd, pe); // Is [c,a] locally convex?
                    if (ori > 0) {
                        // Test if [a,b] is locally convex OR flat.
                        ori = orient3d(pa, pb, pd, pe);
                        if (ori > 0) {
                            // Found a 2-to-3 flip: [a,b,c] => [e,d]
                            reducflag = 1;
                        } else if (ori == 0) {
                            // [a,b] is flat.
                            if (n == 4) {
                                // The "flat" tet can be removed immediately by a 3-to-2 flip.
                                reducflag = 1;
                                // Check if [e,d] is a hull edge.
                                pf = apex(abtets[(i + 2) % n]);
                                hulledgeflag = (pf == dummypoint);
                            }
                        }
                    }
                }
                if (!reducflag) {
                    reflexlinkedgecount++;
                }
            } else {
                // 'c' is dummypoint.
                if (n == 4) {
                    // Let the vertex opposite to 'c' is 'f'.
                    // A 4-to-4 flip is possible if the two tets [d,e,f,a] and [e,d,f,b]
                    //   are valid tets.
                    // Note: When the mesh is not convex, it is possible that [a,b] is
                    //   locally non-convex (at hull faces [a,b,e] and [b,a,d]).
                    //   In this case, an edge flip [a,b] to [e,d] is still possible.
                    pf = apex(abtets[(i + 2) % n]);
                    ori = orient3d(pd, pe, pf, pa);
                    if (ori < 0) {
                        ori = orient3d(pe, pd, pf, pb);
                        if (ori < 0) {
                            // Found a 4-to-4 flip: [a,b] => [e,d]
                            reducflag = 1;
                            ori = 0;          // Signal as a 4-to-4 flip (like a co-planar case).
                            hulledgeflag = 1; // [e,d] is a hull edge.
                        }
                    }
                }
            } // if (hullflag)

            if (reducflag) {
                if (nonconvex && hulledgeflag) {
                    // We will create a hull edge [e,d]. Make sure it does not exist.
                    if (getedge(pe, pd, &spintet)) {
                        // The 2-to-3 flip is not a topological valid flip.
                        reducflag = 0;
                    }
                }
            }

            if (reducflag) {
                // [a,b,c] could be removed by a 2-to-3 flip.
                rejflag = 0;
                if (fc->checkflipeligibility) {
                    // Check if the flip can be performed.
                    rejflag = checkflipeligibility(1, pa, pb, pc, pd, pe, level, abedgepivot, fc);
                }
                if (!rejflag) {
                    // Do flip: [a,b,c] => [e,d].
                    fliptets[0] = abtets[i];
                    fsym(fliptets[0], fliptets[1]); // abtets[i-1].
                    flip23(fliptets, hullflag, fc);

                    // Shrink the array 'abtets', maintain the original order.
                    //   Two tets 'abtets[i-1] ([a,b,e,c])' and 'abtets[i] ([a,b,c,d])'
                    //   are flipped, i.e., they do not in Star(ab) anymore.
                    //   'fliptets[0]' ([e,d,a,b]) is in Star(ab), it is saved in
                    //   'abtets[i-1]' (adjust it to be [a,b,e,d]), see below:
                    //
                    //            before                   after
                    //     [0] |___________|        [0] |___________|
                    //     ... |___________|        ... |___________|
                    //   [i-1] |_[a,b,e,c]_|      [i-1] |_[a,b,e,d]_|
                    //     [i] |_[a,b,c,d]_| -->    [i] |_[a,b,d,#]_|
                    //   [i+1] |_[a,b,d,#]_|      [i+1] |_[a,b,#,*]_|
                    //     ... |___________|        ... |___________|
                    //   [n-2] |___________|      [n-2] |___________|
                    //   [n-1] |___________|      [n-1] |_[i]_2-t-3_|
                    //
                    edestoppoself(fliptets[0]); // [a,b,e,d]
                    // Increase the counter of this new tet (it is in Star(ab)).
                    increaseelemcounter(fliptets[0]);
                    abtets[(i - 1 + n) % n] = fliptets[0];
                    for (j = i; j < n - 1; j++) {
                        abtets[j] = abtets[j + 1]; // Upshift
                    }
                    // The last entry 'abtets[n-1]' is empty. It is used in two ways:
                    //   (i) it remembers the vertex 'c' (in 'abtets[n-1].tet'), and
                    //  (ii) it remembers the position [i] where this flip took place.
                    // These information let us to either undo this flip or recover
                    //   the original edge link (for collecting new created tets).
                    abtets[n - 1].tet = (tetrahedron*)pc;
                    abtets[n - 1].ver = 0; // Clear it.
                    // 'abtets[n - 1].ver' is in range [0,11] -- only uses 4 bits.
                    // Use the 5th bit in 'abtets[n - 1].ver' to signal a 2-to-3 flip.
                    abtets[n - 1].ver |= (1 << 4);
                    // The poisition [i] of this flip is saved above the 7th bit.
                    abtets[n - 1].ver |= (i << 6);

                    if (fc->collectnewtets) {
                        // Push the two new tets [e,d,b,c] and [e,d,c,a] into a stack.
                        //   Re-use the global array 'cavetetlist'.
                        for (j = 1; j < 3; j++) {
                            cavetetlist->newindex((void**)&parytet);
                            *parytet = fliptets[j]; // fliptets[1], fliptets[2].
                        }
                    }

                    // Star(ab) is reduced. Try to flip the edge [a,b].
                    nn = flipnm(abtets, n - 1, level, abedgepivot, fc);

                    if (nn == 2) {
                        // The edge has been flipped.
                        return nn;
                    } else { // if (nn > 2)
                        // The edge is not flipped.
                        if (fc->unflip || (ori == 0)) {
                            // Undo the previous 2-to-3 flip, i.e., do a 3-to-2 flip to
                            //   transform [e,d] => [a,b,c].
                            // 'ori == 0' means that the previous flip created a degenerated
                            //   tet. It must be removed.
                            // Remember that 'abtets[i-1]' is [a,b,e,d]. We can use it to
                            //   find another two tets [e,d,b,c] and [e,d,c,a].
                            fliptets[0] = abtets[(i - 1 + (n - 1)) % (n - 1)]; // [a,b,e,d]
                            edestoppoself(fliptets[0]);                        // [e,d,a,b]
                            fnext(fliptets[0], fliptets[1]);                   // [1] is [e,d,b,c]
                            fnext(fliptets[1], fliptets[2]);                   // [2] is [e,d,c,a]
                            // Restore the two original tets in Star(ab).
                            flip32(fliptets, hullflag, fc);
                            // Marktest the two restored tets in Star(ab).
                            for (j = 0; j < 2; j++) {
                                increaseelemcounter(fliptets[j]);
                            }
                            // Expand the array 'abtets', maintain the original order.
                            for (j = n - 2; j >= i; j--) {
                                abtets[j + 1] = abtets[j]; // Downshift
                            }
                            // Insert the two new tets 'fliptets[0]' [a,b,c,d] and
                            //  'fliptets[1]' [b,a,c,e] into the (i-1)-th and i-th entries,
                            //  respectively.
                            esym(fliptets[1], abtets[(i - 1 + n) % n]); // [a,b,e,c]
                            abtets[i] = fliptets[0];                    // [a,b,c,d]
                            nn++;
                            if (fc->collectnewtets) {
                                // Pop two (flipped) tets from the stack.
                                cavetetlist->objects -= 2;
                            }
                        } // if (unflip || (ori == 0))
                    }     // if (nn > 2)

                    if (!fc->unflip) {
                        // The flips are not reversed. The current Star(ab) can not be
                        //   further reduced. Return its current size (# of tets).
                        return nn;
                    }
                    // unflip is set.
                    // Continue the search for flips.
                }
            } // if (reducflag)
        }     // i

        // The Star(ab) is not reduced.
        if (reflexlinkedgecount > 0) {
            // There are reflex edges in the Link(ab).
            if (((b->fliplinklevel < 0) && (level < autofliplinklevel)) ||
                ((b->fliplinklevel >= 0) && (level < b->fliplinklevel))) {
                // Try to reduce the Star(ab) by flipping a reflex edge in Link(ab).
                for (i = 0; i < n; i++) {
                    // Do not flip this face [a,b,c] if there are two Stars involved.
                    if ((elemcounter(abtets[i]) > 1) ||
                        (elemcounter(abtets[(i - 1 + n) % n]) > 1)) {
                        continue;
                    }
                    pc = apex(abtets[i]);
                    if (pc == dummypoint) {
                        continue; // [a,b] is a hull edge.
                    }
                    pd = apex(abtets[(i + 1) % n]);
                    pe = apex(abtets[(i - 1 + n) % n]);
                    if ((pd == dummypoint) || (pe == dummypoint)) {
                        continue; // [a,b,c] is a hull face.
                    }

                    edgepivot = 0; // No edge is selected yet.

                    // Test if [b,c] is locally convex or flat.
                    ori = orient3d(pb, pc, pd, pe);
                    if (ori <= 0) {
                        // Select the edge [c,b].
                        enext(abtets[i], flipedge); // [b,c,a,d]
                        edgepivot = 1;
                    }
                    if (!edgepivot) {
                        // Test if [c,a] is locally convex or flat.
                        ori = orient3d(pc, pa, pd, pe);
                        if (ori <= 0) {
                            // Select the edge [a,c].
                            eprev(abtets[i], flipedge); // [c,a,b,d].
                            edgepivot = 2;
                        }
                    }

                    if (!edgepivot) continue;

                    // An edge is selected.
                    if (checksubsegflag) {
                        // Do not flip it if it is a segment.
                        if (issubseg(flipedge)) {
                            if (fc->collectencsegflag) {
                                face checkseg, *paryseg;
                                tsspivot1(flipedge, checkseg);
                                if (!sinfected(checkseg)) {
                                    // Queue this segment in list.
                                    sinfect(checkseg);
                                    caveencseglist->newindex((void**)&paryseg);
                                    *paryseg = checkseg;
                                }
                            }
                            continue;
                        }
                    }

                    // Try to flip the selected edge ([c,b] or [a,c]).
                    esymself(flipedge);
                    // Count the number of tets at the edge.
                    n1 = 0;
                    j = 0; // Sum of the star counters.
                    spintet = flipedge;
                    while (1) {
                        n1++;
                        j += (elemcounter(spintet));
                        fnextself(spintet);
                        if (spintet.tet == flipedge.tet) break;
                    }
                    if (n1 < 3) {
                        // This is only possible when the mesh contains inverted
                        //   elements.  Reprot a bug.
                        terminatetetgen(this, 2);
                    }
                    if (j > 2) {
                        // The Star(flipedge) overlaps other Stars.
                        continue; // Do not flip this edge.
                    }

                    if ((b->flipstarsize > 0) && (n1 > b->flipstarsize)) {
                        // The star size exceeds the given limit.
                        continue; // Do not flip it.
                    }

                    // Allocate spaces for Star(flipedge).
                    tmpabtets = new triface[n1];
                    // Form the Star(flipedge).
                    j = 0;
                    spintet = flipedge;
                    while (1) {
                        tmpabtets[j] = spintet;
                        // Increase the star counter of this tet.
                        increaseelemcounter(tmpabtets[j]);
                        j++;
                        fnextself(spintet);
                        if (spintet.tet == flipedge.tet) break;
                    }

                    // Try to flip the selected edge away.
                    nn = flipnm(tmpabtets, n1, level + 1, edgepivot, fc);

                    if (nn == 2) {
                        // The edge is flipped. Star(ab) is reduced.
                        // Shrink the array 'abtets', maintain the original order.
                        if (edgepivot == 1) {
                            // 'tmpabtets[0]' is [d,a,e,b] => contains [a,b].
                            spintet = tmpabtets[0]; // [d,a,e,b]
                            enextself(spintet);
                            esymself(spintet);
                            enextself(spintet); // [a,b,e,d]
                        } else {
                            // 'tmpabtets[1]' is [b,d,e,a] => contains [a,b].
                            spintet = tmpabtets[1]; // [b,d,e,a]
                            eprevself(spintet);
                            esymself(spintet);
                            eprevself(spintet);       // [a,b,e,d]
                        }                             // edgepivot == 2
                        increaseelemcounter(spintet); // It is in Star(ab).
                        // Put the new tet at [i-1]-th entry.
                        abtets[(i - 1 + n) % n] = spintet;
                        for (j = i; j < n - 1; j++) {
                            abtets[j] = abtets[j + 1]; // Upshift
                        }
                        // Remember the flips in the last entry of the array 'abtets'.
                        // They can be used to recover the flipped edge.
                        abtets[n - 1].tet = (tetrahedron*)tmpabtets; // The star(fedge).
                        abtets[n - 1].ver = 0;                       // Clear it.
                        // Use the 1st and 2nd bit to save 'edgepivot' (1 or 2).
                        abtets[n - 1].ver |= edgepivot;
                        // Use the 6th bit to signal this n1-to-m1 flip.
                        abtets[n - 1].ver |= (1 << 5);
                        // The poisition [i] of this flip is saved from 7th to 19th bit.
                        abtets[n - 1].ver |= (i << 6);
                        // The size of the star 'n1' is saved from 20th bit.
                        abtets[n - 1].ver |= (n1 << 19);

                        // Remember the flipped link vertex 'c'. It can be used to recover
                        //   the original edge link of [a,b], and to collect new tets.
                        tmpabtets[0].tet = (tetrahedron*)pc;
                        tmpabtets[0].ver = (1 << 5); // Flag it as a vertex handle.

                        // Continue to flip the edge [a,b].
                        nn = flipnm(abtets, n - 1, level, abedgepivot, fc);

                        if (nn == 2) {
                            // The edge has been flipped.
                            return nn;
                        } else { // if (nn > 2) {
                            // The edge is not flipped.
                            if (fc->unflip) {
                                // Recover the flipped edge ([c,b] or [a,c]).
                                // The sequence of flips are saved in 'tmpabtets'.
                                // abtets[(i-1) % (n-1)] is [a,b,e,d], i.e., the tet created by
                                //   the flipping of edge [c,b] or [a,c].It must still exist in
                                //   Star(ab). It is the start tet to recover the flipped edge.
                                if (edgepivot == 1) {
                                    // The flip edge is [c,b].
                                    tmpabtets[0] =
                                        abtets[((i - 1) + (n - 1)) % (n - 1)]; // [a,b,e,d]
                                    eprevself(tmpabtets[0]);
                                    esymself(tmpabtets[0]);
                                    eprevself(tmpabtets[0]);          // [d,a,e,b]
                                    fsym(tmpabtets[0], tmpabtets[1]); // [a,d,e,c]
                                } else {
                                    // The flip edge is [a,c].
                                    tmpabtets[1] =
                                        abtets[((i - 1) + (n - 1)) % (n - 1)]; // [a,b,e,d]
                                    enextself(tmpabtets[1]);
                                    esymself(tmpabtets[1]);
                                    enextself(tmpabtets[1]);          // [b,d,e,a]
                                    fsym(tmpabtets[1], tmpabtets[0]); // [d,b,e,c]
                                }                                     // if (edgepivot == 2)

                                // Recover the flipped edge ([c,b] or [a,c]).
                                flipnm_post(tmpabtets, n1, 2, edgepivot, fc);

                                // Insert the two recovered tets into Star(ab).
                                for (j = n - 2; j >= i; j--) {
                                    abtets[j + 1] = abtets[j]; // Downshift
                                }
                                if (edgepivot == 1) {
                                    // tmpabtets[0] is [c,b,d,a] ==> contains [a,b]
                                    // tmpabtets[1] is [c,b,a,e] ==> contains [a,b]
                                    // tmpabtets[2] is [c,b,e,d]
                                    fliptets[0] = tmpabtets[1];
                                    enextself(fliptets[0]);
                                    esymself(fliptets[0]); // [a,b,e,c]
                                    fliptets[1] = tmpabtets[0];
                                    esymself(fliptets[1]);
                                    eprevself(fliptets[1]); // [a,b,c,d]
                                } else {
                                    // tmpabtets[0] is [a,c,d,b] ==> contains [a,b]
                                    // tmpabtets[1] is [a,c,b,e] ==> contains [a,b]
                                    // tmpabtets[2] is [a,c,e,d]
                                    fliptets[0] = tmpabtets[1];
                                    eprevself(fliptets[0]);
                                    esymself(fliptets[0]); // [a,b,e,c]
                                    fliptets[1] = tmpabtets[0];
                                    esymself(fliptets[1]);
                                    enextself(fliptets[1]); // [a,b,c,d]
                                }                           // edgepivot == 2
                                for (j = 0; j < 2; j++) {
                                    increaseelemcounter(fliptets[j]);
                                }
                                // Insert the two recovered tets into Star(ab).
                                abtets[(i - 1 + n) % n] = fliptets[0];
                                abtets[i] = fliptets[1];
                                nn++;
                                // Release the allocated spaces.
                                delete[] tmpabtets;
                            } // if (unflip)
                        }     // if (nn > 2)

                        if (!fc->unflip) {
                            // The flips are not reversed. The current Star(ab) can not be
                            //   further reduced. Return its size (# of tets).
                            return nn;
                        }
                        // unflip is set.
                        // Continue the search for flips.
                    } else {
                        // The selected edge is not flipped.
                        if (!fc->unflip) {
                            // Release the memory used in this attempted flip.
                            flipnm_post(tmpabtets, n1, nn, edgepivot, fc);
                        }
                        // Decrease the star counters of tets in Star(flipedge).
                        for (j = 0; j < nn; j++) {
                            decreaseelemcounter(tmpabtets[j]);
                        }
                        // Release the allocated spaces.
                        delete[] tmpabtets;
                    }
                } // i
            }     // if (level...)
        }         // if (reflexlinkedgecount > 0)
    } else {
        // Check if a 3-to-2 flip is possible.
        // Let the three apexes be c, d,and e. Hull tets may be involved. If so,
        //   we rearrange them such that the vertex e is dummypoint.
        hullflag = 0;

        if (apex(abtets[0]) == dummypoint) {
            pc = apex(abtets[1]);
            pd = apex(abtets[2]);
            pe = apex(abtets[0]);
            hullflag = 1;
        } else if (apex(abtets[1]) == dummypoint) {
            pc = apex(abtets[2]);
            pd = apex(abtets[0]);
            pe = apex(abtets[1]);
            hullflag = 2;
        } else {
            pc = apex(abtets[0]);
            pd = apex(abtets[1]);
            pe = apex(abtets[2]);
            hullflag = (pe == dummypoint) ? 3 : 0;
        }

        reducflag = 0;
        rejflag = 0;

        if (hullflag == 0) {
            // Make sure that no inverted tet will be created, i.e. the new tets
            //   [d,c,e,a] and [c,d,e,b] must be valid tets.
            ori = orient3d(pd, pc, pe, pa);
            if (ori < 0) {
                ori = orient3d(pc, pd, pe, pb);
                if (ori < 0) {
                    reducflag = 1;
                }
            }
        } else {
            // [a,b] is a hull edge.
            //   Note: This can happen when it is in the middle of a 4-to-4 flip.
            //   Note: [a,b] may even be a non-convex hull edge.
            if (!nonconvex) {
                //  The mesh is convex, only do flip if it is a coplanar hull edge.
                ori = orient3d(pa, pb, pc, pd);
                if (ori == 0) {
                    reducflag = 1;
                }
            } else { // nonconvex
                reducflag = 1;
            }
            if (reducflag == 1) {
                // [a,b], [a,b,c] and [a,b,d] are on the convex hull.
                // Make sure that no inverted tet will be created.
                point searchpt = NULL, chkpt;
                REAL bigvol = 0.0, ori1, ori2;
                // Search an interior vertex which is an apex of edge [c,d].
                //   In principle, it can be arbitrary interior vertex.  To avoid
                //   numerical issue, we choose the vertex which belongs to a tet
                //   't' at edge [c,d] and 't' has the biggest volume.
                fliptets[0] = abtets[hullflag % 3]; // [a,b,c,d].
                eorgoppoself(fliptets[0]);          // [d,c,b,a]
                spintet = fliptets[0];
                while (1) {
                    fnextself(spintet);
                    chkpt = oppo(spintet);
                    if (chkpt == pb) break;
                    if ((chkpt != dummypoint) && (apex(spintet) != dummypoint)) {
                        ori = -orient3d(pd, pc, apex(spintet), chkpt);
                        if (ori > bigvol) {
                            bigvol = ori;
                            searchpt = chkpt;
                        }
                    }
                }
                if (searchpt != NULL) {
                    // Now valid the configuration.
                    ori1 = orient3d(pd, pc, searchpt, pa);
                    ori2 = orient3d(pd, pc, searchpt, pb);
                    if (ori1 * ori2 >= 0.0) {
                        reducflag = 0; // Not valid.
                    } else {
                        ori1 = orient3d(pa, pb, searchpt, pc);
                        ori2 = orient3d(pa, pb, searchpt, pd);
                        if (ori1 * ori2 >= 0.0) {
                            reducflag = 0; // Not valid.
                        }
                    }
                } else {
                    // No valid searchpt is found.
                    reducflag = 0; // Do not flip it.
                }
            } // if (reducflag == 1)
        }     // if (hullflag == 1)

        if (reducflag) {
            // A 3-to-2 flip is possible.
            if (checksubfaceflag) {
                // This edge (must not be a segment) can be flipped ONLY IF it belongs
                //   to either 0 or 2 subfaces.  In the latter case, a 2-to-2 flip in
                //   the surface mesh will be automatically performed within the
                //   3-to-2 flip.
                nn = 0;
                edgepivot = -1; // Re-use it.
                for (j = 0; j < 3; j++) {
                    if (issubface(abtets[j])) {
                        nn++; // Found a subface.
                    } else {
                        edgepivot = j;
                    }
                }
                if (nn == 1) {
                    // Found only 1 subface containing this edge. This can happen in
                    //   the boundary recovery phase. The neighbor subface is not yet
                    //   recovered. This edge should not be flipped at this moment.
                    rejflag = 1;
                } else if (nn == 2) {
                    // Found two subfaces. A 2-to-2 flip is possible. Validate it.
                    // Below we check if the two faces [p,q,a] and [p,q,b] are subfaces.
                    eorgoppo(abtets[(edgepivot + 1) % 3], spintet); // [q,p,b,a]
                    if (issubface(spintet)) {
                        rejflag = 1; // Conflict to a 2-to-2 flip.
                    } else {
                        esymself(spintet);
                        if (issubface(spintet)) {
                            rejflag = 1; // Conflict to a 2-to-2 flip.
                        }
                    }
                } else if (nn == 3) {
                    // Report a bug.
                    terminatetetgen(this, 2);
                }
            }
            if (!rejflag && fc->checkflipeligibility) {
                // Here we must exchange 'a' and 'b'. Since in the check... function,
                //   we assume the following point sequence, 'a,b,c,d,e', where
                //   the face [a,b,c] will be flipped and the edge [e,d] will be
                //   created. The two new tets are [a,b,c,d] and [b,a,c,e].
                rejflag = checkflipeligibility(2, pc, pd, pe, pb, pa, level, abedgepivot, fc);
            }
            if (!rejflag) {
                // Do flip: [a,b] => [c,d,e]
                flip32(abtets, hullflag, fc);
                if (fc->remove_ndelaunay_edge) {
                    if (level == 0) {
                        // It is the desired removing edge. Check if we have improved
                        //   the objective function.
                        if ((fc->tetprism_vol_sum >= 0.0) ||
                            (fabs(fc->tetprism_vol_sum) < fc->bak_tetprism_vol)) {
                            // No improvement! flip back: [c,d,e] => [a,b].
                            flip23(abtets, hullflag, fc);
                            // Increase the element counter -- They are in cavity.
                            for (j = 0; j < 3; j++) {
                                increaseelemcounter(abtets[j]);
                            }
                            return 3;
                        }
                    } // if (level == 0)
                }
                if (fc->collectnewtets) {
                    // Collect new tets.
                    if (level == 0) {
                        // Push the two new tets into stack.
                        for (j = 0; j < 2; j++) {
                            cavetetlist->newindex((void**)&parytet);
                            *parytet = abtets[j];
                        }
                    } else {
                        // Only one of the new tets is collected. The other one is inside
                        //   the reduced edge star. 'abedgepivot' is either '1' or '2'.
                        cavetetlist->newindex((void**)&parytet);
                        if (abedgepivot == 1) { // [c,b]
                            *parytet = abtets[1];
                        } else {
                            *parytet = abtets[0];
                        }
                    }
                } // if (fc->collectnewtets)
                return 2;
            }
        } // if (reducflag)
    }     // if (n == 3)

    // The current (reduced) Star size.
    return n;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// flipnm_post()    Post process a n-to-m flip.                              //
//                                                                           //
// IMPORTANT: This routine only works when there is no other flip operation  //
// is done after flipnm([a,b]) which attempts to remove an edge [a,b].       //
//                                                                           //
// 'abtets' is an array of 'n' (>= 3) tets which are in the original star of //
// [a,b] before flipnm([a,b]).  'nn' (< n) is the value returned by flipnm.  //
// If 'nn == 2', the edge [a,b] has been flipped. 'abtets[0]' and 'abtets[1]'//
// are [c,d,e,b] and [d,c,e,a], i.e., a 2-to-3 flip can recover the edge [a, //
// b] and its initial Star([a,b]).  If 'nn >= 3' edge [a,b] still exists in  //
// current mesh and 'nn' is the current number of tets in Star([a,b]).       //
//                                                                           //
// Each 'abtets[i]', where nn <= i < n, saves either a 2-to-3 flip or a      //
// flipnm([p1,p2]) operation ([p1,p2] != [a,b]) which created the tet        //
// 'abtets[t-1]', where '0 <= t <= i'.  These information can be used to     //
// undo the flips performed in flipnm([a,b]) or to collect new tets created  //
// by the flipnm([a,b]) operation.                                           //
//                                                                           //
// Default, this routine only walks through the flips and frees the spaces   //
// allocated during the flipnm([a,b]) operation.                             //
//                                                                           //
// If the flag 'fc->unflip' is set, this routine un-does the flips performed //
// in flipnm([a,b]) so that the mesh is returned to its original state       //
// before doing the flipnm([a,b]) operation.                                 //
//                                                                           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::flipnm_post(triface* abtets, int n, int nn, int abedgepivot, flipconstraints* fc) {
    triface fliptets[3], flipface;
    triface* tmpabtets;
    int fliptype;
    int edgepivot;
    int t, n1;
    int i, j;

    if (nn == 2) {
        // The edge [a,b] has been flipped.
        // 'abtets[0]' is [c,d,e,b] or [#,#,#,b].
        // 'abtets[1]' is [d,c,e,a] or [#,#,#,a].
        if (fc->unflip) {
            // Do a 2-to-3 flip to recover the edge [a,b]. There may be hull tets.
            flip23(abtets, 1, fc);
            if (fc->collectnewtets) {
                // Pop up new (flipped) tets from the stack.
                if (abedgepivot == 0) {
                    // Two new tets were collected.
                    cavetetlist->objects -= 2;
                } else {
                    // Only one of the two new tets was collected.
                    cavetetlist->objects -= 1;
                }
            }
        }
        // The initial size of Star(ab) is 3.
        nn++;
    }

    // Walk through the performed flips.
    for (i = nn; i < n; i++) {
        // At the beginning of each step 'i', the size of the Star([a,b]) is 'i'.
        // At the end of this step, the size of the Star([a,b]) is 'i+1'.
        // The sizes of the Link([a,b]) are the same.
        fliptype = ((abtets[i].ver >> 4) & 3); // 0, 1, or 2.
        if (fliptype == 1) {
            // It was a 2-to-3 flip: [a,b,c]->[e,d].
            t = (abtets[i].ver >> 6);
            if (fc->unflip) {
                if (b->verbose > 2) {
                    printf("      Recover a 2-to-3 flip at f[%d].\n", t);
                }
                // 'abtets[(t-1)%i]' is the tet [a,b,e,d] in current Star(ab), i.e.,
                //   it is created by a 2-to-3 flip [a,b,c] => [e,d].
                fliptets[0] = abtets[((t - 1) + i) % i]; // [a,b,e,d]
                eprevself(fliptets[0]);
                esymself(fliptets[0]);
                enextself(fliptets[0]);          // [e,d,a,b]
                fnext(fliptets[0], fliptets[1]); // [e,d,b,c]
                fnext(fliptets[1], fliptets[2]); // [e,d,c,a]
                // Do a 3-to-2 flip: [e,d] => [a,b,c].
                // NOTE: hull tets may be invloved.
                flip32(fliptets, 1, fc);
                // Expand the array 'abtets', maintain the original order.
                // The new array length is (i+1).
                for (j = i - 1; j >= t; j--) {
                    abtets[j + 1] = abtets[j]; // Downshift
                }
                // The tet abtets[(t-1)%i] is deleted. Insert the two new tets
                //   'fliptets[0]' [a,b,c,d] and 'fliptets[1]' [b,a,c,e] into
                //   the (t-1)-th and t-th entries, respectively.
                esym(fliptets[1], abtets[((t - 1) + (i + 1)) % (i + 1)]); // [a,b,e,c]
                abtets[t] = fliptets[0];                                  // [a,b,c,d]
                if (fc->collectnewtets) {
                    // Pop up two (flipped) tets from the stack.
                    cavetetlist->objects -= 2;
                }
            }
        } else if (fliptype == 2) {
            tmpabtets = (triface*)(abtets[i].tet);
            n1 = ((abtets[i].ver >> 19) & 8191); // \sum_{i=0^12}{2^i} = 8191
            edgepivot = (abtets[i].ver & 3);
            t = ((abtets[i].ver >> 6) & 8191);
            if (fc->unflip) {
                if (b->verbose > 2) {
                    printf("      Recover a %d-to-m flip at e[%d] of f[%d].\n", n1, edgepivot, t);
                }
                // Recover the flipped edge ([c,b] or [a,c]).
                // abtets[(t - 1 + i) % i] is [a,b,e,d], i.e., the tet created by
                //   the flipping of edge [c,b] or [a,c]. It must still exist in
                //   Star(ab). Use it to recover the flipped edge.
                if (edgepivot == 1) {
                    // The flip edge is [c,b].
                    tmpabtets[0] = abtets[(t - 1 + i) % i]; // [a,b,e,d]
                    eprevself(tmpabtets[0]);
                    esymself(tmpabtets[0]);
                    eprevself(tmpabtets[0]);          // [d,a,e,b]
                    fsym(tmpabtets[0], tmpabtets[1]); // [a,d,e,c]
                } else {
                    // The flip edge is [a,c].
                    tmpabtets[1] = abtets[(t - 1 + i) % i]; // [a,b,e,d]
                    enextself(tmpabtets[1]);
                    esymself(tmpabtets[1]);
                    enextself(tmpabtets[1]);          // [b,d,e,a]
                    fsym(tmpabtets[1], tmpabtets[0]); // [d,b,e,c]
                }                                     // if (edgepivot == 2)

                // Do a n1-to-m1 flip to recover the flipped edge ([c,b] or [a,c]).
                flipnm_post(tmpabtets, n1, 2, edgepivot, fc);

                // Insert the two recovered tets into the original Star(ab).
                for (j = i - 1; j >= t; j--) {
                    abtets[j + 1] = abtets[j]; // Downshift
                }
                if (edgepivot == 1) {
                    // tmpabtets[0] is [c,b,d,a] ==> contains [a,b]
                    // tmpabtets[1] is [c,b,a,e] ==> contains [a,b]
                    // tmpabtets[2] is [c,b,e,d]
                    fliptets[0] = tmpabtets[1];
                    enextself(fliptets[0]);
                    esymself(fliptets[0]); // [a,b,e,c]
                    fliptets[1] = tmpabtets[0];
                    esymself(fliptets[1]);
                    eprevself(fliptets[1]); // [a,b,c,d]
                } else {
                    // tmpabtets[0] is [a,c,d,b] ==> contains [a,b]
                    // tmpabtets[1] is [a,c,b,e] ==> contains [a,b]
                    // tmpabtets[2] is [a,c,e,d]
                    fliptets[0] = tmpabtets[1];
                    eprevself(fliptets[0]);
                    esymself(fliptets[0]); // [a,b,e,c]
                    fliptets[1] = tmpabtets[0];
                    esymself(fliptets[1]);
                    enextself(fliptets[1]); // [a,b,c,d]
                }                           // edgepivot == 2
                // Insert the two recovered tets into Star(ab).
                abtets[((t - 1) + (i + 1)) % (i + 1)] = fliptets[0];
                abtets[t] = fliptets[1];
            } else {
                // Only free the spaces.
                flipnm_post(tmpabtets, n1, 2, edgepivot, fc);
            } // if (!unflip)
            if (b->verbose > 2) {
                printf("      Release %d spaces at f[%d].\n", n1, i);
            }
            delete[] tmpabtets;
        }
    } // i

    return 1;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// insertpoint()    Insert a point into current tetrahedralization.          //
//                                                                           //
// The Bowyer-Watson (B-W) algorithm is used to add a new point p into the   //
// tetrahedralization T. It first finds a "cavity", denoted as C, in T,  C   //
// consists of tetrahedra in T that "conflict" with p.  If T is a Delaunay   //
// tetrahedralization, then all boundary faces (triangles) of C are visible  //
// by p, i.e.,C is star-shaped. We can insert p into T by first deleting all //
// tetrahedra in C, then creating new tetrahedra formed by boundary faces of //
// C and p.  If T is not a DT, then C may be not star-shaped.  It must be    //
// modified so that it becomes star-shaped.                                  //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::insertpoint(point insertpt, triface* searchtet, face* splitsh, face* splitseg,
                            insertvertexflags* ivf) {
    arraypool* swaplist;
    triface *cavetet, spintet, neightet, neineitet, *parytet;
    triface oldtet, newtet, newneitet;
    face checksh, neighsh, *parysh;
    face checkseg, *paryseg;
    point *pts, pa, pb, pc, *parypt;
    enum locateresult loc = OUTSIDE;
    REAL sign, ori;
    REAL attrib, volume;
    bool enqflag;
    int t1ver;
    int i, j, k, s;

    if (b->verbose > 2) {
        printf("      Insert point %d\n", pointmark(insertpt));
    }

    // Locate the point.
    if (searchtet->tet != NULL) {
        loc = (enum locateresult)ivf->iloc;
    }

    if (loc == OUTSIDE) {
        if (searchtet->tet == NULL) {
            if (!b->weighted) {
                randomsample(insertpt, searchtet);
            } else {
                // Weighted DT. There may exist dangling vertex.
                *searchtet = recenttet;
            }
        }
        // Locate the point.
        loc = locate(insertpt, searchtet);
    }

    ivf->iloc = (int)loc; // The return value.

    if (b->weighted) {
        if (loc != OUTSIDE) {
            // Check if this vertex is regular.
            pts = (point*)searchtet->tet;
            sign = orient4d_s(pts[4], pts[5], pts[6], pts[7], insertpt, pts[4][3], pts[5][3],
                              pts[6][3], pts[7][3], insertpt[3]);
            if (sign > 0) {
                // This new vertex lies above the lower hull. Do not insert it.
                ivf->iloc = (int)NONREGULAR;
                return 0;
            }
        }
    }

    // Create the initial cavity C(p) which contains all tetrahedra that
    //   intersect p. It may include 1, 2, or n tetrahedra.
    // If p lies on a segment or subface, also create the initial sub-cavity
    //   sC(p) which contains all subfaces (and segment) which intersect p.

    if (loc == OUTSIDE) {
        flip14count++;
        // The current hull will be enlarged.
        // Add four adjacent boundary tets into list.
        for (i = 0; i < 4; i++) {
            decode(searchtet->tet[i], neightet);
            neightet.ver = epivot[neightet.ver];
            cavebdrylist->newindex((void**)&parytet);
            *parytet = neightet;
        }
        infect(*searchtet);
        caveoldtetlist->newindex((void**)&parytet);
        *parytet = *searchtet;
    } else if (loc == INTETRAHEDRON) {
        flip14count++;
        // Add four adjacent boundary tets into list.
        for (i = 0; i < 4; i++) {
            decode(searchtet->tet[i], neightet);
            neightet.ver = epivot[neightet.ver];
            cavebdrylist->newindex((void**)&parytet);
            *parytet = neightet;
        }
        infect(*searchtet);
        caveoldtetlist->newindex((void**)&parytet);
        *parytet = *searchtet;
    } else if (loc == ONFACE) {
        flip26count++;
        // Add six adjacent boundary tets into list.
        j = (searchtet->ver & 3); // The current face number.
        for (i = 1; i < 4; i++) {
            decode(searchtet->tet[(j + i) % 4], neightet);
            neightet.ver = epivot[neightet.ver];
            cavebdrylist->newindex((void**)&parytet);
            *parytet = neightet;
        }
        decode(searchtet->tet[j], spintet);
        j = (spintet.ver & 3); // The current face number.
        for (i = 1; i < 4; i++) {
            decode(spintet.tet[(j + i) % 4], neightet);
            neightet.ver = epivot[neightet.ver];
            cavebdrylist->newindex((void**)&parytet);
            *parytet = neightet;
        }
        infect(spintet);
        caveoldtetlist->newindex((void**)&parytet);
        *parytet = spintet;
        infect(*searchtet);
        caveoldtetlist->newindex((void**)&parytet);
        *parytet = *searchtet;

        if (ivf->splitbdflag) {
            if ((splitsh != NULL) && (splitsh->sh != NULL)) {
                // Create the initial sub-cavity sC(p).
                smarktest(*splitsh);
                caveshlist->newindex((void**)&parysh);
                *parysh = *splitsh;
            }
        } // if (splitbdflag)
    } else if (loc == ONEDGE) {
        flipn2ncount++;
        // Add all adjacent boundary tets into list.
        spintet = *searchtet;
        while (1) {
            eorgoppo(spintet, neightet);
            decode(neightet.tet[neightet.ver & 3], neightet);
            neightet.ver = epivot[neightet.ver];
            cavebdrylist->newindex((void**)&parytet);
            *parytet = neightet;
            edestoppo(spintet, neightet);
            decode(neightet.tet[neightet.ver & 3], neightet);
            neightet.ver = epivot[neightet.ver];
            cavebdrylist->newindex((void**)&parytet);
            *parytet = neightet;
            infect(spintet);
            caveoldtetlist->newindex((void**)&parytet);
            *parytet = spintet;
            fnextself(spintet);
            if (spintet.tet == searchtet->tet) break;
        } // while (1)

        if (ivf->splitbdflag) {
            // Create the initial sub-cavity sC(p).
            if ((splitseg != NULL) && (splitseg->sh != NULL)) {
                smarktest(*splitseg);
                splitseg->shver = 0;
                spivot(*splitseg, *splitsh);
            }
            if (splitsh != NULL) {
                if (splitsh->sh != NULL) {
                    // Collect all subfaces share at this edge.
                    pa = sorg(*splitsh);
                    neighsh = *splitsh;
                    while (1) {
                        // Adjust the origin of its edge to be 'pa'.
                        if (sorg(neighsh) != pa) {
                            sesymself(neighsh);
                        }
                        // Add this face into list (in B-W cavity).
                        smarktest(neighsh);
                        caveshlist->newindex((void**)&parysh);
                        *parysh = neighsh;
                        // Add this face into face-at-splitedge list.
                        cavesegshlist->newindex((void**)&parysh);
                        *parysh = neighsh;
                        // Go to the next face at the edge.
                        spivotself(neighsh);
                        // Stop if all faces at the edge have been visited.
                        if (neighsh.sh == splitsh->sh) break;
                        if (neighsh.sh == NULL) break;
                    } // while (1)
                }     // if (not a dangling segment)
            }
        } // if (splitbdflag)
    } else if (loc == INSTAR) {
        // We assume that all tets in the star are given in 'caveoldtetlist',
        //   and they are all infected.
        // Collect the boundary faces of the star.
        for (i = 0; i < caveoldtetlist->objects; i++) {
            cavetet = (triface*)fastlookup(caveoldtetlist, i);
            // Check its 4 neighbor tets.
            for (j = 0; j < 4; j++) {
                decode(cavetet->tet[j], neightet);
                if (!infected(neightet)) {
                    // It's a boundary face.
                    neightet.ver = epivot[neightet.ver];
                    cavebdrylist->newindex((void**)&parytet);
                    *parytet = neightet;
                }
            }
        }
    } else if (loc == ONVERTEX) {
        // The point already exist. Do nothing and return.
        return 0;
    }

    if (ivf->assignmeshsize) {
        // Assign mesh size for the new point.
        if (bgm != NULL) {
            // Interpolate the mesh size from the background mesh.
            bgm->decode(point2bgmtet(org(*searchtet)), neightet);
            int bgmloc = (int)bgm->scoutpoint(insertpt, &neightet, 0);
            if (bgmloc != (int)OUTSIDE) {
                insertpt[pointmtrindex] = bgm->getpointmeshsize(insertpt, &neightet, bgmloc);
                setpoint2bgmtet(insertpt, bgm->encode(neightet));
            }
        } else {
            insertpt[pointmtrindex] = getpointmeshsize(insertpt, searchtet, (int)loc);
        }
    } // if (assignmeshsize)

    if (ivf->bowywat) {
        // Update the cavity C(p) using the Bowyer-Watson algorithm.
        swaplist = cavetetlist;
        cavetetlist = cavebdrylist;
        cavebdrylist = swaplist;
        for (i = 0; i < cavetetlist->objects; i++) {
            // 'cavetet' is an adjacent tet at outside of the cavity.
            cavetet = (triface*)fastlookup(cavetetlist, i);
            // The tet may be tested and included in the (enlarged) cavity.
            if (!infected(*cavetet)) {
                // Check for two possible cases for this tet:
                //   (1) It is a cavity tet, or
                //   (2) it is a cavity boundary face.
                enqflag = false;
                if (!marktested(*cavetet)) {
                    // Do Delaunay (in-sphere) test.
                    pts = (point*)cavetet->tet;
                    if (pts[7] != dummypoint) {
                        // A volume tet. Operate on it.
                        if (b->weighted) {
                            sign = orient4d_s(pts[4], pts[5], pts[6], pts[7], insertpt, pts[4][3],
                                              pts[5][3], pts[6][3], pts[7][3], insertpt[3]);
                        } else {
                            sign = insphere_s(pts[4], pts[5], pts[6], pts[7], insertpt);
                        }
                        enqflag = (sign < 0.0);
                    } else {
                        if (!nonconvex) {
                            // Test if this hull face is visible by the new point.
                            ori = orient3d(pts[4], pts[5], pts[6], insertpt);
                            if (ori < 0) {
                                // A visible hull face.
                                // Include it in the cavity. The convex hull will be enlarged.
                                enqflag = true;
                            } else if (ori == 0.0) {
                                // A coplanar hull face. We need to test if this hull face is
                                //   Delaunay or not. We test if the adjacent tet (not faked)
                                //   of this hull face is Delaunay or not.
                                decode(cavetet->tet[3], neineitet);
                                if (!infected(neineitet)) {
                                    if (!marktested(neineitet)) {
                                        // Do Delaunay test on this tet.
                                        pts = (point*)neineitet.tet;
                                        if (b->weighted) {
                                            sign = orient4d_s(pts[4], pts[5], pts[6], pts[7],
                                                              insertpt, pts[4][3], pts[5][3],
                                                              pts[6][3], pts[7][3], insertpt[3]);
                                        } else {
                                            sign = insphere_s(pts[4], pts[5], pts[6], pts[7],
                                                              insertpt);
                                        }
                                        enqflag = (sign < 0.0);
                                    }
                                } else {
                                    // The adjacent tet is non-Delaunay. The hull face is non-
                                    //   Delaunay as well. Include it in the cavity.
                                    enqflag = true;
                                } // if (!infected(neineitet))
                            }     // if (ori == 0.0)
                        } else {
                            // A hull face (must be a subface).
                            // We FIRST include it in the initial cavity if the adjacent tet
                            //   (not faked) of this hull face is not Delaunay wrt p.
                            //   Whether it belongs to the final cavity will be determined
                            //   during the validation process. 'validflag'.
                            decode(cavetet->tet[3], neineitet);
                            if (!infected(neineitet)) {
                                if (!marktested(neineitet)) {
                                    // Do Delaunay test on this tet.
                                    pts = (point*)neineitet.tet;
                                    if (b->weighted) {
                                        sign = orient4d_s(pts[4], pts[5], pts[6], pts[7], insertpt,
                                                          pts[4][3], pts[5][3], pts[6][3],
                                                          pts[7][3], insertpt[3]);
                                    } else {
                                        sign = insphere_s(pts[4], pts[5], pts[6], pts[7], insertpt);
                                    }
                                    enqflag = (sign < 0.0);
                                }
                            } else {
                                // The adjacent tet is non-Delaunay. The hull face is non-
                                //   Delaunay as well. Include it in the cavity.
                                enqflag = true;
                            }           // if (infected(neineitet))
                        }               // if (nonconvex)
                    }                   // if (pts[7] != dummypoint)
                    marktest(*cavetet); // Only test it once.
                }                       // if (!marktested(*cavetet))

                if (enqflag) {
                    // Found a tet in the cavity. Put other three faces in check list.
                    k = (cavetet->ver & 3); // The current face number
                    for (j = 1; j < 4; j++) {
                        decode(cavetet->tet[(j + k) % 4], neightet);
                        cavetetlist->newindex((void**)&parytet);
                        *parytet = neightet;
                    }
                    infect(*cavetet);
                    caveoldtetlist->newindex((void**)&parytet);
                    *parytet = *cavetet;
                } else {
                    // Found a boundary face of the cavity.
                    cavetet->ver = epivot[cavetet->ver];
                    cavebdrylist->newindex((void**)&parytet);
                    *parytet = *cavetet;
                }
            } // if (!infected(*cavetet))
        }     // i

        cavetetlist->restart(); // Clear the working list.
    }                           // if (ivf->bowywat)

    if (checksubsegflag) {
        // Collect all segments of C(p).
        shellface* ssptr;
        for (i = 0; i < caveoldtetlist->objects; i++) {
            cavetet = (triface*)fastlookup(caveoldtetlist, i);
            if ((ssptr = (shellface*)cavetet->tet[8]) != NULL) {
                for (j = 0; j < 6; j++) {
                    if (ssptr[j]) {
                        sdecode(ssptr[j], checkseg);
                        if (!sinfected(checkseg)) {
                            sinfect(checkseg);
                            cavetetseglist->newindex((void**)&paryseg);
                            *paryseg = checkseg;
                        }
                    }
                } // j
            }
        } // i
        // Uninfect collected segments.
        for (i = 0; i < cavetetseglist->objects; i++) {
            paryseg = (face*)fastlookup(cavetetseglist, i);
            suninfect(*paryseg);
        }

        if (ivf->rejflag & 1) {
            // Reject this point if it encroaches upon any segment.
            face* paryseg1;
            for (i = 0; i < cavetetseglist->objects; i++) {
                paryseg1 = (face*)fastlookup(cavetetseglist, i);
                if (checkseg4encroach((point)paryseg1->sh[3], (point)paryseg1->sh[4], insertpt)) {
                    encseglist->newindex((void**)&paryseg);
                    *paryseg = *paryseg1;
                }
            } // i
            if ((ivf->rejflag & 1) && (encseglist->objects > 0)) {
                insertpoint_abort(splitseg, ivf);
                ivf->iloc = (int)ENCSEGMENT;
                return 0;
            }
        }
    } // if (checksubsegflag)

    if (checksubfaceflag) {
        // Collect all subfaces of C(p).
        shellface* sptr;
        for (i = 0; i < caveoldtetlist->objects; i++) {
            cavetet = (triface*)fastlookup(caveoldtetlist, i);
            if ((sptr = (shellface*)cavetet->tet[9]) != NULL) {
                for (j = 0; j < 4; j++) {
                    if (sptr[j]) {
                        sdecode(sptr[j], checksh);
                        if (!sinfected(checksh)) {
                            sinfect(checksh);
                            cavetetshlist->newindex((void**)&parysh);
                            *parysh = checksh;
                        }
                    }
                } // j
            }
        } // i
        // Uninfect collected subfaces.
        for (i = 0; i < cavetetshlist->objects; i++) {
            parysh = (face*)fastlookup(cavetetshlist, i);
            suninfect(*parysh);
        }

        if (ivf->rejflag & 2) {
            REAL rd, cent[3];
            badface* bface;
            // Reject this point if it encroaches upon any subface.
            for (i = 0; i < cavetetshlist->objects; i++) {
                parysh = (face*)fastlookup(cavetetshlist, i);
                if (checkfac4encroach((point)parysh->sh[3], (point)parysh->sh[4],
                                      (point)parysh->sh[5], insertpt, cent, &rd)) {
                    encshlist->newindex((void**)&bface);
                    bface->ss = *parysh;
                    bface->forg = (point)parysh->sh[3]; // Not a dad one.
                    for (j = 0; j < 3; j++)
                        bface->cent[j] = cent[j];
                    bface->key = rd;
                }
            }
            if (encshlist->objects > 0) {
                insertpoint_abort(splitseg, ivf);
                ivf->iloc = (int)ENCSUBFACE;
                return 0;
            }
        }
    } // if (checksubfaceflag)

    if ((ivf->iloc == (int)OUTSIDE) && ivf->refineflag) {
        // The vertex lies outside of the domain. And it does not encroach
        //   upon any boundary segment or subface. Do not insert it.
        insertpoint_abort(splitseg, ivf);
        return 0;
    }

    if (ivf->splitbdflag) {
        // The new point locates in surface mesh. Update the sC(p).
        // We have already 'smarktested' the subfaces which directly intersect
        //   with p in 'caveshlist'. From them, we 'smarktest' their neighboring
        //   subfaces which are included in C(p). Do not across a segment.
        for (i = 0; i < caveshlist->objects; i++) {
            parysh = (face*)fastlookup(caveshlist, i);
            checksh = *parysh;
            for (j = 0; j < 3; j++) {
                if (!isshsubseg(checksh)) {
                    spivot(checksh, neighsh);
                    if (!smarktested(neighsh)) {
                        stpivot(neighsh, neightet);
                        if (infected(neightet)) {
                            fsymself(neightet);
                            if (infected(neightet)) {
                                // This subface is inside C(p).
                                // Check if its diametrical circumsphere encloses 'p'.
                                //   The purpose of this check is to avoid forming invalid
                                //   subcavity in surface mesh.
                                sign = incircle3d(sorg(neighsh), sdest(neighsh), sapex(neighsh),
                                                  insertpt);
                                if (sign < 0) {
                                    smarktest(neighsh);
                                    caveshlist->newindex((void**)&parysh);
                                    *parysh = neighsh;
                                }
                            }
                        }
                    }
                }
                senextself(checksh);
            } // j
        }     // i
    }         // if (ivf->splitbdflag)

    if (ivf->validflag) {
        // Validate C(p) and update it if it is not star-shaped.
        int cutcount = 0;

        if (ivf->respectbdflag) {
            // The initial cavity may include subfaces which are not on the facets
            //   being splitting. Find them and make them as boundary of C(p).
            // Comment: We have already 'smarktested' the subfaces in sC(p). They
            //   are completely inside C(p).
            for (i = 0; i < cavetetshlist->objects; i++) {
                parysh = (face*)fastlookup(cavetetshlist, i);
                stpivot(*parysh, neightet);
                if (infected(neightet)) {
                    fsymself(neightet);
                    if (infected(neightet)) {
                        // Found a subface inside C(p).
                        if (!smarktested(*parysh)) {
                            // It is possible that this face is a boundary subface.
                            // Check if it is a hull face.
                            // assert(apex(neightet) != dummypoint);
                            if (oppo(neightet) != dummypoint) {
                                fsymself(neightet);
                            }
                            if (oppo(neightet) != dummypoint) {
                                ori = orient3d(org(neightet), dest(neightet), apex(neightet),
                                               insertpt);
                                if (ori < 0) {
                                    // A visible face, get its neighbor face.
                                    fsymself(neightet);
                                    ori = -ori; // It must be invisible by p.
                                }
                            } else {
                                // A hull tet. It needs to be cut.
                                ori = 1;
                            }
                            // Cut this tet if it is either invisible by or coplanar with p.
                            if (ori >= 0) {
                                uninfect(neightet);
                                unmarktest(neightet);
                                cutcount++;
                                neightet.ver = epivot[neightet.ver];
                                cavebdrylist->newindex((void**)&parytet);
                                *parytet = neightet;
                                // Add three new faces to find new boundaries.
                                for (j = 0; j < 3; j++) {
                                    esym(neightet, neineitet);
                                    neineitet.ver = epivot[neineitet.ver];
                                    cavebdrylist->newindex((void**)&parytet);
                                    *parytet = neineitet;
                                    enextself(neightet);
                                }
                            } // if (ori >= 0)
                        }
                    }
                }
            } // i

            // The initial cavity may include segments in its interior. We need to
            //   Update the cavity so that these segments are on the boundary of
            //   the cavity.
            for (i = 0; i < cavetetseglist->objects; i++) {
                paryseg = (face*)fastlookup(cavetetseglist, i);
                // Check this segment if it is not a splitting segment.
                if (!smarktested(*paryseg)) {
                    sstpivot1(*paryseg, neightet);
                    spintet = neightet;
                    while (1) {
                        if (!infected(spintet)) break;
                        fnextself(spintet);
                        if (spintet.tet == neightet.tet) break;
                    }
                    if (infected(spintet)) {
                        // Find an adjacent tet at this segment such that both faces
                        //   at this segment are not visible by p.
                        pa = org(neightet);
                        pb = dest(neightet);
                        spintet = neightet;
                        j = 0;
                        while (1) {
                            // Check if this face is visible by p.
                            pc = apex(spintet);
                            if (pc != dummypoint) {
                                ori = orient3d(pa, pb, pc, insertpt);
                                if (ori >= 0) {
                                    // Not visible. Check another face in this tet.
                                    esym(spintet, neineitet);
                                    pc = apex(neineitet);
                                    if (pc != dummypoint) {
                                        ori = orient3d(pb, pa, pc, insertpt);
                                        if (ori >= 0) {
                                            // Not visible. Found this face.
                                            j = 1; // Flag that it is found.
                                            break;
                                        }
                                    }
                                }
                            }
                            fnextself(spintet);
                            if (spintet.tet == neightet.tet) break;
                        }
                        if (j == 0) {
                            // Not found such a face.
                            terminatetetgen(this, 2);
                        }
                        neightet = spintet;
                        if (b->verbose > 3) {
                            printf("        Cut tet (%d, %d, %d, %d)\n", pointmark(org(neightet)),
                                   pointmark(dest(neightet)), pointmark(apex(neightet)),
                                   pointmark(oppo(neightet)));
                        }
                        uninfect(neightet);
                        unmarktest(neightet);
                        cutcount++;
                        neightet.ver = epivot[neightet.ver];
                        cavebdrylist->newindex((void**)&parytet);
                        *parytet = neightet;
                        // Add three new faces to find new boundaries.
                        for (j = 0; j < 3; j++) {
                            esym(neightet, neineitet);
                            neineitet.ver = epivot[neineitet.ver];
                            cavebdrylist->newindex((void**)&parytet);
                            *parytet = neineitet;
                            enextself(neightet);
                        }
                    }
                }
            } // i
        }     // if (ivf->respectbdflag)

        // Update the cavity by removing invisible faces until it is star-shaped.
        for (i = 0; i < cavebdrylist->objects; i++) {
            cavetet = (triface*)fastlookup(cavebdrylist, i);
            // 'cavetet' is an exterior tet adjacent to the cavity.
            // Check if its neighbor is inside C(p).
            fsym(*cavetet, neightet);
            if (infected(neightet)) {
                if (apex(*cavetet) != dummypoint) {
                    // It is a cavity boundary face. Check its visibility.
                    if (oppo(neightet) != dummypoint) {
                        // Check if this face is visible by the new point.
                        if (issubface(neightet)) {
                            // We should only create a new tet that has a reasonable volume.
                            // Re-use 'volume' and 'attrib'.
                            pa = org(*cavetet);
                            pb = dest(*cavetet);
                            pc = apex(*cavetet);
                            volume = orient3dfast(pa, pb, pc, insertpt);
                            attrib = distance(pa, pb) * distance(pb, pc) * distance(pc, pa);
                            if ((fabs(volume) / attrib) < b->epsilon) {
                                ori = 0.0;
                            } else {
                                ori = orient3d(pa, pb, pc, insertpt);
                            }
                        } else {
                            ori = orient3d(org(*cavetet), dest(*cavetet), apex(*cavetet), insertpt);
                        }
                        enqflag = (ori > 0);
                        // Comment: if ori == 0 (coplanar case), we also cut the tet.
                    } else {
                        // It is a hull face. And its adjacent tet (at inside of the
                        //   domain) has been cut from the cavity. Cut it as well.
                        // assert(nonconvex);
                        enqflag = false;
                    }
                } else {
                    enqflag = true; // A hull edge.
                }
                if (enqflag) {
                    // This face is valid, save it.
                    cavetetlist->newindex((void**)&parytet);
                    *parytet = *cavetet;
                } else {
                    uninfect(neightet);
                    unmarktest(neightet);
                    cutcount++;
                    // Add three new faces to find new boundaries.
                    for (j = 0; j < 3; j++) {
                        esym(neightet, neineitet);
                        neineitet.ver = epivot[neineitet.ver];
                        cavebdrylist->newindex((void**)&parytet);
                        *parytet = neineitet;
                        enextself(neightet);
                    }
                    // 'cavetet' is not on the cavity boundary anymore.
                    unmarktest(*cavetet);
                }
            } else {
                // 'cavetet' is not on the cavity boundary anymore.
                unmarktest(*cavetet);
            }
        } // i

        if (cutcount > 0) {
            // The cavity has been updated.
            // Update the cavity boundary faces.
            cavebdrylist->restart();
            for (i = 0; i < cavetetlist->objects; i++) {
                cavetet = (triface*)fastlookup(cavetetlist, i);
                // 'cavetet' was an exterior tet adjacent to the cavity.
                fsym(*cavetet, neightet);
                if (infected(neightet)) {
                    // It is a cavity boundary face.
                    cavebdrylist->newindex((void**)&parytet);
                    *parytet = *cavetet;
                } else {
                    // Not a cavity boundary face.
                    unmarktest(*cavetet);
                }
            }

            // Update the list of old tets.
            cavetetlist->restart();
            for (i = 0; i < caveoldtetlist->objects; i++) {
                cavetet = (triface*)fastlookup(caveoldtetlist, i);
                if (infected(*cavetet)) {
                    cavetetlist->newindex((void**)&parytet);
                    *parytet = *cavetet;
                }
            }
            // Swap 'cavetetlist' and 'caveoldtetlist'.
            swaplist = caveoldtetlist;
            caveoldtetlist = cavetetlist;
            cavetetlist = swaplist;

            // The cavity should contain at least one tet.
            if (caveoldtetlist->objects == 0l) {
                insertpoint_abort(splitseg, ivf);
                ivf->iloc = (int)BADELEMENT;
                return 0;
            }

            if (ivf->splitbdflag) {
                int cutshcount = 0;
                // Update the sub-cavity sC(p).
                for (i = 0; i < caveshlist->objects; i++) {
                    parysh = (face*)fastlookup(caveshlist, i);
                    if (smarktested(*parysh)) {
                        enqflag = false;
                        stpivot(*parysh, neightet);
                        if (infected(neightet)) {
                            fsymself(neightet);
                            if (infected(neightet)) {
                                enqflag = true;
                            }
                        }
                        if (!enqflag) {
                            sunmarktest(*parysh);
                            // Use the last entry of this array to fill this entry.
                            j = caveshlist->objects - 1;
                            checksh = *(face*)fastlookup(caveshlist, j);
                            *parysh = checksh;
                            cutshcount++;
                            caveshlist->objects--; // The list is shrinked.
                            i--;
                        }
                    }
                }

                if (cutshcount > 0) {
                    i = 0; // Count the number of invalid subfaces/segments.
                    // Valid the updated sub-cavity sC(p).
                    if (loc == ONFACE) {
                        if ((splitsh != NULL) && (splitsh->sh != NULL)) {
                            // The to-be split subface should be in sC(p).
                            if (!smarktested(*splitsh)) i++;
                        }
                    } else if (loc == ONEDGE) {
                        if ((splitseg != NULL) && (splitseg->sh != NULL)) {
                            // The to-be split segment should be in sC(p).
                            if (!smarktested(*splitseg)) i++;
                        }
                        if ((splitsh != NULL) && (splitsh->sh != NULL)) {
                            // All subfaces at this edge should be in sC(p).
                            pa = sorg(*splitsh);
                            neighsh = *splitsh;
                            while (1) {
                                // Adjust the origin of its edge to be 'pa'.
                                if (sorg(neighsh) != pa) {
                                    sesymself(neighsh);
                                }
                                // Add this face into list (in B-W cavity).
                                if (!smarktested(neighsh)) i++;
                                // Go to the next face at the edge.
                                spivotself(neighsh);
                                // Stop if all faces at the edge have been visited.
                                if (neighsh.sh == splitsh->sh) break;
                                if (neighsh.sh == NULL) break;
                            } // while (1)
                        }
                    }

                    if (i > 0) {
                        // The updated sC(p) is invalid. Do not insert this vertex.
                        insertpoint_abort(splitseg, ivf);
                        ivf->iloc = (int)BADELEMENT;
                        return 0;
                    }
                } // if (cutshcount > 0)
            }     // if (ivf->splitbdflag)
        }         // if (cutcount > 0)

    } // if (ivf->validflag)

    if (ivf->refineflag) {
        // The new point is inserted by Delaunay refinement, i.e., it is the
        //   circumcenter of a tetrahedron, or a subface, or a segment.
        //   Do not insert this point if the tetrahedron, or subface, or segment
        //   is not inside the final cavity.
        if (((ivf->refineflag == 1) && !infected(ivf->refinetet)) ||
            ((ivf->refineflag == 2) && !smarktested(ivf->refinesh))) {
            insertpoint_abort(splitseg, ivf);
            ivf->iloc = (int)BADELEMENT;
            return 0;
        }
    } // if (ivf->refineflag)

    if (b->plc && (loc != INSTAR)) {
        // Reject the new point if it lies too close to an existing point (b->plc),
        // or it lies inside a protecting ball of near vertex (ivf->rejflag & 4).
        // Collect the list of vertices of the initial cavity.
        if (loc == OUTSIDE) {
            pts = (point*)&(searchtet->tet[4]);
            for (i = 0; i < 3; i++) {
                cavetetvertlist->newindex((void**)&parypt);
                *parypt = pts[i];
            }
        } else if (loc == INTETRAHEDRON) {
            pts = (point*)&(searchtet->tet[4]);
            for (i = 0; i < 4; i++) {
                cavetetvertlist->newindex((void**)&parypt);
                *parypt = pts[i];
            }
        } else if (loc == ONFACE) {
            pts = (point*)&(searchtet->tet[4]);
            for (i = 0; i < 3; i++) {
                cavetetvertlist->newindex((void**)&parypt);
                *parypt = pts[i];
            }
            if (pts[3] != dummypoint) {
                cavetetvertlist->newindex((void**)&parypt);
                *parypt = pts[3];
            }
            fsym(*searchtet, spintet);
            if (oppo(spintet) != dummypoint) {
                cavetetvertlist->newindex((void**)&parypt);
                *parypt = oppo(spintet);
            }
        } else if (loc == ONEDGE) {
            spintet = *searchtet;
            cavetetvertlist->newindex((void**)&parypt);
            *parypt = org(spintet);
            cavetetvertlist->newindex((void**)&parypt);
            *parypt = dest(spintet);
            while (1) {
                if (apex(spintet) != dummypoint) {
                    cavetetvertlist->newindex((void**)&parypt);
                    *parypt = apex(spintet);
                }
                fnextself(spintet);
                if (spintet.tet == searchtet->tet) break;
            }
        }

        int rejptflag = (ivf->rejflag & 4);
        REAL rd;
        pts = NULL;

        for (i = 0; i < cavetetvertlist->objects; i++) {
            parypt = (point*)fastlookup(cavetetvertlist, i);
            rd = distance(*parypt, insertpt);
            // Is the point very close to an existing point?
            if (rd < minedgelength) {
                pts = parypt;
                loc = NEARVERTEX;
                break;
            }
            if (rejptflag) {
                // Is the point encroaches upon an existing point?
                if (rd < (0.5 * (*parypt)[pointmtrindex])) {
                    pts = parypt;
                    loc = ENCVERTEX;
                    break;
                }
            }
        }
        cavetetvertlist->restart(); // Clear the work list.

        if (pts != NULL) {
            // The point is either too close to an existing vertex (NEARVERTEX)
            //   or encroaches upon (inside the protecting ball) of that vertex.
            if (loc == NEARVERTEX) {
                if (!issteinerpoint(insertpt) && b->nomergevertex) { // -M0/1 option.
                    // 'insertpt' is an input vertex.
                    // In this case, we still insert this vertex. Issue a warning.
                    if (!b->quiet) {
                        printf("Warning:  Two points, %d and %d, are very close.\n",
                               pointmark(insertpt), pointmark(*pts));
                        printf("  Creating a very short edge (len = %g) (< %g).\n", rd,
                               minedgelength);
                        printf("  You may try a smaller tolerance (-T) (current is %g)\n",
                               b->epsilon);
                        printf("  to avoid this warning.\n");
                    }
                } else {
                    point2tetorg(*pts, *searchtet);
                    insertpoint_abort(splitseg, ivf);
                    ivf->iloc = (int)loc;
                    return 0;
                }
            } else { // loc == ENCVERTEX
                // The point lies inside the protection ball.
                point2tetorg(*pts, *searchtet);
                insertpoint_abort(splitseg, ivf);
                ivf->iloc = (int)loc;
                return 0;
            }
        }
    } // if (b->plc && (loc != INSTAR))

    if (b->weighted || ivf->cdtflag || ivf->smlenflag) {
        // There may be other vertices inside C(p). We need to find them.
        // Collect all vertices of C(p).
        for (i = 0; i < caveoldtetlist->objects; i++) {
            cavetet = (triface*)fastlookup(caveoldtetlist, i);
            // assert(infected(*cavetet));
            pts = (point*)&(cavetet->tet[4]);
            for (j = 0; j < 4; j++) {
                if (pts[j] != dummypoint) {
                    if (!pinfected(pts[j])) {
                        pinfect(pts[j]);
                        cavetetvertlist->newindex((void**)&parypt);
                        *parypt = pts[j];
                    }
                }
            } // j
        }     // i
        // Uninfect all collected (cavity) vertices.
        for (i = 0; i < cavetetvertlist->objects; i++) {
            parypt = (point*)fastlookup(cavetetvertlist, i);
            puninfect(*parypt);
        }
        if (ivf->smlenflag) {
            REAL len;
            // Get the length of the shortest edge connecting to 'newpt'.
            parypt = (point*)fastlookup(cavetetvertlist, 0);
            ivf->smlen = distance(*parypt, insertpt);
            ivf->parentpt = *parypt;
            for (i = 1; i < cavetetvertlist->objects; i++) {
                parypt = (point*)fastlookup(cavetetvertlist, i);
                len = distance(*parypt, insertpt);
                if (len < ivf->smlen) {
                    ivf->smlen = len;
                    ivf->parentpt = *parypt;
                }
            }
        }
    }

    if (ivf->cdtflag) {
        // Unmark tets.
        for (i = 0; i < caveoldtetlist->objects; i++) {
            cavetet = (triface*)fastlookup(caveoldtetlist, i);
            unmarktest(*cavetet);
        }
        for (i = 0; i < cavebdrylist->objects; i++) {
            cavetet = (triface*)fastlookup(cavebdrylist, i);
            unmarktest(*cavetet);
        }
        // Clean up arrays which are not needed.
        cavetetlist->restart();
        if (checksubsegflag) {
            cavetetseglist->restart();
        }
        if (checksubfaceflag) {
            cavetetshlist->restart();
        }
        return 1;
    }

    // Before re-mesh C(p). Process the segments and subfaces which are on the
    //   boundary of C(p). Make sure that each such segment or subface is
    //   connecting to a tet outside C(p). So we can re-connect them to the
    //   new tets inside the C(p) later.

    if (checksubsegflag) {
        for (i = 0; i < cavetetseglist->objects; i++) {
            paryseg = (face*)fastlookup(cavetetseglist, i);
            // Operate on it if it is not the splitting segment, i.e., in sC(p).
            if (!smarktested(*paryseg)) {
                // Check if the segment is inside the cavity.
                //   'j' counts the num of adjacent tets of this seg.
                //   'k' counts the num of adjacent tets which are 'sinfected'.
                j = k = 0;
                sstpivot1(*paryseg, neightet);
                spintet = neightet;
                while (1) {
                    j++;
                    if (!infected(spintet)) {
                        neineitet = spintet; // An outer tet. Remember it.
                    } else {
                        k++; // An in tet.
                    }
                    fnextself(spintet);
                    if (spintet.tet == neightet.tet) break;
                }
                // assert(j > 0);
                if (k == 0) {
                    // The segment is not connect to C(p) anymore. Remove it by
                    //   Replacing it by the last entry of this list.
                    s = cavetetseglist->objects - 1;
                    checkseg = *(face*)fastlookup(cavetetseglist, s);
                    *paryseg = checkseg;
                    cavetetseglist->objects--;
                    i--;
                } else if (k < j) {
                    // The segment is on the boundary of C(p).
                    sstbond1(*paryseg, neineitet);
                } else { // k == j
                    // The segment is inside C(p).
                    if (!ivf->splitbdflag) {
                        checkseg = *paryseg;
                        sinfect(checkseg); // Flag it as an interior segment.
                        caveencseglist->newindex((void**)&paryseg);
                        *paryseg = checkseg;
                    } else {
                        // assert(0); // Not possible.
                        terminatetetgen(this, 2);
                    }
                }
            } else {
                // assert(smarktested(*paryseg));
                // Flag it as an interior segment. Do not queue it, since it will
                //   be deleted after the segment splitting.
                sinfect(*paryseg);
            }
        } // i
    }     // if (checksubsegflag)

    if (checksubfaceflag) {
        for (i = 0; i < cavetetshlist->objects; i++) {
            parysh = (face*)fastlookup(cavetetshlist, i);
            // Operate on it if it is not inside the sub-cavity sC(p).
            if (!smarktested(*parysh)) {
                // Check if this subface is inside the cavity.
                k = 0;
                for (j = 0; j < 2; j++) {
                    stpivot(*parysh, neightet);
                    if (!infected(neightet)) {
                        checksh = *parysh; // Remember this side.
                    } else {
                        k++;
                    }
                    sesymself(*parysh);
                }
                if (k == 0) {
                    // The subface is not connected to C(p). Remove it.
                    s = cavetetshlist->objects - 1;
                    checksh = *(face*)fastlookup(cavetetshlist, s);
                    *parysh = checksh;
                    cavetetshlist->objects--;
                    i--;
                } else if (k == 1) {
                    // This side is the outer boundary of C(p).
                    *parysh = checksh;
                } else { // k == 2
                    if (!ivf->splitbdflag) {
                        checksh = *parysh;
                        sinfect(checksh); // Flag it.
                        caveencshlist->newindex((void**)&parysh);
                        *parysh = checksh;
                    } else {
                        // assert(0); // Not possible.
                        terminatetetgen(this, 2);
                    }
                }
            } else {
                // assert(smarktested(*parysh));
                // Flag it as an interior subface. Do not queue it. It will be
                //   deleted after the facet point insertion.
                sinfect(*parysh);
            }
        } // i
    }     // if (checksubfaceflag)

    // Create new tetrahedra to fill the cavity.

    for (i = 0; i < cavebdrylist->objects; i++) {
        cavetet = (triface*)fastlookup(cavebdrylist, i);
        neightet = *cavetet;
        unmarktest(neightet); // Unmark it.
        // Get the oldtet (inside the cavity).
        fsym(neightet, oldtet);
        if (apex(neightet) != dummypoint) {
            // Create a new tet in the cavity.
            maketetrahedron(&newtet);
            setorg(newtet, dest(neightet));
            setdest(newtet, org(neightet));
            setapex(newtet, apex(neightet));
            setoppo(newtet, insertpt);
        } else {
            // Create a new hull tet.
            hullsize++;
            maketetrahedron(&newtet);
            setorg(newtet, org(neightet));
            setdest(newtet, dest(neightet));
            setapex(newtet, insertpt);
            setoppo(newtet, dummypoint); // It must opposite to face 3.
            // Adjust back to the cavity bounday face.
            esymself(newtet);
        }
        // The new tet inherits attribtes from the old tet.
        for (j = 0; j < numelemattrib; j++) {
            attrib = elemattribute(oldtet.tet, j);
            setelemattribute(newtet.tet, j, attrib);
        }
        if (b->varvolume) {
            volume = volumebound(oldtet.tet);
            setvolumebound(newtet.tet, volume);
        }
        // Connect newtet <==> neightet, this also disconnect the old bond.
        bond(newtet, neightet);
        // oldtet still connects to neightet.
        *cavetet = oldtet; // *cavetet = newtet;
    }                      // i

    // Set a handle for speeding point location.
    recenttet = newtet;
    // setpoint2tet(insertpt, encode(newtet));
    setpoint2tet(insertpt, (tetrahedron)(newtet.tet));

    // Re-use this list to save new interior cavity faces.
    cavetetlist->restart();

    // Connect adjacent new tetrahedra together.
    for (i = 0; i < cavebdrylist->objects; i++) {
        cavetet = (triface*)fastlookup(cavebdrylist, i);
        // cavtet is an oldtet, get the newtet at this face.
        oldtet = *cavetet;
        fsym(oldtet, neightet);
        fsym(neightet, newtet);
        // Comment: oldtet and newtet must be at the same directed edge.
        // Connect the three other faces of this newtet.
        for (j = 0; j < 3; j++) {
            esym(newtet, neightet); // Go to the face.
            if (neightet.tet[neightet.ver & 3] == NULL) {
                // Find the adjacent face of this newtet.
                spintet = oldtet;
                while (1) {
                    fnextself(spintet);
                    if (!infected(spintet)) break;
                }
                fsym(spintet, newneitet);
                esymself(newneitet);
                bond(neightet, newneitet);
                if (ivf->lawson > 1) {
                    cavetetlist->newindex((void**)&parytet);
                    *parytet = neightet;
                }
            }
            // setpoint2tet(org(newtet), encode(newtet));
            setpoint2tet(org(newtet), (tetrahedron)(newtet.tet));
            enextself(newtet);
            enextself(oldtet);
        }
        *cavetet = newtet; // Save the new tet.
    }                      // i

    if (checksubfaceflag) {
        // Connect subfaces on the boundary of the cavity to the new tets.
        for (i = 0; i < cavetetshlist->objects; i++) {
            parysh = (face*)fastlookup(cavetetshlist, i);
            // Connect it if it is not a missing subface.
            if (!sinfected(*parysh)) {
                stpivot(*parysh, neightet);
                fsym(neightet, spintet);
                sesymself(*parysh);
                tsbond(spintet, *parysh);
            }
        }
    }

    if (checksubsegflag) {
        // Connect segments on the boundary of the cavity to the new tets.
        for (i = 0; i < cavetetseglist->objects; i++) {
            paryseg = (face*)fastlookup(cavetetseglist, i);
            // Connect it if it is not a missing segment.
            if (!sinfected(*paryseg)) {
                sstpivot1(*paryseg, neightet);
                spintet = neightet;
                while (1) {
                    tssbond1(spintet, *paryseg);
                    fnextself(spintet);
                    if (spintet.tet == neightet.tet) break;
                }
            }
        }
    }

    if (((splitsh != NULL) && (splitsh->sh != NULL)) ||
        ((splitseg != NULL) && (splitseg->sh != NULL))) {
        // Split a subface or a segment.
        sinsertvertex(insertpt, splitsh, splitseg, ivf->sloc, ivf->sbowywat, 0);
    }

    if (checksubfaceflag) {
        if (ivf->splitbdflag) {
            // Recover new subfaces in C(p).
            for (i = 0; i < caveshbdlist->objects; i++) {
                // Get an old subface at edge [a, b].
                parysh = (face*)fastlookup(caveshbdlist, i);
                spivot(*parysh, checksh); // The new subface [a, b, p].
                // Do not recover a deleted new face (degenerated).
                if (checksh.sh[3] != NULL) {
                    // Note that the old subface still connects to adjacent old tets
                    //   of C(p), which still connect to the tets outside C(p).
                    stpivot(*parysh, neightet);
                    // Find the adjacent tet containing the edge [a,b] outside C(p).
                    spintet = neightet;
                    while (1) {
                        fnextself(spintet);
                        if (!infected(spintet)) break;
                    }
                    // The adjacent tet connects to a new tet in C(p).
                    fsym(spintet, neightet);
                    // Find the tet containing the face [a, b, p].
                    spintet = neightet;
                    while (1) {
                        fnextself(spintet);
                        if (apex(spintet) == insertpt) break;
                    }
                    // Adjust the edge direction in spintet and checksh.
                    if (sorg(checksh) != org(spintet)) {
                        sesymself(checksh);
                    }
                    // Connect the subface to two adjacent tets.
                    tsbond(spintet, checksh);
                    fsymself(spintet);
                    sesymself(checksh);
                    tsbond(spintet, checksh);
                } // if (checksh.sh[3] != NULL)
            }
        } else {
            // The Boundary recovery phase.
            // Put all new subfaces into stack for recovery.
            for (i = 0; i < caveshbdlist->objects; i++) {
                // Get an old subface at edge [a, b].
                parysh = (face*)fastlookup(caveshbdlist, i);
                spivot(*parysh, checksh); // The new subface [a, b, p].
                // Do not recover a deleted new face (degenerated).
                if (checksh.sh[3] != NULL) {
                    subfacstack->newindex((void**)&parysh);
                    *parysh = checksh;
                }
            }
            // Put all interior subfaces into stack for recovery.
            for (i = 0; i < caveencshlist->objects; i++) {
                parysh = (face*)fastlookup(caveencshlist, i);
                // Some subfaces inside C(p) might be split in sinsertvertex().
                //   Only queue those faces which are not split.
                if (!smarktested(*parysh)) {
                    checksh = *parysh;
                    suninfect(checksh);
                    stdissolve(checksh); // Detach connections to old tets.
                    subfacstack->newindex((void**)&parysh);
                    *parysh = checksh;
                }
            }
        }
    } // if (checksubfaceflag)

    if (checksubsegflag) {
        if (ivf->splitbdflag) {
            if (splitseg != NULL) {
                // Recover the two new subsegments in C(p).
                for (i = 0; i < cavesegshlist->objects; i++) {
                    paryseg = (face*)fastlookup(cavesegshlist, i);
                    // Insert this subsegment into C(p).
                    checkseg = *paryseg;
                    // Get the adjacent new subface.
                    checkseg.shver = 0;
                    spivot(checkseg, checksh);
                    if (checksh.sh != NULL) {
                        // Get the adjacent new tetrahedron.
                        stpivot(checksh, neightet);
                    } else {
                        // It's a dangling segment.
                        point2tetorg(sorg(checkseg), neightet);
                        finddirection(&neightet, sdest(checkseg));
                    }
                    sstbond1(checkseg, neightet);
                    spintet = neightet;
                    while (1) {
                        tssbond1(spintet, checkseg);
                        fnextself(spintet);
                        if (spintet.tet == neightet.tet) break;
                    }
                }
            } // if (splitseg != NULL)
        } else {
            // The Boundary Recovery Phase.
            // Queue missing segments in C(p) for recovery.
            if (splitseg != NULL) {
                // Queue two new subsegments in C(p) for recovery.
                for (i = 0; i < cavesegshlist->objects; i++) {
                    paryseg = (face*)fastlookup(cavesegshlist, i);
                    checkseg = *paryseg;
                    // sstdissolve1(checkseg); // It has not been connected yet.
                    s = randomnation(subsegstack->objects + 1);
                    subsegstack->newindex((void**)&paryseg);
                    *paryseg = *(face*)fastlookup(subsegstack, s);
                    paryseg = (face*)fastlookup(subsegstack, s);
                    *paryseg = checkseg;
                }
            } // if (splitseg != NULL)
            for (i = 0; i < caveencseglist->objects; i++) {
                paryseg = (face*)fastlookup(caveencseglist, i);
                if (!smarktested(*paryseg)) { // It may be split.
                    checkseg = *paryseg;
                    suninfect(checkseg);
                    sstdissolve1(checkseg); // Detach connections to old tets.
                    s = randomnation(subsegstack->objects + 1);
                    subsegstack->newindex((void**)&paryseg);
                    *paryseg = *(face*)fastlookup(subsegstack, s);
                    paryseg = (face*)fastlookup(subsegstack, s);
                    *paryseg = checkseg;
                }
            }
        }
    } // if (checksubsegflag)

    if (b->weighted) {
        // Some vertices may be completed inside the cavity. They must be
        //   detected and added to recovering list.
        // Since every "live" vertex must contain a pointer to a non-dead
        //   tetrahedron, we can check for each vertex this pointer.
        for (i = 0; i < cavetetvertlist->objects; i++) {
            pts = (point*)fastlookup(cavetetvertlist, i);
            decode(point2tet(*pts), *searchtet);
            if (infected(*searchtet)) {
                if (b->weighted) {
                    if (b->verbose > 1) {
                        printf("    Point #%d is non-regular after the insertion of #%d.\n",
                               pointmark(*pts), pointmark(insertpt));
                    }
                    setpointtype(*pts, NREGULARVERTEX);
                    nonregularcount++;
                }
            }
        }
    }

    if (ivf->chkencflag & 1) {
        // Queue all segment outside C(p).
        for (i = 0; i < cavetetseglist->objects; i++) {
            paryseg = (face*)fastlookup(cavetetseglist, i);
            // Skip if it is the split segment.
            if (!sinfected(*paryseg)) {
                enqueuesubface(badsubsegs, paryseg);
            }
        }
        if (splitseg != NULL) {
            // Queue the two new subsegments inside C(p).
            for (i = 0; i < cavesegshlist->objects; i++) {
                paryseg = (face*)fastlookup(cavesegshlist, i);
                enqueuesubface(badsubsegs, paryseg);
            }
        }
    } // if (chkencflag & 1)

    if (ivf->chkencflag & 2) {
        // Queue all subfaces outside C(p).
        for (i = 0; i < cavetetshlist->objects; i++) {
            parysh = (face*)fastlookup(cavetetshlist, i);
            // Skip if it is a split subface.
            if (!sinfected(*parysh)) {
                enqueuesubface(badsubfacs, parysh);
            }
        }
        // Queue all new subfaces inside C(p).
        for (i = 0; i < caveshbdlist->objects; i++) {
            // Get an old subface at edge [a, b].
            parysh = (face*)fastlookup(caveshbdlist, i);
            spivot(*parysh, checksh); // checksh is a new subface [a, b, p].
            // Do not recover a deleted new face (degenerated).
            if (checksh.sh[3] != NULL) {
                enqueuesubface(badsubfacs, &checksh);
            }
        }
    } // if (chkencflag & 2)

    if (ivf->chkencflag & 4) {
        // Queue all new tetrahedra in C(p).
        for (i = 0; i < cavebdrylist->objects; i++) {
            cavetet = (triface*)fastlookup(cavebdrylist, i);
            enqueuetetrahedron(cavetet);
        }
    }

    // C(p) is re-meshed successfully.

    // Delete the old tets in C(p).
    for (i = 0; i < caveoldtetlist->objects; i++) {
        searchtet = (triface*)fastlookup(caveoldtetlist, i);
        if (ishulltet(*searchtet)) {
            hullsize--;
        }
        tetrahedrondealloc(searchtet->tet);
    }

    if (((splitsh != NULL) && (splitsh->sh != NULL)) ||
        ((splitseg != NULL) && (splitseg->sh != NULL))) {
        // Delete the old subfaces in sC(p).
        for (i = 0; i < caveshlist->objects; i++) {
            parysh = (face*)fastlookup(caveshlist, i);
            if (checksubfaceflag) { // if (bowywat == 2) {
                // It is possible that this subface still connects to adjacent
                //   tets which are not in C(p). If so, clear connections in the
                //   adjacent tets at this subface.
                stpivot(*parysh, neightet);
                if (neightet.tet != NULL) {
                    if (neightet.tet[4] != NULL) {
                        // Found an adjacent tet. It must be not in C(p).
                        tsdissolve(neightet);
                        fsymself(neightet);
                        tsdissolve(neightet);
                    }
                }
            }
            shellfacedealloc(subfaces, parysh->sh);
        }
        if ((splitseg != NULL) && (splitseg->sh != NULL)) {
            // Delete the old segment in sC(p).
            shellfacedealloc(subsegs, splitseg->sh);
        }
    }

    if (ivf->lawson) {
        for (i = 0; i < cavebdrylist->objects; i++) {
            searchtet = (triface*)fastlookup(cavebdrylist, i);
            flippush(flipstack, searchtet);
        }
        if (ivf->lawson > 1) {
            for (i = 0; i < cavetetlist->objects; i++) {
                searchtet = (triface*)fastlookup(cavetetlist, i);
                flippush(flipstack, searchtet);
            }
        }
    }

    // Clean the working lists.

    caveoldtetlist->restart();
    cavebdrylist->restart();
    cavetetlist->restart();

    if (checksubsegflag) {
        cavetetseglist->restart();
        caveencseglist->restart();
    }

    if (checksubfaceflag) {
        cavetetshlist->restart();
        caveencshlist->restart();
    }

    if (b->weighted || ivf->smlenflag) {
        cavetetvertlist->restart();
    }

    if (((splitsh != NULL) && (splitsh->sh != NULL)) ||
        ((splitseg != NULL) && (splitseg->sh != NULL))) {
        caveshlist->restart();
        caveshbdlist->restart();
        cavesegshlist->restart();
    }

    return 1; // Point is inserted.
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// insertpoint_abort()    Abort the insertion of a new vertex.               //
//                                                                           //
// The cavity will be restored.  All working lists are cleared.              //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::insertpoint_abort(face* splitseg, insertvertexflags* ivf) {
    triface* cavetet;
    face* parysh;
    int i;

    for (i = 0; i < caveoldtetlist->objects; i++) {
        cavetet = (triface*)fastlookup(caveoldtetlist, i);
        uninfect(*cavetet);
        unmarktest(*cavetet);
    }
    for (i = 0; i < cavebdrylist->objects; i++) {
        cavetet = (triface*)fastlookup(cavebdrylist, i);
        unmarktest(*cavetet);
    }
    cavetetlist->restart();
    cavebdrylist->restart();
    caveoldtetlist->restart();
    cavetetseglist->restart();
    cavetetshlist->restart();
    if (ivf->splitbdflag) {
        if ((splitseg != NULL) && (splitseg->sh != NULL)) {
            sunmarktest(*splitseg);
        }
        for (i = 0; i < caveshlist->objects; i++) {
            parysh = (face*)fastlookup(caveshlist, i);
            sunmarktest(*parysh);
        }
        caveshlist->restart();
        cavesegshlist->restart();
    }
}

////                                                                       ////
////                                                                       ////
//// flip_cxx /////////////////////////////////////////////////////////////////

//// delaunay_cxx /////////////////////////////////////////////////////////////
////                                                                       ////
////                                                                       ////

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// transfernodes()    Read the vertices from the input (tetgenio).           //
//                                                                           //
// Transferring all points from input ('in->pointlist') to TetGen's 'points'.//
// All points are indexed (the first point index is 'in->firstnumber'). Each //
// point's type is initialized as UNUSEDVERTEX. The bounding box (xmax, xmin,//
// ...) and the diameter (longest) of the point set are calculated.          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::transfernodes() {
    point pointloop;
    REAL x, y, z, w;
    int coordindex;
    int attribindex;
    int mtrindex;
    int i, j;

    // Read the points.
    coordindex = 0;
    attribindex = 0;
    mtrindex = 0;
    for (i = 0; i < in->numberofpoints; i++) {
        makepoint(&pointloop, UNUSEDVERTEX);
        // Read the point coordinates.
        x = pointloop[0] = in->pointlist[coordindex++];
        y = pointloop[1] = in->pointlist[coordindex++];
        z = pointloop[2] = in->pointlist[coordindex++];
        // Read the point attributes. (Including point weights.)
        for (j = 0; j < in->numberofpointattributes; j++) {
            pointloop[3 + j] = in->pointattributelist[attribindex++];
        }
        // Read the point metric tensor.
        for (j = 0; j < in->numberofpointmtrs; j++) {
            pointloop[pointmtrindex + j] = in->pointmtrlist[mtrindex++];
        }
        if (b->weighted) { // -w option
            if (in->numberofpointattributes > 0) {
                // The first point attribute is its weight.
                // w = in->pointattributelist[in->numberofpointattributes * i];
                w = pointloop[3];
            } else {
                // No given weight available. Default choose the maximum
                //   absolute value among its coordinates.
                w = fabs(x);
                if (w < fabs(y)) w = fabs(y);
                if (w < fabs(z)) w = fabs(z);
            }
            if (b->weighted_param == 0) {
                pointloop[3] = x * x + y * y + z * z - w; // Weighted DT.
            } else {                                      // -w1 option
                pointloop[3] = w;                         // Regular tetrahedralization.
            }
        }
        // Determine the smallest and largest x, y and z coordinates.
        if (i == 0) {
            xmin = xmax = x;
            ymin = ymax = y;
            zmin = zmax = z;
        } else {
            xmin = (x < xmin) ? x : xmin;
            xmax = (x > xmax) ? x : xmax;
            ymin = (y < ymin) ? y : ymin;
            ymax = (y > ymax) ? y : ymax;
            zmin = (z < zmin) ? z : zmin;
            zmax = (z > zmax) ? z : zmax;
        }
        if (b->psc) {
            // Read the geometry parameters.
            setpointgeomuv(pointloop, 0, in->pointparamlist[i].uv[0]);
            setpointgeomuv(pointloop, 1, in->pointparamlist[i].uv[1]);
            setpointgeomtag(pointloop, in->pointparamlist[i].tag);
            if (in->pointparamlist[i].type == 0) {
                setpointtype(pointloop, RIDGEVERTEX);
            } else if (in->pointparamlist[i].type == 1) {
                setpointtype(pointloop, FREESEGVERTEX);
            } else if (in->pointparamlist[i].type == 2) {
                setpointtype(pointloop, FREEFACETVERTEX);
            } else if (in->pointparamlist[i].type == 3) {
                setpointtype(pointloop, FREEVOLVERTEX);
            }
        }
    }

    // 'longest' is the largest possible edge length formed by input vertices.
    x = xmax - xmin;
    y = ymax - ymin;
    z = zmax - zmin;
    longest = sqrt(x * x + y * y + z * z);
    if (longest == 0.0) {
        printf("Error:  The point set is trivial.\n");
        terminatetetgen(this, 10);
    }
    // Two identical points are distinguished by 'minedgelength'.
    minedgelength = longest * b->epsilon;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// hilbert_init()    Initialize the Gray code permutation table.             //
//                                                                           //
// The table 'transgc' has 8 x 3 x 8 entries. It contains all possible Gray  //
// code sequences traveled by the 1st order Hilbert curve in 3 dimensions.   //
// The first column is the Gray code of the entry point of the curve, and    //
// the second column is the direction (0, 1, or 2, 0 means the x-axis) where //
// the exit point of curve lies.                                             //
//                                                                           //
// The table 'tsb1mod3' contains the numbers of trailing set '1' bits of the //
// indices from 0 to 7, modulo by '3'. The code for generating this table is //
// from: http://graphics.stanford.edu/~seander/bithacks.html.                //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::hilbert_init(int n) {
    int gc[8], N, mask, travel_bit;
    int e, d, f, k, g;
    int v, c;
    int i;

    N = (n == 2) ? 4 : 8;
    mask = (n == 2) ? 3 : 7;

    // Generate the Gray code sequence.
    for (i = 0; i < N; i++) {
        gc[i] = i ^ (i >> 1);
    }

    for (e = 0; e < N; e++) {
        for (d = 0; d < n; d++) {
            // Calculate the end point (f).
            f = e ^ (1 << d); // Toggle the d-th bit of 'e'.
            // travel_bit = 2**p, the bit we want to travel.
            travel_bit = e ^ f;
            for (i = 0; i < N; i++) {
                // // Rotate gc[i] left by (p + 1) % n bits.
                k = gc[i] * (travel_bit * 2);
                g = ((k | (k / N)) & mask);
                // Calculate the permuted Gray code by xor with the start point (e).
                transgc[e][d][i] = (g ^ e);
            }
        } // d
    }     // e

    // Count the consecutive '1' bits (trailing) on the right.
    tsb1mod3[0] = 0;
    for (i = 1; i < N; i++) {
        v = ~i;                 // Count the 0s.
        v = (v ^ (v - 1)) >> 1; // Set v's trailing 0s to 1s and zero rest
        for (c = 0; v; c++) {
            v >>= 1;
        }
        tsb1mod3[i] = c % n;
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// hilbert_sort3()    Sort points using the 3d Hilbert curve.                //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::hilbert_split(point* vertexarray, int arraysize, int gc0, int gc1, REAL bxmin,
                              REAL bxmax, REAL bymin, REAL bymax, REAL bzmin, REAL bzmax) {
    point swapvert;
    int axis, d;
    REAL split;
    int i, j;

    // Find the current splitting axis. 'axis' is a value 0, or 1, or 2, which
    //   correspoding to x-, or y- or z-axis.
    axis = (gc0 ^ gc1) >> 1;

    // Calulate the split position along the axis.
    if (axis == 0) {
        split = 0.5 * (bxmin + bxmax);
    } else if (axis == 1) {
        split = 0.5 * (bymin + bymax);
    } else { // == 2
        split = 0.5 * (bzmin + bzmax);
    }

    // Find the direction (+1 or -1) of the axis. If 'd' is +1, the direction
    //   of the axis is to the positive of the axis, otherwise, it is -1.
    d = ((gc0 & (1 << axis)) == 0) ? 1 : -1;

    // Partition the vertices into left- and right-arrays such that left points
    //   have Hilbert indices lower than the right points.
    i = 0;
    j = arraysize - 1;

    // Partition the vertices into left- and right-arrays.
    if (d > 0) {
        do {
            for (; i < arraysize; i++) {
                if (vertexarray[i][axis] >= split) break;
            }
            for (; j >= 0; j--) {
                if (vertexarray[j][axis] < split) break;
            }
            // Is the partition finished?
            if (i == (j + 1)) break;
            // Swap i-th and j-th vertices.
            swapvert = vertexarray[i];
            vertexarray[i] = vertexarray[j];
            vertexarray[j] = swapvert;
            // Continue patitioning the array;
        } while (true);
    } else {
        do {
            for (; i < arraysize; i++) {
                if (vertexarray[i][axis] <= split) break;
            }
            for (; j >= 0; j--) {
                if (vertexarray[j][axis] > split) break;
            }
            // Is the partition finished?
            if (i == (j + 1)) break;
            // Swap i-th and j-th vertices.
            swapvert = vertexarray[i];
            vertexarray[i] = vertexarray[j];
            vertexarray[j] = swapvert;
            // Continue patitioning the array;
        } while (true);
    }

    return i;
}

void tetgenmesh::hilbert_sort3(point* vertexarray, int arraysize, int e, int d, REAL bxmin,
                               REAL bxmax, REAL bymin, REAL bymax, REAL bzmin, REAL bzmax,
                               int depth) {
    REAL x1, x2, y1, y2, z1, z2;
    int p[9], w, e_w, d_w, k, ei, di;
    int n = 3, mask = 7;

    p[0] = 0;
    p[8] = arraysize;

    // Sort the points according to the 1st order Hilbert curve in 3d.
    p[4] = hilbert_split(vertexarray, p[8], transgc[e][d][3], transgc[e][d][4], bxmin, bxmax, bymin,
                         bymax, bzmin, bzmax);
    p[2] = hilbert_split(vertexarray, p[4], transgc[e][d][1], transgc[e][d][2], bxmin, bxmax, bymin,
                         bymax, bzmin, bzmax);
    p[1] = hilbert_split(vertexarray, p[2], transgc[e][d][0], transgc[e][d][1], bxmin, bxmax, bymin,
                         bymax, bzmin, bzmax);
    p[3] = hilbert_split(&(vertexarray[p[2]]), p[4] - p[2], transgc[e][d][2], transgc[e][d][3],
                         bxmin, bxmax, bymin, bymax, bzmin, bzmax) +
           p[2];
    p[6] = hilbert_split(&(vertexarray[p[4]]), p[8] - p[4], transgc[e][d][5], transgc[e][d][6],
                         bxmin, bxmax, bymin, bymax, bzmin, bzmax) +
           p[4];
    p[5] = hilbert_split(&(vertexarray[p[4]]), p[6] - p[4], transgc[e][d][4], transgc[e][d][5],
                         bxmin, bxmax, bymin, bymax, bzmin, bzmax) +
           p[4];
    p[7] = hilbert_split(&(vertexarray[p[6]]), p[8] - p[6], transgc[e][d][6], transgc[e][d][7],
                         bxmin, bxmax, bymin, bymax, bzmin, bzmax) +
           p[6];

    if (b->hilbert_order > 0) {
        // A maximum order is prescribed.
        if ((depth + 1) == b->hilbert_order) {
            // The maximum prescribed order is reached.
            return;
        }
    }

    // Recursively sort the points in sub-boxes.
    for (w = 0; w < 8; w++) {
        // w is the local Hilbert index (NOT Gray code).
        // Sort into the sub-box either there are more than 2 points in it, or
        //   the prescribed order of the curve is not reached yet.
        // if ((p[w+1] - p[w] > b->hilbert_limit) || (b->hilbert_order > 0)) {
        if ((p[w + 1] - p[w]) > b->hilbert_limit) {
            // Calculcate the start point (ei) of the curve in this sub-box.
            //   update e = e ^ (e(w) left_rotate (d+1)).
            if (w == 0) {
                e_w = 0;
            } else {
                //   calculate e(w) = gc(2 * floor((w - 1) / 2)).
                k = 2 * ((w - 1) / 2);
                e_w = k ^ (k >> 1); // = gc(k).
            }
            k = e_w;
            e_w = ((k << (d + 1)) & mask) | ((k >> (n - d - 1)) & mask);
            ei = e ^ e_w;
            // Calulcate the direction (di) of the curve in this sub-box.
            //   update d = (d + d(w) + 1) % n
            if (w == 0) {
                d_w = 0;
            } else {
                d_w = ((w % 2) == 0) ? tsb1mod3[w - 1] : tsb1mod3[w];
            }
            di = (d + d_w + 1) % n;
            // Calculate the bounding box of the sub-box.
            if (transgc[e][d][w] & 1) { // x-axis
                x1 = 0.5 * (bxmin + bxmax);
                x2 = bxmax;
            } else {
                x1 = bxmin;
                x2 = 0.5 * (bxmin + bxmax);
            }
            if (transgc[e][d][w] & 2) { // y-axis
                y1 = 0.5 * (bymin + bymax);
                y2 = bymax;
            } else {
                y1 = bymin;
                y2 = 0.5 * (bymin + bymax);
            }
            if (transgc[e][d][w] & 4) { // z-axis
                z1 = 0.5 * (bzmin + bzmax);
                z2 = bzmax;
            } else {
                z1 = bzmin;
                z2 = 0.5 * (bzmin + bzmax);
            }
            hilbert_sort3(&(vertexarray[p[w]]), p[w + 1] - p[w], ei, di, x1, x2, y1, y2, z1, z2,
                          depth + 1);
        } // if (p[w+1] - p[w] > 1)
    }     // w
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// brio_multiscale_sort()    Sort the points using BRIO and Hilbert curve.   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::brio_multiscale_sort(point* vertexarray, int arraysize, int threshold, REAL ratio,
                                      int* depth) {
    int middle;

    middle = 0;
    if (arraysize >= threshold) {
        (*depth)++;
        middle = arraysize * ratio;
        brio_multiscale_sort(vertexarray, middle, threshold, ratio, depth);
    }
    // Sort the right-array (rnd-th round) using the Hilbert curve.
    hilbert_sort3(&(vertexarray[middle]), arraysize - middle, 0, 0, // e, d
                  xmin, xmax, ymin, ymax, zmin, zmax, 0);           // depth.
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// randomnation()    Generate a random number between 0 and 'choices' - 1.   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

unsigned long tetgenmesh::randomnation(unsigned int choices) {
    unsigned long newrandom;

    if (choices >= 714025l) {
        newrandom = (randomseed * 1366l + 150889l) % 714025l;
        randomseed = (newrandom * 1366l + 150889l) % 714025l;
        newrandom = newrandom * (choices / 714025l) + randomseed;
        if (newrandom >= choices) {
            return newrandom - choices;
        } else {
            return newrandom;
        }
    } else {
        randomseed = (randomseed * 1366l + 150889l) % 714025l;
        return randomseed % choices;
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// randomsample()    Randomly sample the tetrahedra for point loation.       //
//                                                                           //
// Searching begins from one of handles:  the input 'searchtet', a recently  //
// encountered tetrahedron 'recenttet',  or from one chosen from a random    //
// sample.  The choice is made by determining which one's origin is closest  //
// to the point we are searching for.                                        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::randomsample(point searchpt, triface* searchtet) {
    tetrahedron *firsttet, *tetptr;
    point torg;
    void** sampleblock;
    uintptr_t alignptr;
    long sampleblocks, samplesperblock, samplenum;
    long tetblocks, i, j;
    REAL searchdist, dist;

    if (b->verbose > 2) {
        printf("      Random sampling tetrahedra for searching point %d.\n", pointmark(searchpt));
    }

    if (!nonconvex) {
        if (searchtet->tet == NULL) {
            // A null tet. Choose the recenttet as the starting tet.
            *searchtet = recenttet;
        }

        // 'searchtet' should be a valid tetrahedron. Choose the base face
        //   whose vertices must not be 'dummypoint'.
        searchtet->ver = 3;
        // Record the distance from its origin to the searching point.
        torg = org(*searchtet);
        searchdist = (searchpt[0] - torg[0]) * (searchpt[0] - torg[0]) +
                     (searchpt[1] - torg[1]) * (searchpt[1] - torg[1]) +
                     (searchpt[2] - torg[2]) * (searchpt[2] - torg[2]);

        // If a recently encountered tetrahedron has been recorded and has not
        //   been deallocated, test it as a good starting point.
        if (recenttet.tet != searchtet->tet) {
            recenttet.ver = 3;
            torg = org(recenttet);
            dist = (searchpt[0] - torg[0]) * (searchpt[0] - torg[0]) +
                   (searchpt[1] - torg[1]) * (searchpt[1] - torg[1]) +
                   (searchpt[2] - torg[2]) * (searchpt[2] - torg[2]);
            if (dist < searchdist) {
                *searchtet = recenttet;
                searchdist = dist;
            }
        }
    } else {
        // The mesh is non-convex. Do not use 'recenttet'.
        searchdist = longest;
    }

    // Select "good" candidate using k random samples, taking the closest one.
    //   The number of random samples taken is proportional to the fourth root
    //   of the number of tetrahedra in the mesh.
    while (samples * samples * samples * samples < tetrahedrons->items) {
        samples++;
    }
    // Find how much blocks in current tet pool.
    tetblocks = (tetrahedrons->maxitems + b->tetrahedraperblock - 1) / b->tetrahedraperblock;
    // Find the average samples per block. Each block at least have 1 sample.
    samplesperblock = 1 + (samples / tetblocks);
    sampleblocks = samples / samplesperblock;
    sampleblock = tetrahedrons->firstblock;
    for (i = 0; i < sampleblocks; i++) {
        alignptr = (uintptr_t)(sampleblock + 1);
        firsttet = (tetrahedron*)(alignptr + (uintptr_t)tetrahedrons->alignbytes -
                                  (alignptr % (uintptr_t)tetrahedrons->alignbytes));
        for (j = 0; j < samplesperblock; j++) {
            if (i == tetblocks - 1) {
                // This is the last block.
                samplenum =
                    randomnation((int)(tetrahedrons->maxitems - (i * b->tetrahedraperblock)));
            } else {
                samplenum = randomnation(b->tetrahedraperblock);
            }
            tetptr = (tetrahedron*)(firsttet + (samplenum * tetrahedrons->itemwords));
            torg = (point)tetptr[4];
            if (torg != (point)NULL) {
                dist = (searchpt[0] - torg[0]) * (searchpt[0] - torg[0]) +
                       (searchpt[1] - torg[1]) * (searchpt[1] - torg[1]) +
                       (searchpt[2] - torg[2]) * (searchpt[2] - torg[2]);
                if (dist < searchdist) {
                    searchtet->tet = tetptr;
                    searchtet->ver = 11; // torg = org(t);
                    searchdist = dist;
                }
            } else {
                // A dead tet. Re-sample it.
                if (i != tetblocks - 1) j--;
            }
        }
        sampleblock = (void**)*sampleblock;
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// locate()    Find a tetrahedron containing a given point.                  //
//                                                                           //
// Begins its search from 'searchtet', assume there is a line segment L from //
// a vertex of 'searchtet' to the query point 'searchpt', and simply walk    //
// towards 'searchpt' by traversing all faces intersected by L.              //
//                                                                           //
// On completion, 'searchtet' is a tetrahedron that contains 'searchpt'. The //
// returned value indicates one of the following cases:                      //
//   - ONVERTEX, the search point lies on the origin of 'searchtet'.         //
//   - ONEDGE, the search point lies on an edge of 'searchtet'.              //
//   - ONFACE, the search point lies on a face of 'searchtet'.               //
//   - INTET, the search point lies in the interior of 'searchtet'.          //
//   - OUTSIDE, the search point lies outside the mesh. 'searchtet' is a     //
//              hull face which is visible by the search point.              //
//                                                                           //
// WARNING: This routine is designed for convex triangulations, and will not //
// generally work after the holes and concavities have been carved.          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

enum tetgenmesh::locateresult tetgenmesh::locate(point searchpt, triface* searchtet,
                                                 int chkencflag) {
    point torg, tdest, tapex, toppo;
    enum { ORGMOVE, DESTMOVE, APEXMOVE } nextmove;
    REAL ori, oriorg, oridest, oriapex;
    enum locateresult loc = OUTSIDE;
    int t1ver;
    int s;

    torg = tdest = tapex = toppo = NULL;

    if (searchtet->tet == NULL) {
        // A null tet. Choose the recenttet as the starting tet.
        searchtet->tet = recenttet.tet;
    }

    // Check if we are in the outside of the convex hull.
    if (ishulltet(*searchtet)) {
        // Get its adjacent tet (inside the hull).
        searchtet->ver = 3;
        fsymself(*searchtet);
    }

    // Let searchtet be the face such that 'searchpt' lies above to it.
    for (searchtet->ver = 0; searchtet->ver < 4; searchtet->ver++) {
        torg = org(*searchtet);
        tdest = dest(*searchtet);
        tapex = apex(*searchtet);
        ori = orient3d(torg, tdest, tapex, searchpt);
        if (ori < 0.0) break;
    }
    if (searchtet->ver == 4) {
        terminatetetgen(this, 2);
    }

    // Walk through tetrahedra to locate the point.
    while (true) {

        toppo = oppo(*searchtet);

        // Check if the vertex is we seek.
        if (toppo == searchpt) {
            // Adjust the origin of searchtet to be searchpt.
            esymself(*searchtet);
            eprevself(*searchtet);
            loc = ONVERTEX; // return ONVERTEX;
            break;
        }

        // We enter from one of serarchtet's faces, which face do we exit?
        oriorg = orient3d(tdest, tapex, toppo, searchpt);
        oridest = orient3d(tapex, torg, toppo, searchpt);
        oriapex = orient3d(torg, tdest, toppo, searchpt);

        // Now decide which face to move. It is possible there are more than one
        //   faces are viable moves. If so, randomly choose one.
        if (oriorg < 0) {
            if (oridest < 0) {
                if (oriapex < 0) {
                    // All three faces are possible.
                    s = randomnation(3); // 's' is in {0,1,2}.
                    if (s == 0) {
                        nextmove = ORGMOVE;
                    } else if (s == 1) {
                        nextmove = DESTMOVE;
                    } else {
                        nextmove = APEXMOVE;
                    }
                } else {
                    // Two faces, opposite to origin and destination, are viable.
                    // s = randomnation(2); // 's' is in {0,1}.
                    if (randomnation(2)) {
                        nextmove = ORGMOVE;
                    } else {
                        nextmove = DESTMOVE;
                    }
                }
            } else {
                if (oriapex < 0) {
                    // Two faces, opposite to origin and apex, are viable.
                    // s = randomnation(2); // 's' is in {0,1}.
                    if (randomnation(2)) {
                        nextmove = ORGMOVE;
                    } else {
                        nextmove = APEXMOVE;
                    }
                } else {
                    // Only the face opposite to origin is viable.
                    nextmove = ORGMOVE;
                }
            }
        } else {
            if (oridest < 0) {
                if (oriapex < 0) {
                    // Two faces, opposite to destination and apex, are viable.
                    // s = randomnation(2); // 's' is in {0,1}.
                    if (randomnation(2)) {
                        nextmove = DESTMOVE;
                    } else {
                        nextmove = APEXMOVE;
                    }
                } else {
                    // Only the face opposite to destination is viable.
                    nextmove = DESTMOVE;
                }
            } else {
                if (oriapex < 0) {
                    // Only the face opposite to apex is viable.
                    nextmove = APEXMOVE;
                } else {
                    // The point we seek must be on the boundary of or inside this
                    //   tetrahedron. Check for boundary cases.
                    if (oriorg == 0) {
                        // Go to the face opposite to origin.
                        enextesymself(*searchtet);
                        if (oridest == 0) {
                            eprevself(*searchtet); // edge oppo->apex
                            if (oriapex == 0) {
                                // oppo is duplicated with p.
                                loc = ONVERTEX; // return ONVERTEX;
                                break;
                            }
                            loc = ONEDGE; // return ONEDGE;
                            break;
                        }
                        if (oriapex == 0) {
                            enextself(*searchtet); // edge dest->oppo
                            loc = ONEDGE;          // return ONEDGE;
                            break;
                        }
                        loc = ONFACE; // return ONFACE;
                        break;
                    }
                    if (oridest == 0) {
                        // Go to the face opposite to destination.
                        eprevesymself(*searchtet);
                        if (oriapex == 0) {
                            eprevself(*searchtet); // edge oppo->org
                            loc = ONEDGE;          // return ONEDGE;
                            break;
                        }
                        loc = ONFACE; // return ONFACE;
                        break;
                    }
                    if (oriapex == 0) {
                        // Go to the face opposite to apex
                        esymself(*searchtet);
                        loc = ONFACE; // return ONFACE;
                        break;
                    }
                    loc = INTETRAHEDRON; // return INTETRAHEDRON;
                    break;
                }
            }
        }

        // Move to the selected face.
        if (nextmove == ORGMOVE) {
            enextesymself(*searchtet);
        } else if (nextmove == DESTMOVE) {
            eprevesymself(*searchtet);
        } else {
            esymself(*searchtet);
        }
        if (chkencflag) {
            // Check if we are walking across a subface.
            if (issubface(*searchtet)) {
                loc = ENCSUBFACE;
                break;
            }
        }
        // Move to the adjacent tetrahedron (maybe a hull tetrahedron).
        fsymself(*searchtet);
        if (oppo(*searchtet) == dummypoint) {
            loc = OUTSIDE; // return OUTSIDE;
            break;
        }

        // Retreat the three vertices of the base face.
        torg = org(*searchtet);
        tdest = dest(*searchtet);
        tapex = apex(*searchtet);

    } // while (true)

    return loc;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// flippush()    Push a face (possibly will be flipped) into flipstack.      //
//                                                                           //
// The face is marked. The flag is used to check the validity of the face on //
// its popup.  Some other flips may change it already.                       //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::flippush(badface*& fstack, triface* flipface) {
    if (!facemarked(*flipface)) {
        badface* newflipface = (badface*)flippool->alloc();
        newflipface->tt = *flipface;
        markface(newflipface->tt);
        // Push this face into stack.
        newflipface->nextitem = fstack;
        fstack = newflipface;
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// incrementalflip()    Incrementally flipping to construct DT.              //
//                                                                           //
// Faces need to be checked for flipping are already queued in 'flipstack'.  //
// Return the total number of performed flips.                               //
//                                                                           //
// Comment:  This routine should be only used in the incremental Delaunay    //
// construction.  In other cases, lawsonflip3d() should be used.             //
//                                                                           //
// If the new point lies outside of the convex hull ('hullflag' is set). The //
// incremental flip algorithm still works as usual.  However, we must ensure //
// that every flip (2-to-3 or 3-to-2) does not create a duplicated (existing)//
// edge or face. Otherwise, the underlying space of the triangulation becomes//
// non-manifold and it is not possible to flip further.                      //
// Thanks to Joerg Rambau and Frank Lutz for helping in this issue.          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::incrementalflip(point newpt, int hullflag, flipconstraints* fc) {
    badface* popface;
    triface fliptets[5], *parytet;
    point *pts, *parypt, pe;
    REAL sign, ori;
    int flipcount = 0;
    int t1ver;
    int i;

    if (b->verbose > 2) {
        printf("      Lawson flip (%ld faces).\n", flippool->items);
    }

    if (hullflag) {
        // 'newpt' lies in the outside of the convex hull.
        // Mark all hull vertices which are connecting to it.
        popface = flipstack;
        while (popface != NULL) {
            pts = (point*)popface->tt.tet;
            for (i = 4; i < 8; i++) {
                if ((pts[i] != newpt) && (pts[i] != dummypoint)) {
                    if (!pinfected(pts[i])) {
                        pinfect(pts[i]);
                        cavetetvertlist->newindex((void**)&parypt);
                        *parypt = pts[i];
                    }
                }
            }
            popface = popface->nextitem;
        }
    }

    // Loop until the queue is empty.
    while (flipstack != NULL) {

        // Pop a face from the stack.
        popface = flipstack;
        fliptets[0] = popface->tt;
        flipstack = flipstack->nextitem; // The next top item in stack.
        flippool->dealloc((void*)popface);

        // Skip it if it is a dead tet (destroyed by previous flips).
        if (isdeadtet(fliptets[0])) continue;
        // Skip it if it is not the same tet as we saved.
        if (!facemarked(fliptets[0])) continue;

        unmarkface(fliptets[0]);

        if ((point)fliptets[0].tet[7] == dummypoint) {
            // It must be a hull edge.
            fliptets[0].ver = epivot[fliptets[0].ver];
            // A hull edge. The current convex hull may be enlarged.
            fsym(fliptets[0], fliptets[1]);
            pts = (point*)fliptets[1].tet;
            ori = orient3d(pts[4], pts[5], pts[6], newpt);
            if (ori < 0) {
                // Visible. The convex hull will be enlarged.
                // Decide which flip (2-to-3, 3-to-2, or 4-to-1) to use.
                // Check if the tet [a,c,e,d] or [c,b,e,d] exists.
                enext(fliptets[1], fliptets[2]);
                eprev(fliptets[1], fliptets[3]);
                fnextself(fliptets[2]); // [a,c,e,*]
                fnextself(fliptets[3]); // [c,b,e,*]
                if (oppo(fliptets[2]) == newpt) {
                    if (oppo(fliptets[3]) == newpt) {
                        // Both tets exist! A 4-to-1 flip is found.
                        terminatetetgen(this, 2); // Report a bug.
                    } else {
                        esym(fliptets[2], fliptets[0]);
                        fnext(fliptets[0], fliptets[1]);
                        fnext(fliptets[1], fliptets[2]);
                        // Perform a 3-to-2 flip. Replace edge [c,a] by face [d,e,b].
                        // This corresponds to my standard labels, where edge [e,d] is
                        //   repalced by face [a,b,c], and a is the new vertex.
                        //   [0] [c,a,d,e] (d = newpt)
                        //   [1] [c,a,e,b] (c = dummypoint)
                        //   [2] [c,a,b,d]
                        flip32(fliptets, 1, fc);
                    }
                } else {
                    if (oppo(fliptets[3]) == newpt) {
                        fnext(fliptets[3], fliptets[0]);
                        fnext(fliptets[0], fliptets[1]);
                        fnext(fliptets[1], fliptets[2]);
                        // Perform a 3-to-2 flip. Replace edge [c,b] by face [d,a,e].
                        //   [0] [c,b,d,a] (d = newpt)
                        //   [1] [c,b,a,e] (c = dummypoint)
                        //   [2] [c,b,e,d]
                        flip32(fliptets, 1, fc);
                    } else {
                        if (hullflag) {
                            // Reject this flip if pe is already marked.
                            pe = oppo(fliptets[1]);
                            if (!pinfected(pe)) {
                                pinfect(pe);
                                cavetetvertlist->newindex((void**)&parypt);
                                *parypt = pe;
                                // Perform a 2-to-3 flip.
                                flip23(fliptets, 1, fc);
                            } else {
                                // Reject this flip.
                                flipcount--;
                            }
                        } else {
                            // Perform a 2-to-3 flip. Replace face [a,b,c] by edge [e,d].
                            //   [0] [a,b,c,d], d = newpt.
                            //   [1] [b,a,c,e], c = dummypoint.
                            flip23(fliptets, 1, fc);
                        }
                    }
                }
                flipcount++;
            }
            continue;
        } // if (dummypoint)

        fsym(fliptets[0], fliptets[1]);
        if ((point)fliptets[1].tet[7] == dummypoint) {
            // A hull face is locally Delaunay.
            continue;
        }
        // Check if the adjacent tet has already been tested.
        if (marktested(fliptets[1])) {
            // It has been tested and it is Delaunay.
            continue;
        }

        // Test whether the face is locally Delaunay or not.
        pts = (point*)fliptets[1].tet;
        if (b->weighted) {
            sign = orient4d_s(pts[4], pts[5], pts[6], pts[7], newpt, pts[4][3], pts[5][3],
                              pts[6][3], pts[7][3], newpt[3]);
        } else {
            sign = insphere_s(pts[4], pts[5], pts[6], pts[7], newpt);
        }

        if (sign < 0) {
            point pd = newpt;
            point pe = oppo(fliptets[1]);
            // Check the convexity of its three edges. Stop checking either a
            //   locally non-convex edge (ori < 0) or a flat edge (ori = 0) is
            //   encountered, and 'fliptet' represents that edge.
            for (i = 0; i < 3; i++) {
                ori = orient3d(org(fliptets[0]), dest(fliptets[0]), pd, pe);
                if (ori <= 0) break;
                enextself(fliptets[0]);
            }
            if (ori > 0) {
                // A 2-to-3 flip is found.
                //   [0] [a,b,c,d],
                //   [1] [b,a,c,e]. no dummypoint.
                flip23(fliptets, 0, fc);
                flipcount++;
            } else { // ori <= 0
                // The edge ('fliptets[0]' = [a',b',c',d]) is non-convex or flat,
                //   where the edge [a',b'] is one of [a,b], [b,c], and [c,a].
                // Check if there are three or four tets sharing at this edge.
                esymself(fliptets[0]); // [b,a,d,c]
                for (i = 0; i < 3; i++) {
                    fnext(fliptets[i], fliptets[i + 1]);
                }
                if (fliptets[3].tet == fliptets[0].tet) {
                    // A 3-to-2 flip is found. (No hull tet.)
                    flip32(fliptets, 0, fc);
                    flipcount++;
                } else {
                    // There are more than 3 tets at this edge.
                    fnext(fliptets[3], fliptets[4]);
                    if (fliptets[4].tet == fliptets[0].tet) {
                        if (ori == 0) {
                            // A 4-to-4 flip is found. (Two hull tets may be involved.)
                            // Current tets in 'fliptets':
                            //   [0] [b,a,d,c] (d may be newpt)
                            //   [1] [b,a,c,e]
                            //   [2] [b,a,e,f] (f may be dummypoint)
                            //   [3] [b,a,f,d]
                            esymself(fliptets[0]); // [a,b,c,d]
                            // A 2-to-3 flip replaces face [a,b,c] by edge [e,d].
                            //   This creates a degenerate tet [e,d,a,b] (tmpfliptets[0]).
                            //   It will be removed by the followed 3-to-2 flip.
                            flip23(fliptets, 0, fc); // No hull tet.
                            fnext(fliptets[3], fliptets[1]);
                            fnext(fliptets[1], fliptets[2]);
                            // Current tets in 'fliptets':
                            //   [0] [...]
                            //   [1] [b,a,d,e] (degenerated, d may be new point).
                            //   [2] [b,a,e,f] (f may be dummypoint)
                            //   [3] [b,a,f,d]
                            // A 3-to-2 flip replaces edge [b,a] by face [d,e,f].
                            //   Hull tets may be involved (f may be dummypoint).
                            flip32(&(fliptets[1]), (apex(fliptets[3]) == dummypoint), fc);
                            flipcount++;
                        }
                    }
                }
            } // ori
        } else {
            // The adjacent tet is Delaunay. Mark it to avoid testing it again.
            marktest(fliptets[1]);
            // Save it for unmarking it later.
            cavebdrylist->newindex((void**)&parytet);
            *parytet = fliptets[1];
        }

    } // while (flipstack)

    // Unmark saved tetrahedra.
    for (i = 0; i < cavebdrylist->objects; i++) {
        parytet = (triface*)fastlookup(cavebdrylist, i);
        unmarktest(*parytet);
    }
    cavebdrylist->restart();

    if (hullflag) {
        // Unmark infected vertices.
        for (i = 0; i < cavetetvertlist->objects; i++) {
            parypt = (point*)fastlookup(cavetetvertlist, i);
            puninfect(*parypt);
        }
        cavetetvertlist->restart();
    }

    return flipcount;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// initialdelaunay()    Create an initial Delaunay tetrahedralization.       //
//                                                                           //
// The tetrahedralization contains only one tetrahedron abcd, and four hull  //
// tetrahedra. The points pa, pb, pc, and pd must be linearly independent.   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::initialdelaunay(point pa, point pb, point pc, point pd) {
    triface firsttet, tetopa, tetopb, tetopc, tetopd;
    triface worktet, worktet1;

    if (b->verbose > 2) {
        printf("      Create init tet (%d, %d, %d, %d)\n", pointmark(pa), pointmark(pb),
               pointmark(pc), pointmark(pd));
    }

    // Create the first tetrahedron.
    maketetrahedron(&firsttet);
    setvertices(firsttet, pa, pb, pc, pd);
    // Create four hull tetrahedra.
    maketetrahedron(&tetopa);
    setvertices(tetopa, pb, pc, pd, dummypoint);
    maketetrahedron(&tetopb);
    setvertices(tetopb, pc, pa, pd, dummypoint);
    maketetrahedron(&tetopc);
    setvertices(tetopc, pa, pb, pd, dummypoint);
    maketetrahedron(&tetopd);
    setvertices(tetopd, pb, pa, pc, dummypoint);
    hullsize += 4;

    // Connect hull tetrahedra to firsttet (at four faces of firsttet).
    bond(firsttet, tetopd);
    esym(firsttet, worktet);
    bond(worktet, tetopc); // ab
    enextesym(firsttet, worktet);
    bond(worktet, tetopa); // bc
    eprevesym(firsttet, worktet);
    bond(worktet, tetopb); // ca

    // Connect hull tetrahedra together (at six edges of firsttet).
    esym(tetopc, worktet);
    esym(tetopd, worktet1);
    bond(worktet, worktet1); // ab
    esym(tetopa, worktet);
    eprevesym(tetopd, worktet1);
    bond(worktet, worktet1); // bc
    esym(tetopb, worktet);
    enextesym(tetopd, worktet1);
    bond(worktet, worktet1); // ca
    eprevesym(tetopc, worktet);
    enextesym(tetopb, worktet1);
    bond(worktet, worktet1); // da
    eprevesym(tetopa, worktet);
    enextesym(tetopc, worktet1);
    bond(worktet, worktet1); // db
    eprevesym(tetopb, worktet);
    enextesym(tetopa, worktet1);
    bond(worktet, worktet1); // dc

    // Set the vertex type.
    if (pointtype(pa) == UNUSEDVERTEX) {
        setpointtype(pa, VOLVERTEX);
    }
    if (pointtype(pb) == UNUSEDVERTEX) {
        setpointtype(pb, VOLVERTEX);
    }
    if (pointtype(pc) == UNUSEDVERTEX) {
        setpointtype(pc, VOLVERTEX);
    }
    if (pointtype(pd) == UNUSEDVERTEX) {
        setpointtype(pd, VOLVERTEX);
    }

    setpoint2tet(pa, encode(firsttet));
    setpoint2tet(pb, encode(firsttet));
    setpoint2tet(pc, encode(firsttet));
    setpoint2tet(pd, encode(firsttet));

    // Remember the first tetrahedron.
    recenttet = firsttet;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// incrementaldelaunay()    Create a Delaunay tetrahedralization by          //
//                          the incremental approach.                        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::incrementaldelaunay(clock_t& tv) {
    triface searchtet;
    point *permutarray, swapvertex;
    REAL v1[3], v2[3], n[3];
    REAL bboxsize, bboxsize2, bboxsize3, ori;
    int randindex;
    int ngroup = 0;
    int i, j;

    if (!b->quiet) {
        printf("Delaunizing vertices...\n");
    }

    // Form a random permuation (uniformly at random) of the set of vertices.
    permutarray = new point[in->numberofpoints];
    points->traversalinit();

    if (b->no_sort) {
        if (b->verbose) {
            printf("  Using the input order.\n");
        }
        for (i = 0; i < in->numberofpoints; i++) {
            permutarray[i] = (point)points->traverse();
        }
    } else {
        if (b->verbose) {
            printf("  Permuting vertices.\n");
        }
        srand(in->numberofpoints);
        for (i = 0; i < in->numberofpoints; i++) {
            randindex = rand() % (i + 1); // randomnation(i + 1);
            permutarray[i] = permutarray[randindex];
            permutarray[randindex] = (point)points->traverse();
        }
        if (b->brio_hilbert) { // -b option
            if (b->verbose) {
                printf("  Sorting vertices.\n");
            }
            hilbert_init(in->mesh_dim);
            brio_multiscale_sort(permutarray, in->numberofpoints, b->brio_threshold, b->brio_ratio,
                                 &ngroup);
        }
    }

    tv = clock(); // Remember the time for sorting points.

    // Calculate the diagonal size of its bounding box.
    bboxsize = sqrt(norm2(xmax - xmin, ymax - ymin, zmax - zmin));
    bboxsize2 = bboxsize * bboxsize;
    bboxsize3 = bboxsize2 * bboxsize;

    // Make sure the second vertex is not identical with the first one.
    i = 1;
    while ((distance(permutarray[0], permutarray[i]) / bboxsize) < b->epsilon) {
        i++;
        if (i == in->numberofpoints - 1) {
            printf("Exception:  All vertices are (nearly) identical (Tol = %g).\n", b->epsilon);
            terminatetetgen(this, 10);
        }
    }
    if (i > 1) {
        // Swap to move the non-identical vertex from index i to index 1.
        swapvertex = permutarray[i];
        permutarray[i] = permutarray[1];
        permutarray[1] = swapvertex;
    }

    // Make sure the third vertex is not collinear with the first two.
    // Acknowledgement:  Thanks Jan Pomplun for his correction by using
    //   epsilon^2 and epsilon^3 (instead of epsilon). 2013-08-15.
    i = 2;
    for (j = 0; j < 3; j++) {
        v1[j] = permutarray[1][j] - permutarray[0][j];
        v2[j] = permutarray[i][j] - permutarray[0][j];
    }
    cross(v1, v2, n);
    while ((sqrt(norm2(n[0], n[1], n[2])) / bboxsize2) < b->epsilon) {
        i++;
        if (i == in->numberofpoints - 1) {
            printf("Exception:  All vertices are (nearly) collinear (Tol = %g).\n", b->epsilon);
            terminatetetgen(this, 10);
        }
        for (j = 0; j < 3; j++) {
            v2[j] = permutarray[i][j] - permutarray[0][j];
        }
        cross(v1, v2, n);
    }
    if (i > 2) {
        // Swap to move the non-identical vertex from index i to index 1.
        swapvertex = permutarray[i];
        permutarray[i] = permutarray[2];
        permutarray[2] = swapvertex;
    }

    // Make sure the fourth vertex is not coplanar with the first three.
    i = 3;
    ori = orient3dfast(permutarray[0], permutarray[1], permutarray[2], permutarray[i]);
    while ((fabs(ori) / bboxsize3) < b->epsilon) {
        i++;
        if (i == in->numberofpoints) {
            printf("Exception:  All vertices are coplanar (Tol = %g).\n", b->epsilon);
            terminatetetgen(this, 10);
        }
        ori = orient3dfast(permutarray[0], permutarray[1], permutarray[2], permutarray[i]);
    }
    if (i > 3) {
        // Swap to move the non-identical vertex from index i to index 1.
        swapvertex = permutarray[i];
        permutarray[i] = permutarray[3];
        permutarray[3] = swapvertex;
    }

    // Orient the first four vertices in permutarray so that they follow the
    //   right-hand rule.
    if (ori > 0.0) {
        // Swap the first two vertices.
        swapvertex = permutarray[0];
        permutarray[0] = permutarray[1];
        permutarray[1] = swapvertex;
    }

    // Create the initial Delaunay tetrahedralization.
    initialdelaunay(permutarray[0], permutarray[1], permutarray[2], permutarray[3]);

    if (b->verbose) {
        printf("  Incrementally inserting vertices.\n");
    }
    insertvertexflags ivf;
    flipconstraints fc;

    // Choose algorithm: Bowyer-Watson (default) or Incremental Flip
    if (b->incrflip) {
        ivf.bowywat = 0;
        ivf.lawson = 1;
        fc.enqflag = 1;
    } else {
        ivf.bowywat = 1;
        ivf.lawson = 0;
    }

    for (i = 4; i < in->numberofpoints; i++) {
        if (pointtype(permutarray[i]) == UNUSEDVERTEX) {
            setpointtype(permutarray[i], VOLVERTEX);
        }
        if (b->brio_hilbert || b->no_sort) { // -b or -b/1
            // Start the last updated tet.
            searchtet.tet = recenttet.tet;
        } else { // -b0
            // Randomly choose the starting tet for point location.
            searchtet.tet = NULL;
        }
        ivf.iloc = (int)OUTSIDE;
        // Insert the vertex.
        if (insertpoint(permutarray[i], &searchtet, NULL, NULL, &ivf)) {
            if (flipstack != NULL) {
                // Perform flip to recover Delaunayness.
                incrementalflip(permutarray[i], (ivf.iloc == (int)OUTSIDE), &fc);
            }
        } else {
            if (ivf.iloc == (int)ONVERTEX) {
                // The point already exists. Mark it and do nothing on it.
                swapvertex = org(searchtet);
                if (b->object != tetgenbehavior::STL) {
                    if (!b->quiet) {
                        printf("Warning:  Point #%d is coincident with #%d. Ignored!\n",
                               pointmark(permutarray[i]), pointmark(swapvertex));
                    }
                }
                setpoint2ppt(permutarray[i], swapvertex);
                setpointtype(permutarray[i], DUPLICATEDVERTEX);
                dupverts++;
            } else if (ivf.iloc == (int)NEARVERTEX) {
                swapvertex = org(searchtet);
                if (!b->quiet) {
                    printf("Warning:  Point %d is replaced by point %d.\n",
                           pointmark(permutarray[i]), pointmark(swapvertex));
                    printf("  Avoid creating a very short edge (len = %g) (< %g).\n",
                           permutarray[i][3], minedgelength);
                    printf("  You may try a smaller tolerance (-T) (current is %g)\n", b->epsilon);
                    printf("  or use the option -M0/1 to avoid such replacement.\n");
                }
                // Remember it is a duplicated point.
                setpoint2ppt(permutarray[i], swapvertex);
                setpointtype(permutarray[i], DUPLICATEDVERTEX);
                dupverts++;
            } else if (ivf.iloc == (int)NONREGULAR) {
                // The point is non-regular. Skipped.
                if (b->verbose) {
                    printf("  Point #%d is non-regular, skipped.\n", pointmark(permutarray[i]));
                }
                setpointtype(permutarray[i], NREGULARVERTEX);
                nonregularcount++;
            }
        }
    }

    delete[] permutarray;
}

////                                                                       ////
////                                                                       ////
//// delaunay_cxx /////////////////////////////////////////////////////////////

//// surface_cxx //////////////////////////////////////////////////////////////
////                                                                       ////
////                                                                       ////

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// flipshpush()    Push a facet edge into flip stack.                        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::flipshpush(face* flipedge) {
    badface* newflipface;

    newflipface = (badface*)flippool->alloc();
    newflipface->ss = *flipedge;
    newflipface->forg = sorg(*flipedge);
    newflipface->fdest = sdest(*flipedge);
    newflipface->nextitem = flipstack;
    flipstack = newflipface;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// flip22()    Perform a 2-to-2 flip in surface mesh.                        //
//                                                                           //
// 'flipfaces' is an array of two subfaces. On input, they are [a,b,c] and   //
// [b,a,d]. On output, they are [c,d,b] and [d,c,a]. As a result, edge [a,b] //
// is replaced by edge [c,d].                                                //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::flip22(face* flipfaces, int flipflag, int chkencflag) {
    face bdedges[4], outfaces[4], infaces[4];
    face bdsegs[4];
    face checkface;
    point pa, pb, pc, pd;
    int i;

    pa = sorg(flipfaces[0]);
    pb = sdest(flipfaces[0]);
    pc = sapex(flipfaces[0]);
    pd = sapex(flipfaces[1]);

    if (sorg(flipfaces[1]) != pb) {
        sesymself(flipfaces[1]);
    }

    flip22count++;

    // Collect the four boundary edges.
    senext(flipfaces[0], bdedges[0]);
    senext2(flipfaces[0], bdedges[1]);
    senext(flipfaces[1], bdedges[2]);
    senext2(flipfaces[1], bdedges[3]);

    // Collect outer boundary faces.
    for (i = 0; i < 4; i++) {
        spivot(bdedges[i], outfaces[i]);
        infaces[i] = outfaces[i];
        sspivot(bdedges[i], bdsegs[i]);
        if (outfaces[i].sh != NULL) {
            if (isshsubseg(bdedges[i])) {
                spivot(infaces[i], checkface);
                while (checkface.sh != bdedges[i].sh) {
                    infaces[i] = checkface;
                    spivot(infaces[i], checkface);
                }
            }
        }
    }

    // The flags set in these two subfaces do not change.
    // Shellmark does not change.
    // area constraint does not change.

    // Transform [a,b,c] -> [c,d,b].
    setshvertices(flipfaces[0], pc, pd, pb);
    // Transform [b,a,d] -> [d,c,a].
    setshvertices(flipfaces[1], pd, pc, pa);

    // Update the point-to-subface map.
    if (pointtype(pa) == FREEFACETVERTEX) {
        setpoint2sh(pa, sencode(flipfaces[1]));
    }
    if (pointtype(pb) == FREEFACETVERTEX) {
        setpoint2sh(pb, sencode(flipfaces[0]));
    }
    if (pointtype(pc) == FREEFACETVERTEX) {
        setpoint2sh(pc, sencode(flipfaces[0]));
    }
    if (pointtype(pd) == FREEFACETVERTEX) {
        setpoint2sh(pd, sencode(flipfaces[0]));
    }

    // Reconnect boundary edges to outer boundary faces.
    for (i = 0; i < 4; i++) {
        if (outfaces[(3 + i) % 4].sh != NULL) {
            // Make sure that the subface has the ori as the segment.
            if (bdsegs[(3 + i) % 4].sh != NULL) {
                bdsegs[(3 + i) % 4].shver = 0;
                if (sorg(bdedges[i]) != sorg(bdsegs[(3 + i) % 4])) {
                    sesymself(bdedges[i]);
                }
            }
            sbond1(bdedges[i], outfaces[(3 + i) % 4]);
            sbond1(infaces[(3 + i) % 4], bdedges[i]);
        } else {
            sdissolve(bdedges[i]);
        }
        if (bdsegs[(3 + i) % 4].sh != NULL) {
            ssbond(bdedges[i], bdsegs[(3 + i) % 4]);
            if (chkencflag & 1) {
                // Queue this segment for encroaching check.
                enqueuesubface(badsubsegs, &(bdsegs[(3 + i) % 4]));
            }
        } else {
            ssdissolve(bdedges[i]);
        }
    }

    if (chkencflag & 2) {
        // Queue the flipped subfaces for quality/encroaching checks.
        for (i = 0; i < 2; i++) {
            enqueuesubface(badsubfacs, &(flipfaces[i]));
        }
    }

    recentsh = flipfaces[0];

    if (flipflag) {
        // Put the boundary edges into flip stack.
        for (i = 0; i < 4; i++) {
            flipshpush(&(bdedges[i]));
        }
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// flip31()    Remove a vertex by transforming 3-to-1 subfaces.              //
//                                                                           //
// 'flipfaces' is an array of subfaces. Its length is at least 4.  On input, //
// the first three faces are: [p,a,b], [p,b,c], and [p,c,a]. This routine    //
// replaces them by one face [a,b,c], it is returned in flipfaces[3].        //
//                                                                           //
// NOTE: The three old subfaces are not deleted within this routine.  They   //
// still hold pointers to their adjacent subfaces. These informations are    //
// needed by the routine 'sremovevertex()' for recovering a segment.         //
// The caller of this routine must delete the old subfaces after their uses. //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::flip31(face* flipfaces, int flipflag) {
    face bdedges[3], outfaces[3], infaces[3];
    face bdsegs[3];
    face checkface;
    point pa, pb, pc;
    int i;

    pa = sdest(flipfaces[0]);
    pb = sdest(flipfaces[1]);
    pc = sdest(flipfaces[2]);

    flip31count++;

    // Collect all infos at the three boundary edges.
    for (i = 0; i < 3; i++) {
        senext(flipfaces[i], bdedges[i]);
        spivot(bdedges[i], outfaces[i]);
        infaces[i] = outfaces[i];
        sspivot(bdedges[i], bdsegs[i]);
        if (outfaces[i].sh != NULL) {
            if (isshsubseg(bdedges[i])) {
                spivot(infaces[i], checkface);
                while (checkface.sh != bdedges[i].sh) {
                    infaces[i] = checkface;
                    spivot(infaces[i], checkface);
                }
            }
        }
    } // i

    // Create a new subface.
    makeshellface(subfaces, &(flipfaces[3]));
    setshvertices(flipfaces[3], pa, pb, pc);
    setshellmark(flipfaces[3], shellmark(flipfaces[0]));
    if (checkconstraints) {
        // area = areabound(flipfaces[0]);
        setareabound(flipfaces[3], areabound(flipfaces[0]));
    }
    if (useinsertradius) {
        setfacetindex(flipfaces[3], getfacetindex(flipfaces[0]));
    }

    // Update the point-to-subface map.
    if (pointtype(pa) == FREEFACETVERTEX) {
        setpoint2sh(pa, sencode(flipfaces[3]));
    }
    if (pointtype(pb) == FREEFACETVERTEX) {
        setpoint2sh(pb, sencode(flipfaces[3]));
    }
    if (pointtype(pc) == FREEFACETVERTEX) {
        setpoint2sh(pc, sencode(flipfaces[3]));
    }

    // Update the three new boundary edges.
    bdedges[0] = flipfaces[3];         // [a,b]
    senext(flipfaces[3], bdedges[1]);  // [b,c]
    senext2(flipfaces[3], bdedges[2]); // [c,a]

    // Reconnect boundary edges to outer boundary faces.
    for (i = 0; i < 3; i++) {
        if (outfaces[i].sh != NULL) {
            // Make sure that the subface has the ori as the segment.
            if (bdsegs[i].sh != NULL) {
                bdsegs[i].shver = 0;
                if (sorg(bdedges[i]) != sorg(bdsegs[i])) {
                    sesymself(bdedges[i]);
                }
            }
            sbond1(bdedges[i], outfaces[i]);
            sbond1(infaces[i], bdedges[i]);
        }
        if (bdsegs[i].sh != NULL) {
            ssbond(bdedges[i], bdsegs[i]);
        }
    }

    recentsh = flipfaces[3];

    if (flipflag) {
        // Put the boundary edges into flip stack.
        for (i = 0; i < 3; i++) {
            flipshpush(&(bdedges[i]));
        }
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// lawsonflip()    Flip non-locally Delaunay edges.                          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

long tetgenmesh::lawsonflip() {
    badface* popface;
    face flipfaces[2];
    point pa, pb, pc, pd;
    REAL sign;
    long flipcount = 0;

    if (b->verbose > 2) {
        printf("      Lawson flip %ld edges.\n", flippool->items);
    }

    while (flipstack != (badface*)NULL) {

        // Pop an edge from the stack.
        popface = flipstack;
        flipfaces[0] = popface->ss;
        pa = popface->forg;
        pb = popface->fdest;
        flipstack = popface->nextitem; // The next top item in stack.
        flippool->dealloc((void*)popface);

        // Skip it if it is dead.
        if (flipfaces[0].sh[3] == NULL) continue;
        // Skip it if it is not the same edge as we saved.
        if ((sorg(flipfaces[0]) != pa) || (sdest(flipfaces[0]) != pb)) continue;
        // Skip it if it is a subsegment.
        if (isshsubseg(flipfaces[0])) continue;

        // Get the adjacent face.
        spivot(flipfaces[0], flipfaces[1]);
        if (flipfaces[1].sh == NULL) continue; // Skip a hull edge.
        pc = sapex(flipfaces[0]);
        pd = sapex(flipfaces[1]);

        sign = incircle3d(pa, pb, pc, pd);

        if (sign < 0) {
            // It is non-locally Delaunay. Flip it.
            flip22(flipfaces, 1, 0);
            flipcount++;
        }
    }

    if (b->verbose > 2) {
        printf("      Performed %ld flips.\n", flipcount);
    }

    return flipcount;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// sinsertvertex()    Insert a vertex into a triangulation of a facet.       //
//                                                                           //
// This function uses three global arrays: 'caveshlist', 'caveshbdlist', and //
// 'caveshseglist'. On return, 'caveshlist' contains old subfaces in C(p),   //
// 'caveshbdlist' contains new subfaces in C(p). If the new point lies on a  //
// segment, 'cavesegshlist' returns the two new subsegments.                 //
//                                                                           //
// 'iloc' suggests the location of the point. If it is OUTSIDE, this routine //
// will first locate the point. It starts searching from 'searchsh' or 'rec- //
// entsh' if 'searchsh' is NULL.                                             //
//                                                                           //
// If 'bowywat' is set (1), the Bowyer-Watson algorithm is used to insert    //
// the vertex. Otherwise, only insert the vertex in the initial cavity.      //
//                                                                           //
// If 'iloc' is 'INSTAR', this means the cavity of this vertex was already   //
// provided in the list 'caveshlist'.                                        //
//                                                                           //
// If 'splitseg' is not NULL, the new vertex lies on the segment and it will //
// be split. 'iloc' must be either 'ONEDGE' or 'INSTAR'.                     //
//                                                                           //
// 'rflag' (rounding) is a parameter passed to slocate() function.  If it is //
// set, after the location of the point is found, either ONEDGE or ONFACE,   //
// round the result using an epsilon.                                        //
//                                                                           //
// NOTE: the old subfaces in C(p) are not deleted. They're needed in case we //
// want to remove the new point immediately.                                 //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::sinsertvertex(point insertpt, face* searchsh, face* splitseg, int iloc, int bowywat,
                              int rflag) {
    face cavesh, neighsh, *parysh;
    face newsh, casout, casin;
    face checkseg;
    point pa, pb;
    enum locateresult loc = OUTSIDE;
    REAL sign, ori;
    int i, j;

    if (b->verbose > 2) {
        printf("      Insert facet point %d.\n", pointmark(insertpt));
    }

    if (bowywat == 3) {
        loc = INSTAR;
    }

    if ((splitseg != NULL) && (splitseg->sh != NULL)) {
        // A segment is going to be split, no point location.
        spivot(*splitseg, *searchsh);
        if (loc != INSTAR) loc = ONEDGE;
    } else {
        if (loc != INSTAR) loc = (enum locateresult)iloc;
        if (loc == OUTSIDE) {
            // Do point location in surface mesh.
            if (searchsh->sh == NULL) {
                *searchsh = recentsh;
            }
            // Search the vertex. An above point must be provided ('aflag' = 1).
            loc = slocate(insertpt, searchsh, 1, 1, rflag);
        }
    }

    // Form the initial sC(p).
    if (loc == ONFACE) {
        // Add the face into list (in B-W cavity).
        smarktest(*searchsh);
        caveshlist->newindex((void**)&parysh);
        *parysh = *searchsh;
    } else if (loc == ONEDGE) {
        if ((splitseg != NULL) && (splitseg->sh != NULL)) {
            splitseg->shver = 0;
            pa = sorg(*splitseg);
        } else {
            pa = sorg(*searchsh);
        }
        if (searchsh->sh != NULL) {
            // Collect all subfaces share at this edge.
            neighsh = *searchsh;
            while (1) {
                // Adjust the origin of its edge to be 'pa'.
                if (sorg(neighsh) != pa) sesymself(neighsh);
                // Add this face into list (in B-W cavity).
                smarktest(neighsh);
                caveshlist->newindex((void**)&parysh);
                *parysh = neighsh;
                // Add this face into face-at-splitedge list.
                cavesegshlist->newindex((void**)&parysh);
                *parysh = neighsh;
                // Go to the next face at the edge.
                spivotself(neighsh);
                // Stop if all faces at the edge have been visited.
                if (neighsh.sh == searchsh->sh) break;
                if (neighsh.sh == NULL) break;
            }
        } // If (not a non-dangling segment).
    } else if (loc == ONVERTEX) {
        return (int)loc;
    } else if (loc == OUTSIDE) {
        // Comment: This should only happen during the surface meshing step.
        // Enlarge the convex hull of the triangulation by including p.
        // An above point of the facet is set in 'dummypoint' to replace
        // orient2d tests by orient3d tests.
        // Imagine that the current edge a->b (in 'searchsh') is horizontal in a
        //   plane, and a->b is directed from left to right, p lies above a->b.
        //   Find the right-most edge of the triangulation which is visible by p.
        neighsh = *searchsh;
        while (1) {
            senext2self(neighsh);
            spivot(neighsh, casout);
            if (casout.sh == NULL) {
                // A convex hull edge. Is it visible by p.
                ori = orient3d(sorg(neighsh), sdest(neighsh), dummypoint, insertpt);
                if (ori < 0) {
                    *searchsh = neighsh; // Visible, update 'searchsh'.
                } else {
                    break; // 'searchsh' is the right-most visible edge.
                }
            } else {
                if (sorg(casout) != sdest(neighsh)) sesymself(casout);
                neighsh = casout;
            }
        }
        // Create new triangles for all visible edges of p (from right to left).
        casin.sh = NULL; // No adjacent face at right.
        pa = sorg(*searchsh);
        pb = sdest(*searchsh);
        while (1) {
            // Create a new subface on top of the (visible) edge.
            makeshellface(subfaces, &newsh);
            setshvertices(newsh, pb, pa, insertpt);
            setshellmark(newsh, shellmark(*searchsh));
            if (checkconstraints) {
                // area = areabound(*searchsh);
                setareabound(newsh, areabound(*searchsh));
            }
            if (useinsertradius) {
                setfacetindex(newsh, getfacetindex(*searchsh));
            }
            // Connect the new subface to the bottom subfaces.
            sbond1(newsh, *searchsh);
            sbond1(*searchsh, newsh);
            // Connect the new subface to its right-adjacent subface.
            if (casin.sh != NULL) {
                senext(newsh, casout);
                sbond1(casout, casin);
                sbond1(casin, casout);
            }
            // The left-adjacent subface has not been created yet.
            senext2(newsh, casin);
            // Add the new face into list (inside the B-W cavity).
            smarktest(newsh);
            caveshlist->newindex((void**)&parysh);
            *parysh = newsh;
            // Move to the convex hull edge at the left of 'searchsh'.
            neighsh = *searchsh;
            while (1) {
                senextself(neighsh);
                spivot(neighsh, casout);
                if (casout.sh == NULL) {
                    *searchsh = neighsh;
                    break;
                }
                if (sorg(casout) != sdest(neighsh)) sesymself(casout);
                neighsh = casout;
            }
            // A convex hull edge. Is it visible by p.
            pa = sorg(*searchsh);
            pb = sdest(*searchsh);
            ori = orient3d(pa, pb, dummypoint, insertpt);
            // Finish the process if p is not visible by the hull edge.
            if (ori >= 0) break;
        }
    } else if (loc == INSTAR) {
        // Under this case, the sub-cavity sC(p) has already been formed in
        //   insertvertex().
    }

    // Form the Bowyer-Watson cavity sC(p).
    for (i = 0; i < caveshlist->objects; i++) {
        cavesh = *(face*)fastlookup(caveshlist, i);
        for (j = 0; j < 3; j++) {
            if (!isshsubseg(cavesh)) {
                spivot(cavesh, neighsh);
                if (neighsh.sh != NULL) {
                    // The adjacent face exists.
                    if (!smarktested(neighsh)) {
                        if (bowywat) {
                            if (loc == INSTAR) { // if (bowywat > 2) {
                                // It must be a boundary edge.
                                sign = 1;
                            } else {
                                // Check if this subface is connected to adjacent tet(s).
                                if (!isshtet(neighsh)) {
                                    // Check if the subface is non-Delaunay wrt. the new pt.
                                    sign = incircle3d(sorg(neighsh), sdest(neighsh), sapex(neighsh),
                                                      insertpt);
                                } else {
                                    // It is connected to an adjacent tet. A boundary edge.
                                    sign = 1;
                                }
                            }
                            if (sign < 0) {
                                // Add the adjacent face in list (in B-W cavity).
                                smarktest(neighsh);
                                caveshlist->newindex((void**)&parysh);
                                *parysh = neighsh;
                            }
                        } else {
                            sign = 1; // A boundary edge.
                        }
                    } else {
                        sign = -1; // Not a boundary edge.
                    }
                } else {
                    // No adjacent face. It is a hull edge.
                    if (loc == OUTSIDE) {
                        // It is a boundary edge if it does not contain p.
                        if ((sorg(cavesh) == insertpt) || (sdest(cavesh) == insertpt)) {
                            sign = -1; // Not a boundary edge.
                        } else {
                            sign = 1; // A boundary edge.
                        }
                    } else {
                        sign = 1; // A boundary edge.
                    }
                }
            } else {
                // Do not across a segment. It is a boundary edge.
                sign = 1;
            }
            if (sign >= 0) {
                // Add a boundary edge.
                caveshbdlist->newindex((void**)&parysh);
                *parysh = cavesh;
            }
            senextself(cavesh);
        } // j
    }     // i

    // Creating new subfaces.
    for (i = 0; i < caveshbdlist->objects; i++) {
        parysh = (face*)fastlookup(caveshbdlist, i);
        sspivot(*parysh, checkseg);
        if ((parysh->shver & 01) != 0) sesymself(*parysh);
        pa = sorg(*parysh);
        pb = sdest(*parysh);
        // Create a new subface.
        makeshellface(subfaces, &newsh);
        setshvertices(newsh, pa, pb, insertpt);
        setshellmark(newsh, shellmark(*parysh));
        if (checkconstraints) {
            // area = areabound(*parysh);
            setareabound(newsh, areabound(*parysh));
        }
        if (useinsertradius) {
            setfacetindex(newsh, getfacetindex(*parysh));
        }
        // Update the point-to-subface map.
        if (pointtype(pa) == FREEFACETVERTEX) {
            setpoint2sh(pa, sencode(newsh));
        }
        if (pointtype(pb) == FREEFACETVERTEX) {
            setpoint2sh(pb, sencode(newsh));
        }
        // Connect newsh to outer subfaces.
        spivot(*parysh, casout);
        if (casout.sh != NULL) {
            casin = casout;
            if (checkseg.sh != NULL) {
                // Make sure that newsh has the right ori at this segment.
                checkseg.shver = 0;
                if (sorg(newsh) != sorg(checkseg)) {
                    sesymself(newsh);
                    sesymself(*parysh); // This side should also be inverse.
                }
                spivot(casin, neighsh);
                while (neighsh.sh != parysh->sh) {
                    casin = neighsh;
                    spivot(casin, neighsh);
                }
            }
            sbond1(newsh, casout);
            sbond1(casin, newsh);
        }
        if (checkseg.sh != NULL) {
            ssbond(newsh, checkseg);
        }
        // Connect oldsh <== newsh (for connecting adjacent new subfaces).
        //   *parysh and newsh point to the same edge and the same ori.
        sbond1(*parysh, newsh);
    }

    if (newsh.sh != NULL) {
        // Set a handle for searching.
        recentsh = newsh;
    }

    // Update the point-to-subface map.
    if (pointtype(insertpt) == FREEFACETVERTEX) {
        setpoint2sh(insertpt, sencode(newsh));
    }

    // Connect adjacent new subfaces together.
    for (i = 0; i < caveshbdlist->objects; i++) {
        // Get an old subface at edge [a, b].
        parysh = (face*)fastlookup(caveshbdlist, i);
        spivot(*parysh, newsh); // The new subface [a, b, p].
        senextself(newsh);      // At edge [b, p].
        spivot(newsh, neighsh);
        if (neighsh.sh == NULL) {
            // Find the adjacent new subface at edge [b, p].
            pb = sdest(*parysh);
            neighsh = *parysh;
            while (1) {
                senextself(neighsh);
                spivotself(neighsh);
                if (neighsh.sh == NULL) break;
                if (!smarktested(neighsh)) break;
                if (sdest(neighsh) != pb) sesymself(neighsh);
            }
            if (neighsh.sh != NULL) {
                // Now 'neighsh' is a new subface at edge [b, #].
                if (sorg(neighsh) != pb) sesymself(neighsh);
                senext2self(neighsh); // Go to the open edge [p, b].
                sbond(newsh, neighsh);
            }
        }
        spivot(*parysh, newsh); // The new subface [a, b, p].
        senext2self(newsh);     // At edge [p, a].
        spivot(newsh, neighsh);
        if (neighsh.sh == NULL) {
            // Find the adjacent new subface at edge [p, a].
            pa = sorg(*parysh);
            neighsh = *parysh;
            while (1) {
                senext2self(neighsh);
                spivotself(neighsh);
                if (neighsh.sh == NULL) break;
                if (!smarktested(neighsh)) break;
                if (sorg(neighsh) != pa) sesymself(neighsh);
            }
            if (neighsh.sh != NULL) {
                // Now 'neighsh' is a new subface at edge [#, a].
                if (sdest(neighsh) != pa) sesymself(neighsh);
                senextself(neighsh); // Go to the open edge [a, p].
                sbond(newsh, neighsh);
            }
        }
    }

    if ((loc == ONEDGE) || ((splitseg != NULL) && (splitseg->sh != NULL)) ||
        (cavesegshlist->objects > 0l)) {
        // An edge is being split. We distinguish two cases:
        //   (1) the edge is not on the boundary of the cavity;
        //   (2) the edge is on the boundary of the cavity.
        // In case (2), the edge is either a segment or a hull edge. There are
        //   degenerated new faces in the cavity. They must be removed.
        face aseg, bseg, aoutseg, boutseg;

        for (i = 0; i < cavesegshlist->objects; i++) {
            // Get the saved old subface.
            parysh = (face*)fastlookup(cavesegshlist, i);
            // Get a possible new degenerated subface.
            spivot(*parysh, cavesh);
            if (sapex(cavesh) == insertpt) {
                // Found a degenerated new subface, i.e., case (2).
                if (cavesegshlist->objects > 1) {
                    // There are more than one subface share at this edge.
                    j = (i + 1) % (int)cavesegshlist->objects;
                    parysh = (face*)fastlookup(cavesegshlist, j);
                    spivot(*parysh, neighsh);
                    // Adjust cavesh and neighsh both at edge a->b, and has p as apex.
                    if (sorg(neighsh) != sorg(cavesh)) {
                        sesymself(neighsh);
                    }
                    // Connect adjacent faces at two other edges of cavesh and neighsh.
                    //   As a result, the two degenerated new faces are squeezed from the
                    //   new triangulation of the cavity. Note that the squeezed faces
                    //   still hold the adjacent informations which will be used in
                    //   re-connecting subsegments (if they exist).
                    for (j = 0; j < 2; j++) {
                        senextself(cavesh);
                        senextself(neighsh);
                        spivot(cavesh, newsh);
                        spivot(neighsh, casout);
                        sbond1(newsh, casout); // newsh <- casout.
                    }
                } else {
                    // There is only one subface containing this edge [a,b]. Squeeze the
                    //   degenerated new face [a,b,c] by disconnecting it from its two
                    //   adjacent subfaces at edges [b,c] and [c,a]. Note that the face
                    //   [a,b,c] still hold the connection to them.
                    for (j = 0; j < 2; j++) {
                        senextself(cavesh);
                        spivot(cavesh, newsh);
                        sdissolve(newsh);
                    }
                }
                // recentsh = newsh;
                // Update the point-to-subface map.
                if (pointtype(insertpt) == FREEFACETVERTEX) {
                    setpoint2sh(insertpt, sencode(newsh));
                }
            }
        }

        if ((splitseg != NULL) && (splitseg->sh != NULL)) {
            if (loc != INSTAR) {      // if (bowywat < 3) {
                smarktest(*splitseg); // Mark it as being processed.
            }

            aseg = *splitseg;
            pa = sorg(*splitseg);
            pb = sdest(*splitseg);

            // Insert the new point p.
            makeshellface(subsegs, &aseg);
            makeshellface(subsegs, &bseg);

            setshvertices(aseg, pa, insertpt, NULL);
            setshvertices(bseg, insertpt, pb, NULL);
            setshellmark(aseg, shellmark(*splitseg));
            setshellmark(bseg, shellmark(*splitseg));
            if (checkconstraints) {
                setareabound(aseg, areabound(*splitseg));
                setareabound(bseg, areabound(*splitseg));
            }
            if (useinsertradius) {
                setfacetindex(aseg, getfacetindex(*splitseg));
                setfacetindex(bseg, getfacetindex(*splitseg));
            }

            // Connect [#, a]<->[a, p].
            senext2(*splitseg, boutseg); // Temporarily use boutseg.
            spivotself(boutseg);
            if (boutseg.sh != NULL) {
                senext2(aseg, aoutseg);
                sbond(boutseg, aoutseg);
            }
            // Connect [p, b]<->[b, #].
            senext(*splitseg, aoutseg);
            spivotself(aoutseg);
            if (aoutseg.sh != NULL) {
                senext(bseg, boutseg);
                sbond(boutseg, aoutseg);
            }
            // Connect [a, p] <-> [p, b].
            senext(aseg, aoutseg);
            senext2(bseg, boutseg);
            sbond(aoutseg, boutseg);

            // Connect subsegs [a, p] and [p, b] to adjacent new subfaces.
            // Although the degenerated new faces have been squeezed. They still
            //   hold the connections to the actual new faces.
            for (i = 0; i < cavesegshlist->objects; i++) {
                parysh = (face*)fastlookup(cavesegshlist, i);
                spivot(*parysh, neighsh);
                // neighsh is a degenerated new face.
                if (sorg(neighsh) != pa) {
                    sesymself(neighsh);
                }
                senext2(neighsh, newsh);
                spivotself(newsh); // The edge [p, a] in newsh
                ssbond(newsh, aseg);
                senext(neighsh, newsh);
                spivotself(newsh); // The edge [b, p] in newsh
                ssbond(newsh, bseg);
            }

            // Let the point remember the segment it lies on.
            if (pointtype(insertpt) == FREESEGVERTEX) {
                setpoint2sh(insertpt, sencode(aseg));
            }
            // Update the point-to-seg map.
            if (pointtype(pa) == FREESEGVERTEX) {
                setpoint2sh(pa, sencode(aseg));
            }
            if (pointtype(pb) == FREESEGVERTEX) {
                setpoint2sh(pb, sencode(bseg));
            }
        } // if ((splitseg != NULL) && (splitseg->sh != NULL))

        // Delete all degenerated new faces.
        for (i = 0; i < cavesegshlist->objects; i++) {
            parysh = (face*)fastlookup(cavesegshlist, i);
            spivotself(*parysh);
            if (sapex(*parysh) == insertpt) {
                shellfacedealloc(subfaces, parysh->sh);
            }
        }
        cavesegshlist->restart();

        if ((splitseg != NULL) && (splitseg->sh != NULL)) {
            // Return the two new subsegments (for further process).
            //   Re-use 'cavesegshlist'.
            cavesegshlist->newindex((void**)&parysh);
            *parysh = aseg;
            cavesegshlist->newindex((void**)&parysh);
            *parysh = bseg;
        }
    } // if (loc == ONEDGE)

    return (int)loc;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// sremovevertex()    Remove a vertex from the surface mesh.                 //
//                                                                           //
// 'delpt' (p) is the vertex to be removed. If 'parentseg' is not NULL, p is //
// a segment vertex, and the origin of 'parentseg' is p. Otherwise, p is a   //
// facet vertex, and the origin of 'parentsh' is p.                          //
//                                                                           //
// Within each facet, we first use a sequence of 2-to-2 flips to flip any    //
// edge at p, finally use a 3-to-1 flip to remove p.                         //
//                                                                           //
// All new created subfaces are returned in the global array 'caveshbdlist'. //
// The new segment (when p is on segment) is returned in 'parentseg'.        //
//                                                                           //
// If 'lawson' > 0, the Lawson flip algorithm is used to recover Delaunay-   //
// ness after p is removed.                                                  //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::sremovevertex(point delpt, face* parentsh, face* parentseg, int lawson) {
    face flipfaces[4], spinsh, *parysh;
    point pa, pb, pc, pd;
    REAL ori1, ori2;
    int it, i, j;

    if (parentseg != NULL) {
        // 'delpt' (p) should be a Steiner point inserted in a segment [a,b],
        //   where 'parentseg' should be [p,b]. Find the segment [a,p].
        face startsh, neighsh, nextsh;
        face abseg, prevseg, checkseg;
        face adjseg1, adjseg2;
        face fakesh;
        senext2(*parentseg, prevseg);
        spivotself(prevseg);
        prevseg.shver = 0;
        // Restore the original segment [a,b].
        pa = sorg(prevseg);
        pb = sdest(*parentseg);
        if (b->verbose > 2) {
            printf("      Remove vertex %d from segment [%d, %d].\n", pointmark(delpt),
                   pointmark(pa), pointmark(pb));
        }
        makeshellface(subsegs, &abseg);
        setshvertices(abseg, pa, pb, NULL);
        setshellmark(abseg, shellmark(*parentseg));
        if (checkconstraints) {
            setareabound(abseg, areabound(*parentseg));
        }
        if (useinsertradius) {
            setfacetindex(abseg, getfacetindex(*parentseg));
        }
        // Connect [#, a]<->[a, b].
        senext2(prevseg, adjseg1);
        spivotself(adjseg1);
        if (adjseg1.sh != NULL) {
            adjseg1.shver = 0;
            senextself(adjseg1);
            senext2(abseg, adjseg2);
            sbond(adjseg1, adjseg2);
        }
        // Connect [a, b]<->[b, #].
        senext(*parentseg, adjseg1);
        spivotself(adjseg1);
        if (adjseg1.sh != NULL) {
            adjseg1.shver = 0;
            senext2self(adjseg1);
            senext(abseg, adjseg2);
            sbond(adjseg1, adjseg2);
        }
        // Update the point-to-segment map.
        setpoint2sh(pa, sencode(abseg));
        setpoint2sh(pb, sencode(abseg));

        // Get the faces in face ring at segment [p, b].
        //   Re-use array 'caveshlist'.
        spivot(*parentseg, *parentsh);
        if (parentsh->sh != NULL) {
            spinsh = *parentsh;
            while (1) {
                // Save this face in list.
                caveshlist->newindex((void**)&parysh);
                *parysh = spinsh;
                // Go to the next face in the ring.
                spivotself(spinsh);
                if (spinsh.sh == NULL) {
                    break; // It is possible there is only one facet.
                }
                if (spinsh.sh == parentsh->sh) break;
            }
        }

        // Create the face ring of the new segment [a,b]. Each face in the ring
        //   is [a,b,p] (degenerated!). It will be removed (automatically).
        for (i = 0; i < caveshlist->objects; i++) {
            parysh = (face*)fastlookup(caveshlist, i);
            startsh = *parysh;
            if (sorg(startsh) != delpt) {
                sesymself(startsh);
            }
            // startsh is [p, b, #1], find the subface [a, p, #2].
            neighsh = startsh;
            while (1) {
                senext2self(neighsh);
                sspivot(neighsh, checkseg);
                if (checkseg.sh != NULL) {
                    // It must be the segment [a, p].
                    break;
                }
                spivotself(neighsh);
                if (sorg(neighsh) != delpt) sesymself(neighsh);
            }
            // Now neighsh is [a, p, #2].
            if (neighsh.sh != startsh.sh) {
                // Detach the two subsegments [a,p] and [p,b] from subfaces.
                ssdissolve(startsh);
                ssdissolve(neighsh);
                // Create a degenerated subface [a,b,p]. It is used to: (1) hold the
                //   new segment [a,b]; (2) connect to the two adjacent subfaces
                //   [p,b,#] and [a,p,#].
                makeshellface(subfaces, &fakesh);
                setshvertices(fakesh, pa, pb, delpt);
                setshellmark(fakesh, shellmark(startsh));
                // Connect fakesh to the segment [a,b].
                ssbond(fakesh, abseg);
                // Connect fakesh to adjacent subfaces: [p,b,#1] and [a,p,#2].
                senext(fakesh, nextsh);
                sbond(nextsh, startsh);
                senext2(fakesh, nextsh);
                sbond(nextsh, neighsh);
                smarktest(fakesh); // Mark it as faked.
            } else {
                // Special case. There exists already a degenerated face [a,b,p]!
                //   There is no need to create a faked subface here.
                senext2self(neighsh); // [a,b,p]
                // Since we will re-connect the face ring using the faked subfaces.
                //   We put the adjacent face of [a,b,p] to the list.
                spivot(neighsh, startsh); // The original adjacent subface.
                if (sorg(startsh) != pa) sesymself(startsh);
                sdissolve(startsh);
                // Connect fakesh to the segment [a,b].
                ssbond(startsh, abseg);
                fakesh = startsh; // Do not mark it!
                // Delete the degenerated subface.
                shellfacedealloc(subfaces, neighsh.sh);
            }
            // Save the fakesh in list (for re-creating the face ring).
            cavesegshlist->newindex((void**)&parysh);
            *parysh = fakesh;
        } // i
        caveshlist->restart();

        // Re-create the face ring.
        if (cavesegshlist->objects > 1) {
            for (i = 0; i < cavesegshlist->objects; i++) {
                parysh = (face*)fastlookup(cavesegshlist, i);
                fakesh = *parysh;
                // Get the next face in the ring.
                j = (i + 1) % cavesegshlist->objects;
                parysh = (face*)fastlookup(cavesegshlist, j);
                nextsh = *parysh;
                sbond1(fakesh, nextsh);
            }
        }

        // Delete the two subsegments containing p.
        shellfacedealloc(subsegs, parentseg->sh);
        shellfacedealloc(subsegs, prevseg.sh);
        // Return the new segment.
        *parentseg = abseg;
    } else {
        // p is inside the surface.
        if (b->verbose > 2) {
            printf("      Remove vertex %d from surface.\n", pointmark(delpt));
        }
        // Let 'delpt' be its apex.
        senextself(*parentsh);
        // For unifying the code, we add parentsh to list.
        cavesegshlist->newindex((void**)&parysh);
        *parysh = *parentsh;
    }

    // Remove the point (p).

    for (it = 0; it < cavesegshlist->objects; it++) {
        parentsh = (face*)fastlookup(cavesegshlist, it); // [a,b,p]
        senextself(*parentsh);                           // [b,p,a].
        spivotself(*parentsh);
        if (sorg(*parentsh) != delpt) sesymself(*parentsh);
        // now parentsh is [p,b,#].
        if (sorg(*parentsh) != delpt) {
            // The vertex has already been removed in above special case.
            continue;
        }

        while (1) {
            // Initialize the flip edge list. Re-use 'caveshlist'.
            spinsh = *parentsh; // [p, b, #]
            while (1) {
                caveshlist->newindex((void**)&parysh);
                *parysh = spinsh;
                senext2self(spinsh);
                spivotself(spinsh);
                if (spinsh.sh == parentsh->sh) break;
                if (sorg(spinsh) != delpt) sesymself(spinsh);
            } // while (1)

            if (caveshlist->objects == 3) {
                // Delete the point by a 3-to-1 flip.
                for (i = 0; i < 3; i++) {
                    parysh = (face*)fastlookup(caveshlist, i);
                    flipfaces[i] = *parysh;
                }
                flip31(flipfaces, lawson);
                for (i = 0; i < 3; i++) {
                    shellfacedealloc(subfaces, flipfaces[i].sh);
                }
                caveshlist->restart();
                // Save the new subface.
                caveshbdlist->newindex((void**)&parysh);
                *parysh = flipfaces[3];
                // The vertex is removed.
                break;
            }

            // Search an edge to flip.
            for (i = 0; i < caveshlist->objects; i++) {
                parysh = (face*)fastlookup(caveshlist, i);
                flipfaces[0] = *parysh;
                spivot(flipfaces[0], flipfaces[1]);
                if (sorg(flipfaces[0]) != sdest(flipfaces[1])) sesymself(flipfaces[1]);
                // Skip this edge if it belongs to a faked subface.
                if (!smarktested(flipfaces[0]) && !smarktested(flipfaces[1])) {
                    pa = sorg(flipfaces[0]);
                    pb = sdest(flipfaces[0]);
                    pc = sapex(flipfaces[0]);
                    pd = sapex(flipfaces[1]);
                    calculateabovepoint4(pa, pb, pc, pd);
                    // Check if a 2-to-2 flip is possible.
                    ori1 = orient3d(pc, pd, dummypoint, pa);
                    ori2 = orient3d(pc, pd, dummypoint, pb);
                    if (ori1 * ori2 < 0) {
                        // A 2-to-2 flip is found.
                        flip22(flipfaces, lawson, 0);
                        // The i-th edge is flipped. The i-th and (i-1)-th subfaces are
                        //   changed. The 'flipfaces[1]' contains p as its apex.
                        senext2(flipfaces[1], *parentsh);
                        // Save the new subface.
                        caveshbdlist->newindex((void**)&parysh);
                        *parysh = flipfaces[0];
                        break;
                    }
                } //
            }     // i

            if (i == caveshlist->objects) {
                // Do a flip22 and a flip31 to remove p.
                parysh = (face*)fastlookup(caveshlist, 0);
                flipfaces[0] = *parysh;
                spivot(flipfaces[0], flipfaces[1]);
                if (sorg(flipfaces[0]) != sdest(flipfaces[1])) {
                    sesymself(flipfaces[1]);
                }
                flip22(flipfaces, lawson, 0);
                senext2(flipfaces[1], *parentsh);
                // Save the new subface.
                caveshbdlist->newindex((void**)&parysh);
                *parysh = flipfaces[0];
            }

            // The edge list at p are changed.
            caveshlist->restart();
        } // while (1)

    } // it

    cavesegshlist->restart();

    if (b->verbose > 2) {
        printf("      Created %ld new subfaces.\n", caveshbdlist->objects);
    }

    if (lawson) {
        lawsonflip();
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// slocate()    Locate a point in a surface triangulation.                   //
//                                                                           //
// Staring the search from 'searchsh'(it should not be NULL). Perform a line //
// walk search for a subface containing the point (p).                       //
//                                                                           //
// If 'aflag' is set, the 'dummypoint' is pre-calculated so that it lies     //
// above the 'searchsh' in its current orientation. The test if c is CCW to  //
// the line a->b can be done by the test if c is below the oriented plane    //
// a->b->dummypoint.                                                         //
//                                                                           //
// If 'cflag' is not TRUE, the triangulation may not be convex.  Stop search //
// when a segment is met and return OUTSIDE.                                 //
//                                                                           //
// If 'rflag' (rounding) is set, after the location of the point is found,   //
// either ONEDGE or ONFACE, round the result using an epsilon.               //
//                                                                           //
// The returned value indicates the following cases:                         //
//   - ONVERTEX, p is the origin of 'searchsh'.                              //
//   - ONEDGE, p lies on the edge of 'searchsh'.                             //
//   - ONFACE, p lies in the interior of 'searchsh'.                         //
//   - OUTSIDE, p lies outside of the triangulation, p is on the left-hand   //
//     side of the edge 'searchsh'(s), i.e., org(s), dest(s), p are CW.      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

enum tetgenmesh::locateresult tetgenmesh::slocate(point searchpt, face* searchsh, int aflag,
                                                  int cflag, int rflag) {
    face neighsh;
    point pa, pb, pc;
    enum locateresult loc;
    enum { MOVE_BC, MOVE_CA } nextmove;
    REAL ori, ori_bc, ori_ca;
    int i;

    pa = sorg(*searchsh);
    pb = sdest(*searchsh);
    pc = sapex(*searchsh);

    if (!aflag) {
        // No above point is given. Calculate an above point for this facet.
        calculateabovepoint4(pa, pb, pc, searchpt);
    }

    // 'dummypoint' is given. Make sure it is above [a,b,c]
    ori = orient3d(pa, pb, pc, dummypoint);
    if (ori > 0) {
        sesymself(*searchsh); // Reverse the face orientation.
    } else if (ori == 0.0) {
        // This case should not happen theoretically. But...
        return UNKNOWN;
    }

    // Find an edge of the face s.t. p lies on its right-hand side (CCW).
    for (i = 0; i < 3; i++) {
        pa = sorg(*searchsh);
        pb = sdest(*searchsh);
        ori = orient3d(pa, pb, dummypoint, searchpt);
        if (ori > 0) break;
        senextself(*searchsh);
    }
    if (i == 3) {
        return UNKNOWN;
    }

    pc = sapex(*searchsh);

    if (pc == searchpt) {
        senext2self(*searchsh);
        return ONVERTEX;
    }

    while (1) {

        ori_bc = orient3d(pb, pc, dummypoint, searchpt);
        ori_ca = orient3d(pc, pa, dummypoint, searchpt);

        if (ori_bc < 0) {
            if (ori_ca < 0) { // (--)
                // Any of the edges is a viable move.
                if (randomnation(2)) {
                    nextmove = MOVE_CA;
                } else {
                    nextmove = MOVE_BC;
                }
            } else { // (-#)
                // Edge [b, c] is viable.
                nextmove = MOVE_BC;
            }
        } else {
            if (ori_ca < 0) { // (#-)
                // Edge [c, a] is viable.
                nextmove = MOVE_CA;
            } else {
                if (ori_bc > 0) {
                    if (ori_ca > 0) { // (++)
                        loc = ONFACE; // Inside [a, b, c].
                        break;
                    } else {                    // (+0)
                        senext2self(*searchsh); // On edge [c, a].
                        loc = ONEDGE;
                        break;
                    }
                } else {                       // ori_bc == 0
                    if (ori_ca > 0) {          // (0+)
                        senextself(*searchsh); // On edge [b, c].
                        loc = ONEDGE;
                        break;
                    } else { // (00)
                        // p is coincident with vertex c.
                        senext2self(*searchsh);
                        return ONVERTEX;
                    }
                }
            }
        }

        // Move to the next face.
        if (nextmove == MOVE_BC) {
            senextself(*searchsh);
        } else {
            senext2self(*searchsh);
        }
        if (!cflag) {
            // NON-convex case. Check if we will cross a boundary.
            if (isshsubseg(*searchsh)) {
                return ENCSEGMENT;
            }
        }
        spivot(*searchsh, neighsh);
        if (neighsh.sh == NULL) {
            return OUTSIDE; // A hull edge.
        }
        // Adjust the edge orientation.
        if (sorg(neighsh) != sdest(*searchsh)) {
            sesymself(neighsh);
        }

        // Update the newly discovered face and its endpoints.
        *searchsh = neighsh;
        pa = sorg(*searchsh);
        pb = sdest(*searchsh);
        pc = sapex(*searchsh);

        if (pc == searchpt) {
            senext2self(*searchsh);
            return ONVERTEX;
        }

    } // while (1)

    // assert(loc == ONFACE || loc == ONEDGE);

    if (rflag) {
        // Round the locate result before return.
        REAL n[3], area_abc, area_abp, area_bcp, area_cap;

        pa = sorg(*searchsh);
        pb = sdest(*searchsh);
        pc = sapex(*searchsh);

        facenormal(pa, pb, pc, n, 1, NULL);
        area_abc = sqrt(dot(n, n));

        facenormal(pb, pc, searchpt, n, 1, NULL);
        area_bcp = sqrt(dot(n, n));
        if ((area_bcp / area_abc) < b->epsilon) {
            area_bcp = 0; // Rounding.
        }

        facenormal(pc, pa, searchpt, n, 1, NULL);
        area_cap = sqrt(dot(n, n));
        if ((area_cap / area_abc) < b->epsilon) {
            area_cap = 0; // Rounding
        }

        if ((loc == ONFACE) || (loc == OUTSIDE)) {
            facenormal(pa, pb, searchpt, n, 1, NULL);
            area_abp = sqrt(dot(n, n));
            if ((area_abp / area_abc) < b->epsilon) {
                area_abp = 0; // Rounding
            }
        } else { // loc == ONEDGE
            area_abp = 0;
        }

        if (area_abp == 0) {
            if (area_bcp == 0) {
                senextself(*searchsh);
                loc = ONVERTEX; // p is close to b.
            } else {
                if (area_cap == 0) {
                    loc = ONVERTEX; // p is close to a.
                } else {
                    loc = ONEDGE; // p is on edge [a,b].
                }
            }
        } else if (area_bcp == 0) {
            if (area_cap == 0) {
                senext2self(*searchsh);
                loc = ONVERTEX; // p is close to c.
            } else {
                senextself(*searchsh);
                loc = ONEDGE; // p is on edge [b,c].
            }
        } else if (area_cap == 0) {
            senext2self(*searchsh);
            loc = ONEDGE; // p is on edge [c,a].
        } else {
            loc = ONFACE; // p is on face [a,b,c].
        }
    } // if (rflag)

    return loc;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// sscoutsegment()    Look for a segment in the surface triangulation.       //
//                                                                           //
// The segment is given by the origin of 'searchsh' and 'endpt'.             //
//                                                                           //
// If an edge in T is found matching this segment, the segment is "locked"   //
// in T at the edge.  Otherwise, flip the first edge in T that the segment   //
// crosses. Continue the search from the flipped face.                       //
//                                                                           //
// This routine uses 'orisent3d' to determine the search direction. It uses  //
// 'dummypoint' as the 'lifted point' in 3d, and it assumes that it (dummy-  //
// point) lies above the 'searchsh' (w.r.t the Right-hand rule).             //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

enum tetgenmesh::interresult tetgenmesh::sscoutsegment(face* searchsh, point endpt,
                                                       int insertsegflag, int reporterrorflag,
                                                       int chkencflag) {
    face flipshs[2], neighsh;
    point startpt, pa, pb, pc, pd;
    enum interresult dir;
    enum { MOVE_AB, MOVE_CA } nextmove;
    REAL ori_ab, ori_ca, len;

    pc = NULL; // Avoid warnings from MSVC
    // The origin of 'searchsh' is fixed.
    startpt = sorg(*searchsh);
    nextmove = MOVE_AB; // Avoid compiler warning.

    if (b->verbose > 2) {
        printf("      Scout segment (%d, %d).\n", pointmark(startpt), pointmark(endpt));
    }
    len = distance(startpt, endpt);

    // Search an edge in 'searchsh' on the path of this segment.
    while (1) {

        pb = sdest(*searchsh);
        if (pb == endpt) {
            dir = SHAREEDGE; // Found!
            break;
        }

        pc = sapex(*searchsh);
        if (pc == endpt) {
            senext2self(*searchsh);
            sesymself(*searchsh);
            dir = SHAREEDGE; // Found!
            break;
        }

        // Round the results.
        if ((sqrt(triarea(startpt, pb, endpt)) / len) < b->epsilon) {
            ori_ab = 0.0;
        } else {
            ori_ab = orient3d(startpt, pb, dummypoint, endpt);
        }
        if ((sqrt(triarea(pc, startpt, endpt)) / len) < b->epsilon) {
            ori_ca = 0.0;
        } else {
            ori_ca = orient3d(pc, startpt, dummypoint, endpt);
        }

        if (ori_ab < 0) {
            if (ori_ca < 0) { // (--)
                // Both sides are viable moves.
                if (randomnation(2)) {
                    nextmove = MOVE_CA;
                } else {
                    nextmove = MOVE_AB;
                }
            } else { // (-#)
                nextmove = MOVE_AB;
            }
        } else {
            if (ori_ca < 0) { // (#-)
                nextmove = MOVE_CA;
            } else {
                if (ori_ab > 0) {
                    if (ori_ca > 0) { // (++)
                        // The segment intersects with edge [b, c].
                        dir = ACROSSEDGE;
                        break;
                    } else { // (+0)
                        // The segment collinear with edge [c, a].
                        senext2self(*searchsh);
                        sesymself(*searchsh);
                        dir = ACROSSVERT;
                        break;
                    }
                } else {
                    if (ori_ca > 0) { // (0+)
                        // The segment is collinear with edge [a, b].
                        dir = ACROSSVERT;
                        break;
                    } else { // (00)
                        // startpt == endpt. Not possible.
                        terminatetetgen(this, 2);
                    }
                }
            }
        }

        // Move 'searchsh' to the next face, keep the origin unchanged.
        if (nextmove == MOVE_AB) {
            if (chkencflag) {
                // Do not cross boundary.
                if (isshsubseg(*searchsh)) {
                    return ACROSSEDGE; // ACROSS_SEG
                }
            }
            spivot(*searchsh, neighsh);
            if (neighsh.sh != NULL) {
                if (sorg(neighsh) != pb) sesymself(neighsh);
                senext(neighsh, *searchsh);
            } else {
                // This side (startpt->pb) is outside. It is caused by rounding error.
                // Try the next side, i.e., (pc->startpt).
                senext2(*searchsh, neighsh);
                if (chkencflag) {
                    // Do not cross boundary.
                    if (isshsubseg(neighsh)) {
                        *searchsh = neighsh;
                        return ACROSSEDGE; // ACROSS_SEG
                    }
                }
                spivotself(neighsh);
                if (sdest(neighsh) != pc) sesymself(neighsh);
                *searchsh = neighsh;
            }
        } else { // MOVE_CA
            senext2(*searchsh, neighsh);
            if (chkencflag) {
                // Do not cross boundary.
                if (isshsubseg(neighsh)) {
                    *searchsh = neighsh;
                    return ACROSSEDGE; // ACROSS_SEG
                }
            }
            spivotself(neighsh);
            if (neighsh.sh != NULL) {
                if (sdest(neighsh) != pc) sesymself(neighsh);
                *searchsh = neighsh;
            } else {
                // The same reason as above.
                // Try the next side, i.e., (startpt->pb).
                if (chkencflag) {
                    // Do not cross boundary.
                    if (isshsubseg(*searchsh)) {
                        return ACROSSEDGE; // ACROSS_SEG
                    }
                }
                spivot(*searchsh, neighsh);
                if (sorg(neighsh) != pb) sesymself(neighsh);
                senext(neighsh, *searchsh);
            }
        }
    } // while

    if (dir == SHAREEDGE) {
        if (insertsegflag) {
            // Insert the segment into the triangulation.
            face newseg;
            makeshellface(subsegs, &newseg);
            setshvertices(newseg, startpt, endpt, NULL);
            // Set the default segment marker.
            setshellmark(newseg, -1);
            ssbond(*searchsh, newseg);
            spivot(*searchsh, neighsh);
            if (neighsh.sh != NULL) {
                ssbond(neighsh, newseg);
            }
        }
        return dir;
    }

    if (dir == ACROSSVERT) {
        // A point is found collinear with this segment.
        if (reporterrorflag) {
            point pp = sdest(*searchsh);
            printf("PLC Error:  A vertex lies in a segment in facet #%d.\n", shellmark(*searchsh));
            printf("  Vertex:  [%d] (%g,%g,%g).\n", pointmark(pp), pp[0], pp[1], pp[2]);
            printf("  Segment: [%d, %d]\n", pointmark(startpt), pointmark(endpt));
        }
        return dir;
    }

    if (dir == ACROSSEDGE) {
        // Edge [b, c] intersects with the segment.
        senext(*searchsh, flipshs[0]);
        if (isshsubseg(flipshs[0])) {
            if (reporterrorflag) {
                REAL P[3], Q[3], tp = 0, tq = 0;
                linelineint(startpt, endpt, pb, pc, P, Q, &tp, &tq);
                printf("PLC Error:  Two segments intersect at point (%g,%g,%g),", P[0], P[1], P[2]);
                printf(" in facet #%d.\n", shellmark(*searchsh));
                printf("  Segment 1: [%d, %d]\n", pointmark(pb), pointmark(pc));
                printf("  Segment 2: [%d, %d]\n", pointmark(startpt), pointmark(endpt));
            }
            return dir; // ACROSS_SEG
        }
        // Flip edge [b, c], queue unflipped edges (for Delaunay checks).
        spivot(flipshs[0], flipshs[1]);
        if (sorg(flipshs[1]) != sdest(flipshs[0])) sesymself(flipshs[1]);
        flip22(flipshs, 1, 0);
        // The flip may create an inverted triangle, check it.
        pa = sapex(flipshs[1]);
        pb = sapex(flipshs[0]);
        pc = sorg(flipshs[0]);
        pd = sdest(flipshs[0]);
        // Check if pa and pb are on the different sides of [pc, pd].
        // Re-use ori_ab, ori_ca for the tests.
        ori_ab = orient3d(pc, pd, dummypoint, pb);
        ori_ca = orient3d(pd, pc, dummypoint, pa);
        if (ori_ab <= 0) {
            flipshpush(&(flipshs[0]));
        } else if (ori_ca <= 0) {
            flipshpush(&(flipshs[1]));
        }
        // Set 'searchsh' s.t. its origin is 'startpt'.
        *searchsh = flipshs[0];
    }

    return sscoutsegment(searchsh, endpt, insertsegflag, reporterrorflag, chkencflag);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// scarveholes()    Remove triangles not in the facet.                       //
//                                                                           //
// This routine re-uses the two global arrays: caveshlist and caveshbdlist.  //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::scarveholes(int holes, REAL* holelist) {
    face *parysh, searchsh, neighsh;
    enum locateresult loc;
    int i, j;

    // Get all triangles. Infect unprotected convex hull triangles.
    smarktest(recentsh);
    caveshlist->newindex((void**)&parysh);
    *parysh = recentsh;
    for (i = 0; i < caveshlist->objects; i++) {
        parysh = (face*)fastlookup(caveshlist, i);
        searchsh = *parysh;
        searchsh.shver = 0;
        for (j = 0; j < 3; j++) {
            spivot(searchsh, neighsh);
            // Is this side on the convex hull?
            if (neighsh.sh != NULL) {
                if (!smarktested(neighsh)) {
                    smarktest(neighsh);
                    caveshlist->newindex((void**)&parysh);
                    *parysh = neighsh;
                }
            } else {
                // A hull side. Check if it is protected by a segment.
                if (!isshsubseg(searchsh)) {
                    // Not protected. Save this face.
                    if (!sinfected(searchsh)) {
                        sinfect(searchsh);
                        caveshbdlist->newindex((void**)&parysh);
                        *parysh = searchsh;
                    }
                }
            }
            senextself(searchsh);
        }
    }

    // Infect the triangles in the holes.
    for (i = 0; i < 3 * holes; i += 3) {
        searchsh = recentsh;
        loc = slocate(&(holelist[i]), &searchsh, 1, 1, 0);
        if (loc != OUTSIDE) {
            sinfect(searchsh);
            caveshbdlist->newindex((void**)&parysh);
            *parysh = searchsh;
        }
    }

    // Find and infect all exterior triangles.
    for (i = 0; i < caveshbdlist->objects; i++) {
        parysh = (face*)fastlookup(caveshbdlist, i);
        searchsh = *parysh;
        searchsh.shver = 0;
        for (j = 0; j < 3; j++) {
            spivot(searchsh, neighsh);
            if (neighsh.sh != NULL) {
                if (!isshsubseg(searchsh)) {
                    if (!sinfected(neighsh)) {
                        sinfect(neighsh);
                        caveshbdlist->newindex((void**)&parysh);
                        *parysh = neighsh;
                    }
                } else {
                    sdissolve(neighsh); // Disconnect a protected face.
                }
            }
            senextself(searchsh);
        }
    }

    // Delete exterior triangles, unmark interior triangles.
    for (i = 0; i < caveshlist->objects; i++) {
        parysh = (face*)fastlookup(caveshlist, i);
        if (sinfected(*parysh)) {
            shellfacedealloc(subfaces, parysh->sh);
        } else {
            sunmarktest(*parysh);
        }
    }

    caveshlist->restart();
    caveshbdlist->restart();
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// triangulate()    Create a CDT for the facet.                              //
//                                                                           //
// All vertices of the triangulation have type FACETVERTEX.  The actual type //
//   of boundary vertices are set by the routine unifysements().             //
//                                                                           //
// All segments created here will have a default marker '-1'.  Some of these //
//   segments will get their actual marker defined in 'edgemarkerlist'.      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::triangulate(int shmark, arraypool* ptlist, arraypool* conlist, int holes,
                            REAL* holelist) {
    face searchsh, newsh, *parysh;
    face newseg, *paryseg;
    point pa, pb, pc, *ppt, *cons;
    int iloc;
    int i, j;

    if (b->verbose > 2) {
        printf("      f%d:  %ld vertices, %ld segments", shmark, ptlist->objects, conlist->objects);
        if (holes > 0) {
            printf(", %d holes", holes);
        }
        printf(".\n");
    }

    if (ptlist->objects < 2l) {
        // Not a segment or a facet.
        return 1;
    } else if (ptlist->objects == 2l) {
        pa = *(point*)fastlookup(ptlist, 0);
        pb = *(point*)fastlookup(ptlist, 1);
        if (distance(pa, pb) > 0) {
            // It is a single segment.
            makeshellface(subsegs, &newseg);
            setshvertices(newseg, pa, pb, NULL);
            setshellmark(newseg, -1);
        }
        if (pointtype(pa) == VOLVERTEX) {
            setpointtype(pa, FACETVERTEX);
        }
        if (pointtype(pb) == VOLVERTEX) {
            setpointtype(pb, FACETVERTEX);
        }
        return 1;
    } else if (ptlist->objects == 3) {
        pa = *(point*)fastlookup(ptlist, 0);
        pb = *(point*)fastlookup(ptlist, 1);
        pc = *(point*)fastlookup(ptlist, 2);
    } else {
        // Calculate an above point of this facet.
        if (!calculateabovepoint(ptlist, &pa, &pb, &pc)) {
            if (!b->quiet) {
                printf("Warning:  Unable to triangulate facet #%d. Skipped!\n", shmark);
            }
            return 0; // The point set is degenerate.
        }
    }

    // Create an initial triangulation.
    makeshellface(subfaces, &newsh);
    setshvertices(newsh, pa, pb, pc);
    setshellmark(newsh, shmark);
    recentsh = newsh;

    if (pointtype(pa) == VOLVERTEX) {
        setpointtype(pa, FACETVERTEX);
    }
    if (pointtype(pb) == VOLVERTEX) {
        setpointtype(pb, FACETVERTEX);
    }
    if (pointtype(pc) == VOLVERTEX) {
        setpointtype(pc, FACETVERTEX);
    }

    // Are there area constraints?
    if (b->quality && (in->facetconstraintlist != NULL)) {
        for (i = 0; i < in->numberoffacetconstraints; i++) {
            if (shmark == ((int)in->facetconstraintlist[i * 2])) {
                REAL area = in->facetconstraintlist[i * 2 + 1];
                setareabound(newsh, area);
                break;
            }
        }
    }

    if (ptlist->objects == 3) {
        // The triangulation only has one element.
        for (i = 0; i < 3; i++) {
            makeshellface(subsegs, &newseg);
            setshvertices(newseg, sorg(newsh), sdest(newsh), NULL);
            setshellmark(newseg, -1);
            ssbond(newsh, newseg);
            senextself(newsh);
        }
        return 1;
    }

    // Triangulate the facet. It may not success (due to rounding error, or
    //   incorrect input data), use 'caveencshlist' and 'caveencseglist' are
    //   re-used to store all the newly created subfaces and segments. So we
    //   can clean them if the triangulation is not successful.
    caveencshlist->newindex((void**)&parysh);
    *parysh = newsh;

    // Incrementally build the triangulation.
    pinfect(pa);
    pinfect(pb);
    pinfect(pc);
    for (i = 0; i < ptlist->objects; i++) {
        ppt = (point*)fastlookup(ptlist, i);
        if (!pinfected(*ppt)) {
            searchsh = recentsh; // Start from 'recentsh'.
            iloc = (int)OUTSIDE;
            // Insert the vertex. Use Bowyer-Watson algo. Round the location.
            iloc = sinsertvertex(*ppt, &searchsh, NULL, iloc, 1, 1);
            if (iloc != ((int)ONVERTEX)) {
                // Point inserted successfully.
                if (pointtype(*ppt) == VOLVERTEX) {
                    setpointtype(*ppt, FACETVERTEX);
                }
                // Save the set of new subfaces.
                for (j = 0; j < caveshbdlist->objects; j++) {
                    // Get an old subface at edge [a, b].
                    parysh = (face*)fastlookup(caveshbdlist, j);
                    spivot(*parysh, searchsh); // The new subface [a, b, p].
                    // Do not save a deleted new face (degenerated).
                    if (searchsh.sh[3] != NULL) {
                        caveencshlist->newindex((void**)&parysh);
                        *parysh = searchsh;
                    }
                }
                // Delete all removed subfaces.
                for (j = 0; j < caveshlist->objects; j++) {
                    parysh = (face*)fastlookup(caveshlist, j);
                    shellfacedealloc(subfaces, parysh->sh);
                }
                // Clear the global lists.
                caveshbdlist->restart();
                caveshlist->restart();
                cavesegshlist->restart();
            } else {
                // The facet triangulation is failed.
                break;
            }
        }
    } // i
    puninfect(pa);
    puninfect(pb);
    puninfect(pc);

    if (i < ptlist->objects) {
        // The facet triangulation is failed. Clean the new subfaces.
        //  There is no new segment be created yet.
        if (!b->quiet) {
            printf("Warning:  Fail to triangulate facet #%d. Skipped!\n", shmark);
        }
        for (i = 0; i < caveencshlist->objects; i++) {
            parysh = (face*)fastlookup(caveencshlist, i);
            if (parysh->sh[3] != NULL) {
                shellfacedealloc(subfaces, parysh->sh);
            }
        }
        caveencshlist->restart();
        return 0;
    }

    // Insert the segments.
    for (i = 0; i < conlist->objects; i++) {
        cons = (point*)fastlookup(conlist, i);
        searchsh = recentsh;
        iloc = (int)slocate(cons[0], &searchsh, 1, 1, 0);
        if (iloc != (int)ONVERTEX) {
            // Not found due to roundoff errors. Do a brute-force search.
            subfaces->traversalinit();
            searchsh.sh = shellfacetraverse(subfaces);
            while (searchsh.sh != NULL) {
                // Only search the subface in the same facet.
                if (shellmark(searchsh) == shmark) {
                    if ((point)searchsh.sh[3] == cons[0]) {
                        searchsh.shver = 0;
                        break;
                    } else if ((point)searchsh.sh[4] == cons[0]) {
                        searchsh.shver = 2;
                        break;
                    } else if ((point)searchsh.sh[5] == cons[0]) {
                        searchsh.shver = 4;
                        break;
                    }
                }
                searchsh.sh = shellfacetraverse(subfaces);
            }
        }
        // Recover the segment. Some edges may be flipped.
        if (sscoutsegment(&searchsh, cons[1], 1, 1, 0) != SHAREEDGE) {
            break; // Fail to recover a segment.
        }
        // Save this newseg.
        sspivot(searchsh, newseg);
        caveencseglist->newindex((void**)&paryseg);
        *paryseg = newseg;
        if (flipstack != NULL) {
            // Recover locally Delaunay edges.
            lawsonflip();
        }
    } // i

    if (i < conlist->objects) {
        if (!b->quiet) {
            printf("Warning:  Fail to recover a segment in facet #%d. Skipped!\n", shmark);
        }
        for (i = 0; i < caveencshlist->objects; i++) {
            parysh = (face*)fastlookup(caveencshlist, i);
            if (parysh->sh[3] != NULL) {
                shellfacedealloc(subfaces, parysh->sh);
            }
        }
        for (i = 0; i < caveencseglist->objects; i++) {
            paryseg = (face*)fastlookup(caveencseglist, i);
            if (paryseg->sh[3] != NULL) {
                shellfacedealloc(subsegs, paryseg->sh);
            }
        }
        caveencshlist->restart();
        caveencseglist->restart();
        return 0;
    }

    // Remove exterior and hole triangles.
    scarveholes(holes, holelist);

    caveencshlist->restart();
    caveencseglist->restart();
    return 1;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// unifysegments()    Remove redundant segments and create face links.       //
//                                                                           //
// After this routine, although segments are unique, but some of them may be //
// removed later by mergefacet().  All vertices still have type FACETVERTEX. //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::unifysegments() {
    badface *facelink = NULL, *newlinkitem, *f1, *f2;
    face *facperverlist, sface;
    face subsegloop, testseg;
    point torg, tdest;
    REAL ori1, ori2, ori3;
    REAL n1[3], n2[3];
    REAL cosang, ang, ang_tol;
    int* idx2faclist;
    int idx, k, m;

    if (b->verbose > 1) {
        printf("  Unifying segments.\n");
    }
    // The limit dihedral angle that two facets are not overlapping.
    ang_tol = b->facet_overlap_ang_tol / 180.0 * PI;
    if (ang_tol < 0.0) ang_tol = 0.0;

    // Create a mapping from vertices to subfaces.
    makepoint2submap(subfaces, idx2faclist, facperverlist);

    subsegloop.shver = 0;
    subsegs->traversalinit();
    subsegloop.sh = shellfacetraverse(subsegs);
    while (subsegloop.sh != (shellface*)NULL) {
        torg = sorg(subsegloop);
        tdest = sdest(subsegloop);

        idx = pointmark(torg) - in->firstnumber;
        // Loop through the set of subfaces containing 'torg'.  Get all the
        //   subfaces containing the edge (torg, tdest). Save and order them
        //   in 'sfacelist', the ordering is defined by the right-hand rule
        //   with thumb points from torg to tdest.
        for (k = idx2faclist[idx]; k < idx2faclist[idx + 1]; k++) {
            sface = facperverlist[k];
            // The face may be deleted if it is a duplicated face.
            if (sface.sh[3] == NULL) continue;
            // Search the edge torg->tdest.
            if (sdest(sface) != tdest) {
                senext2self(sface);
                sesymself(sface);
            }
            if (sdest(sface) != tdest) continue;

            // Save the face f in facelink.
            if (flippool->items >= 2) {
                f1 = facelink;
                for (m = 0; m < flippool->items - 1; m++) {
                    f2 = f1->nextitem;
                    ori1 = orient3d(torg, tdest, sapex(f1->ss), sapex(f2->ss));
                    ori2 = orient3d(torg, tdest, sapex(f1->ss), sapex(sface));
                    if (ori1 > 0) {
                        // apex(f2) is below f1.
                        if (ori2 > 0) {
                            // apex(f) is below f1 (see Fig.1).
                            ori3 = orient3d(torg, tdest, sapex(f2->ss), sapex(sface));
                            if (ori3 > 0) {
                                // apex(f) is below f2, insert it.
                                break;
                            } else if (ori3 < 0) {
                                // apex(f) is above f2, continue.
                            } else { // ori3 == 0;
                                // f is coplanar and codirection with f2.
                                report_overlapping_facets(&(f2->ss), &sface);
                                break;
                            }
                        } else if (ori2 < 0) {
                            // apex(f) is above f1 below f2, inset it (see Fig. 2).
                            break;
                        } else { // ori2 == 0;
                            // apex(f) is coplanar with f1 (see Fig. 5).
                            ori3 = orient3d(torg, tdest, sapex(f2->ss), sapex(sface));
                            if (ori3 > 0) {
                                // apex(f) is below f2, insert it.
                                break;
                            } else {
                                // f is coplanar and codirection with f1.
                                report_overlapping_facets(&(f1->ss), &sface);
                                break;
                            }
                        }
                    } else if (ori1 < 0) {
                        // apex(f2) is above f1.
                        if (ori2 > 0) {
                            // apex(f) is below f1, continue (see Fig. 3).
                        } else if (ori2 < 0) {
                            // apex(f) is above f1 (see Fig.4).
                            ori3 = orient3d(torg, tdest, sapex(f2->ss), sapex(sface));
                            if (ori3 > 0) {
                                // apex(f) is below f2, insert it.
                                break;
                            } else if (ori3 < 0) {
                                // apex(f) is above f2, continue.
                            } else { // ori3 == 0;
                                // f is coplanar and codirection with f2.
                                report_overlapping_facets(&(f2->ss), &sface);
                                break;
                            }
                        } else { // ori2 == 0;
                            // f is coplanar and with f1 (see Fig. 6).
                            ori3 = orient3d(torg, tdest, sapex(f2->ss), sapex(sface));
                            if (ori3 > 0) {
                                // f is also codirection with f1.
                                report_overlapping_facets(&(f1->ss), &sface);
                                break;
                            } else {
                                // f is above f2, continue.
                            }
                        }
                    } else { // ori1 == 0;
                        // apex(f2) is coplanar with f1. By assumption, f1 is not
                        //   coplanar and codirection with f2.
                        if (ori2 > 0) {
                            // apex(f) is below f1, continue (see Fig. 7).
                        } else if (ori2 < 0) {
                            // apex(f) is above f1, insert it (see Fig. 7).
                            break;
                        } else { // ori2 == 0.
                            // apex(f) is coplanar with f1 (see Fig. 8).
                            // f is either codirection with f1 or is codirection with f2.
                            facenormal(torg, tdest, sapex(f1->ss), n1, 1, NULL);
                            facenormal(torg, tdest, sapex(sface), n2, 1, NULL);
                            if (dot(n1, n2) > 0) {
                                report_overlapping_facets(&(f1->ss), &sface);
                            } else {
                                report_overlapping_facets(&(f2->ss), &sface);
                            }
                            break;
                        }
                    }
                    // Go to the next item;
                    f1 = f2;
                } // for (m = 0; ...)
                if (sface.sh[3] != NULL) {
                    // Insert sface between f1 and f2.
                    newlinkitem = (badface*)flippool->alloc();
                    newlinkitem->ss = sface;
                    newlinkitem->nextitem = f1->nextitem;
                    f1->nextitem = newlinkitem;
                }
            } else if (flippool->items == 1) {
                f1 = facelink;
                // Make sure that f is not coplanar and codirection with f1.
                ori1 = orient3d(torg, tdest, sapex(f1->ss), sapex(sface));
                if (ori1 == 0) {
                    // f is coplanar with f1 (see Fig. 8).
                    facenormal(torg, tdest, sapex(f1->ss), n1, 1, NULL);
                    facenormal(torg, tdest, sapex(sface), n2, 1, NULL);
                    if (dot(n1, n2) > 0) {
                        // The two faces are codirectional as well.
                        report_overlapping_facets(&(f1->ss), &sface);
                    }
                }
                // Add this face to link if it is not deleted.
                if (sface.sh[3] != NULL) {
                    // Add this face into link.
                    newlinkitem = (badface*)flippool->alloc();
                    newlinkitem->ss = sface;
                    newlinkitem->nextitem = NULL;
                    f1->nextitem = newlinkitem;
                }
            } else {
                // The first face.
                newlinkitem = (badface*)flippool->alloc();
                newlinkitem->ss = sface;
                newlinkitem->nextitem = NULL;
                facelink = newlinkitem;
            }
        } // for (k = idx2faclist[idx]; ...)

        // Set the connection between this segment and faces containing it,
        //   at the same time, remove redundant segments.
        f1 = facelink;
        for (k = 0; k < flippool->items; k++) {
            sspivot(f1->ss, testseg);
            // If 'testseg' is not 'subsegloop' and is not dead, it is redundant.
            if ((testseg.sh != subsegloop.sh) && (testseg.sh[3] != NULL)) {
                shellfacedealloc(subsegs, testseg.sh);
            }
            // Bonds the subface and the segment together.
            ssbond(f1->ss, subsegloop);
            f1 = f1->nextitem;
        }

        // Create the face ring at the segment.
        if (flippool->items > 1) {
            f1 = facelink;
            for (k = 1; k <= flippool->items; k++) {
                k < flippool->items ? f2 = f1->nextitem : f2 = facelink;
                // Calculate the dihedral angle between the two facet.
                facenormal(torg, tdest, sapex(f1->ss), n1, 1, NULL);
                facenormal(torg, tdest, sapex(f2->ss), n2, 1, NULL);
                cosang = dot(n1, n2) / (sqrt(dot(n1, n1)) * sqrt(dot(n2, n2)));
                // Rounding.
                if (cosang > 1.0)
                    cosang = 1.0;
                else if (cosang < -1.0)
                    cosang = -1.0;
                ang = acos(cosang);
                if (ang < ang_tol) {
                    // Two facets are treated as overlapping each other.
                    report_overlapping_facets(&(f1->ss), &(f2->ss), ang);
                } else {
                    // Record the smallest input dihedral angle.
                    if (ang < minfacetdihed) {
                        minfacetdihed = ang;
                    }
                    sbond1(f1->ss, f2->ss);
                }
                f1 = f2;
            }
        }

        flippool->restart();

        // Are there length constraints?
        if (b->quality && (in->segmentconstraintlist != (REAL*)NULL)) {
            int e1, e2;
            REAL len;
            for (k = 0; k < in->numberofsegmentconstraints; k++) {
                e1 = (int)in->segmentconstraintlist[k * 3];
                e2 = (int)in->segmentconstraintlist[k * 3 + 1];
                if (((pointmark(torg) == e1) && (pointmark(tdest) == e2)) ||
                    ((pointmark(torg) == e2) && (pointmark(tdest) == e1))) {
                    len = in->segmentconstraintlist[k * 3 + 2];
                    setareabound(subsegloop, len);
                    break;
                }
            }
        }

        subsegloop.sh = shellfacetraverse(subsegs);
    }

    delete[] idx2faclist;
    delete[] facperverlist;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// identifyinputedges()    Identify input edges.                             //
//                                                                           //
// A set of input edges is provided in the 'in->edgelist'.  We find these    //
// edges in the surface mesh and make them segments of the mesh.             //
//                                                                           //
// It is possible that an input edge is not in any facet, i.e.,it is a float-//
// segment inside the volume.                                                //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::identifyinputedges(point* idx2verlist) {
    face* shperverlist;
    int* idx2shlist;
    face searchsh, neighsh;
    face segloop, checkseg, newseg;
    point checkpt, pa = NULL, pb = NULL;
    int* endpts;
    int edgemarker;
    int idx, i, j;

    int e1, e2;
    REAL len;

    if (!b->quiet) {
        printf("Inserting edges ...\n");
    }

    // Construct a map from points to subfaces.
    makepoint2submap(subfaces, idx2shlist, shperverlist);

    // Process the set of input edges.
    for (i = 0; i < in->numberofedges; i++) {
        endpts = &(in->edgelist[(i << 1)]);
        if (endpts[0] == endpts[1]) {
            if (!b->quiet) {
                printf("Warning:  Edge #%d is degenerated. Skipped.\n", i);
            }
            continue; // Skip a degenerated edge.
        }
        // Recall that all existing segments have a default marker '-1'.
        // We assign all identified segments a default marker '-2'.
        edgemarker = in->edgemarkerlist ? in->edgemarkerlist[i] : -2;

        // Find a face contains the edge.
        newseg.sh = NULL;
        searchsh.sh = NULL;
        idx = endpts[0] - in->firstnumber;
        for (j = idx2shlist[idx]; j < idx2shlist[idx + 1]; j++) {
            checkpt = sdest(shperverlist[j]);
            if (pointmark(checkpt) == endpts[1]) {
                searchsh = shperverlist[j];
                break; // Found.
            } else {
                checkpt = sapex(shperverlist[j]);
                if (pointmark(checkpt) == endpts[1]) {
                    senext2(shperverlist[j], searchsh);
                    sesymself(searchsh);
                    break;
                }
            }
        } // j

        if (searchsh.sh != NULL) {
            // Check if this edge is already a segment of the mesh.
            sspivot(searchsh, checkseg);
            if (checkseg.sh != NULL) {
                // This segment already exist.
                newseg = checkseg;
            } else {
                // Create a new segment at this edge.
                pa = sorg(searchsh);
                pb = sdest(searchsh);
                makeshellface(subsegs, &newseg);
                setshvertices(newseg, pa, pb, NULL);
                ssbond(searchsh, newseg);
                spivot(searchsh, neighsh);
                if (neighsh.sh != NULL) {
                    ssbond(neighsh, newseg);
                }
            }
        } else {
            // It is a dangling segment (not belong to any facets).
            // Get the two endpoints of this segment.
            pa = idx2verlist[endpts[0]];
            pb = idx2verlist[endpts[1]];
            if (pa == pb) {
                if (!b->quiet) {
                    printf("Warning:  Edge #%d is degenerated. Skipped.\n", i);
                }
                continue;
            }
            // Check if segment [a,b] already exists.
            // TODO: Change the brute-force search. Slow!
            point* ppt;
            subsegs->traversalinit();
            segloop.sh = shellfacetraverse(subsegs);
            while (segloop.sh != NULL) {
                ppt = (point*)&(segloop.sh[3]);
                if (((ppt[0] == pa) && (ppt[1] == pb)) || ((ppt[0] == pb) && (ppt[1] == pa))) {
                    // Found!
                    newseg = segloop;
                    break;
                }
                segloop.sh = shellfacetraverse(subsegs);
            }
            if (newseg.sh == NULL) {
                makeshellface(subsegs, &newseg);
                setshvertices(newseg, pa, pb, NULL);
            }
        }

        setshellmark(newseg, edgemarker);

        if (b->quality && (in->segmentconstraintlist != (REAL*)NULL)) {
            for (i = 0; i < in->numberofsegmentconstraints; i++) {
                e1 = (int)in->segmentconstraintlist[i * 3];
                e2 = (int)in->segmentconstraintlist[i * 3 + 1];
                if (((pointmark(pa) == e1) && (pointmark(pb) == e2)) ||
                    ((pointmark(pa) == e2) && (pointmark(pb) == e1))) {
                    len = in->segmentconstraintlist[i * 3 + 2];
                    setareabound(newseg, len);
                    break;
                }
            }
        }
    } // i

    delete[] shperverlist;
    delete[] idx2shlist;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// mergefacets()    Merge adjacent facets.                                   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::mergefacets() {
    face parentsh, neighsh, neineish;
    face segloop;
    point pa, pb, pc, pd;
    REAL n1[3], n2[3];
    REAL cosang, cosang_tol;

    // Allocate an array to save calcaulated dihedral angles at segments.
    arraypool* dihedangarray = new arraypool(sizeof(double), 10);
    REAL* paryang = NULL;

    // First, remove coplanar segments.
    // The dihedral angle bound for two different facets.
    cosang_tol = cos(b->facet_separate_ang_tol / 180.0 * PI);

    subsegs->traversalinit();
    segloop.sh = shellfacetraverse(subsegs);
    while (segloop.sh != (shellface*)NULL) {
        // Only remove a segment if it has a marker '-1'.
        if (shellmark(segloop) != -1) {
            segloop.sh = shellfacetraverse(subsegs);
            continue;
        }
        spivot(segloop, parentsh);
        if (parentsh.sh != NULL) {
            spivot(parentsh, neighsh);
            if (neighsh.sh != NULL) {
                spivot(neighsh, neineish);
                if (neineish.sh == parentsh.sh) {
                    // Exactly two subfaces at this segment.
                    // Only merge them if they have the same boundary marker.
                    if (shellmark(parentsh) == shellmark(neighsh)) {
                        pa = sorg(segloop);
                        pb = sdest(segloop);
                        pc = sapex(parentsh);
                        pd = sapex(neighsh);
                        // Calculate the dihedral angle at the segment [a,b].
                        facenormal(pa, pb, pc, n1, 1, NULL);
                        facenormal(pa, pb, pd, n2, 1, NULL);
                        cosang = dot(n1, n2) / (sqrt(dot(n1, n1)) * sqrt(dot(n2, n2)));
                        if (cosang < cosang_tol) {
                            ssdissolve(parentsh);
                            ssdissolve(neighsh);
                            shellfacedealloc(subsegs, segloop.sh);
                            // Add the edge to flip stack.
                            flipshpush(&parentsh);
                        } else {
                            // Save 'cosang' to avoid re-calculate it.
                            // Re-use the pointer at the first segment.
                            dihedangarray->newindex((void**)&paryang);
                            *paryang = cosang;
                            segloop.sh[6] = (shellface)paryang;
                        }
                    }
                } // if (neineish.sh == parentsh.sh)
            }
        }
        segloop.sh = shellfacetraverse(subsegs);
    }

    // Second, remove ridge segments at small angles.
    // The dihedral angle bound for two different facets.
    cosang_tol = cos(b->facet_small_ang_tol / 180.0 * PI);
    REAL cosang_sep_tol = cos((b->facet_separate_ang_tol - 5.0) / 180.0 * PI);
    face shloop;
    face seg1, seg2;
    REAL cosang1, cosang2;
    int i, j;

    subfaces->traversalinit();
    shloop.sh = shellfacetraverse(subfaces);
    while (shloop.sh != (shellface*)NULL) {
        for (i = 0; i < 3; i++) {
            if (isshsubseg(shloop)) {
                senext(shloop, neighsh);
                if (isshsubseg(neighsh)) {
                    // Found two segments sharing at one vertex.
                    // Check if they form a small angle.
                    pa = sorg(shloop);
                    pb = sdest(shloop);
                    pc = sapex(shloop);
                    for (j = 0; j < 3; j++)
                        n1[j] = pa[j] - pb[j];
                    for (j = 0; j < 3; j++)
                        n2[j] = pc[j] - pb[j];
                    cosang = dot(n1, n2) / (sqrt(dot(n1, n1)) * sqrt(dot(n2, n2)));
                    if (cosang > cosang_tol) {
                        // Found a small angle.
                        segloop.sh = NULL;
                        sspivot(shloop, seg1);
                        sspivot(neighsh, seg2);
                        if (seg1.sh[6] != NULL) {
                            paryang = (REAL*)(seg1.sh[6]);
                            cosang1 = *paryang;
                        } else {
                            cosang1 = 1.0; // 0 degree;
                        }
                        if (seg2.sh[6] != NULL) {
                            paryang = (REAL*)(seg2.sh[6]);
                            cosang2 = *paryang;
                        } else {
                            cosang2 = 1.0; // 0 degree;
                        }
                        if (cosang1 < cosang_sep_tol) {
                            if (cosang2 < cosang_sep_tol) {
                                if (cosang1 < cosang2) {
                                    segloop = seg1;
                                } else {
                                    segloop = seg2;
                                }
                            } else {
                                segloop = seg1;
                            }
                        } else {
                            if (cosang2 < cosang_sep_tol) {
                                segloop = seg2;
                            }
                        }
                        if (segloop.sh != NULL) {
                            // Remove this segment.
                            segloop.shver = 0;
                            spivot(segloop, parentsh);
                            spivot(parentsh, neighsh);
                            ssdissolve(parentsh);
                            ssdissolve(neighsh);
                            shellfacedealloc(subsegs, segloop.sh);
                            // Add the edge to flip stack.
                            flipshpush(&parentsh);
                            break;
                        }
                    }
                } // if (isshsubseg)
            }     // if (isshsubseg)
            senextself(shloop);
        }
        shloop.sh = shellfacetraverse(subfaces);
    }

    delete dihedangarray;

    if (flipstack != NULL) {
        lawsonflip(); // Recover Delaunayness.
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// meshsurface()    Create a surface mesh of the input PLC.                  //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::meshsurface() {
    arraypool *ptlist, *conlist;
    point* idx2verlist;
    point tstart, tend, *pnewpt, *cons;
    tetgenio::facet* f;
    tetgenio::polygon* p;
    int end1, end2;
    int shmark, i, j;

    if (!b->quiet) {
        printf("Creating surface mesh ...\n");
    }

    // Create a map from indices to points.
    makeindex2pointmap(idx2verlist);

    // Initialize arrays (block size: 2^8 = 256).
    ptlist = new arraypool(sizeof(point*), 8);
    conlist = new arraypool(2 * sizeof(point*), 8);

    // Loop the facet list, triangulate each facet.
    for (shmark = 1; shmark <= in->numberoffacets; shmark++) {

        // Get a facet F.
        f = &in->facetlist[shmark - 1];

        // Process the duplicated points first, they are marked with type
        //   DUPLICATEDVERTEX.  If p and q are duplicated, and p'index > q's,
        //   then p is substituted by q.
        if (dupverts > 0l) {
            // Loop all polygons of this facet.
            for (i = 0; i < f->numberofpolygons; i++) {
                p = &(f->polygonlist[i]);
                // Loop other vertices of this polygon.
                for (j = 0; j < p->numberofvertices; j++) {
                    end1 = p->vertexlist[j];
                    tstart = idx2verlist[end1];
                    if (pointtype(tstart) == DUPLICATEDVERTEX) {
                        // Reset the index of vertex-j.
                        tend = point2ppt(tstart);
                        end2 = pointmark(tend);
                        p->vertexlist[j] = end2;
                    }
                }
            }
        }

        // Loop polygons of F, get the set of vertices and segments.
        for (i = 0; i < f->numberofpolygons; i++) {
            // Get a polygon.
            p = &(f->polygonlist[i]);
            // Get the first vertex.
            end1 = p->vertexlist[0];
            if ((end1 < in->firstnumber) || (end1 >= in->firstnumber + in->numberofpoints)) {
                if (!b->quiet) {
                    printf("Warning:  Invalid the 1st vertex %d of polygon", end1);
                    printf(" %d in facet %d.\n", i + 1, shmark);
                }
                continue; // Skip this polygon.
            }
            tstart = idx2verlist[end1];
            // Add tstart to V if it haven't been added yet.
            if (!pinfected(tstart)) {
                pinfect(tstart);
                ptlist->newindex((void**)&pnewpt);
                *pnewpt = tstart;
            }
            // Loop other vertices of this polygon.
            for (j = 1; j <= p->numberofvertices; j++) {
                // get a vertex.
                if (j < p->numberofvertices) {
                    end2 = p->vertexlist[j];
                } else {
                    end2 = p->vertexlist[0]; // Form a loop from last to first.
                }
                if ((end2 < in->firstnumber) || (end2 >= in->firstnumber + in->numberofpoints)) {
                    if (!b->quiet) {
                        printf("Warning:  Invalid vertex %d in polygon %d", end2, i + 1);
                        printf(" in facet %d.\n", shmark);
                    }
                } else {
                    if (end1 != end2) {
                        // 'end1' and 'end2' form a segment.
                        tend = idx2verlist[end2];
                        // Add tstart to V if it haven't been added yet.
                        if (!pinfected(tend)) {
                            pinfect(tend);
                            ptlist->newindex((void**)&pnewpt);
                            *pnewpt = tend;
                        }
                        // Save the segment in S (conlist).
                        conlist->newindex((void**)&cons);
                        cons[0] = tstart;
                        cons[1] = tend;
                        // Set the start for next continuous segment.
                        end1 = end2;
                        tstart = tend;
                    } else {
                        // Two identical vertices mean an isolated vertex of F.
                        if (p->numberofvertices > 2) {
                            // This may be an error in the input, anyway, we can continue
                            //   by simply skipping this segment.
                            if (!b->quiet) {
                                printf("Warning:  Polygon %d has two identical verts", i + 1);
                                printf(" in facet %d.\n", shmark);
                            }
                        }
                        // Ignore this vertex.
                    }
                }
                // Is the polygon degenerate (a segment or a vertex)?
                if (p->numberofvertices == 2) break;
            }
        }
        // Unmark vertices.
        for (i = 0; i < ptlist->objects; i++) {
            pnewpt = (point*)fastlookup(ptlist, i);
            puninfect(*pnewpt);
        }

        // Triangulate F into a CDT.
        // If in->facetmarklist is NULL, use the default marker -1.
        triangulate(in->facetmarkerlist ? in->facetmarkerlist[shmark - 1] : -1, ptlist, conlist,
                    f->numberofholes, f->holelist);

        // Clear working lists.
        ptlist->restart();
        conlist->restart();
    }

    if (!b->diagnose) {
        // Remove redundant segments and build the face links.
        unifysegments();
        if (in->numberofedges > 0) {
            // There are input segments. Insert them.
            identifyinputedges(idx2verlist);
        }
        if (!b->psc && !b->nomergefacet &&
            (!b->nobisect || (b->nobisect && !b->nobisect_nomerge))) {
            // Merge coplanar facets.
            mergefacets();
        }
    }

    if (b->object == tetgenbehavior::STL) {
        // Remove redundant vertices (for .stl input mesh).
        jettisonnodes();
    }

    if (b->verbose) {
        printf("  %ld (%ld) subfaces (segments).\n", subfaces->items, subsegs->items);
    }

    // The total number of iunput segments.
    insegments = subsegs->items;

    delete[] idx2verlist;
    delete ptlist;
    delete conlist;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// interecursive()    Recursively do intersection test on a set of triangles.//
//                                                                           //
// Recursively split the set 'subfacearray' of subfaces into two sets using  //
// a cut plane parallel to x-, or, y-, or z-axis.  The split criteria are    //
// follows. Assume the cut plane is H, and H+ denotes the left halfspace of  //
// H, and H- denotes the right halfspace of H; and s be a subface:           //
//                                                                           //
//    (1) If all points of s lie at H+, put it into left array;              //
//    (2) If all points of s lie at H-, put it into right array;             //
//    (3) If some points of s lie at H+ and some of lie at H-, or some       //
//        points lie on H, put it into both arraies.                         //
//                                                                           //
// Partitions by x-axis if axis == '0'; by y-axis if axis == '1'; by z-axis  //
// if axis == '2'. If current cut plane is parallel to the x-axis, the next  //
// one will be parallel to y-axis, and the next one after the next is z-axis,//
// and then alternately return back to x-axis.                               //
//                                                                           //
// Stop splitting when the number of triangles of the input array is not     //
// decreased anymore. Do tests on the current set.                           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::interecursive(shellface** subfacearray, int arraysize, int axis, REAL bxmin,
                               REAL bxmax, REAL bymin, REAL bymax, REAL bzmin, REAL bzmax,
                               int* internum) {
    shellface **leftarray, **rightarray;
    face sface1, sface2;
    point p1, p2, p3;
    point p4, p5, p6;
    enum interresult intersect;
    REAL split;
    bool toleft, toright;
    int leftsize, rightsize;
    int i, j;

    if (b->verbose > 2) {
        printf("      Recur %d faces. Bbox (%g, %g, %g),(%g, %g, %g). %s-axis\n", arraysize, bxmin,
               bymin, bzmin, bxmax, bymax, bzmax, axis == 0 ? "x" : (axis == 1 ? "y" : "z"));
    }

    leftarray = new shellface*[arraysize];
    if (leftarray == NULL) {
        terminatetetgen(this, 1);
    }
    rightarray = new shellface*[arraysize];
    if (rightarray == NULL) {
        terminatetetgen(this, 1);
    }
    leftsize = rightsize = 0;

    if (axis == 0) {
        // Split along x-axis.
        split = 0.5 * (bxmin + bxmax);
    } else if (axis == 1) {
        // Split along y-axis.
        split = 0.5 * (bymin + bymax);
    } else {
        // Split along z-axis.
        split = 0.5 * (bzmin + bzmax);
    }

    for (i = 0; i < arraysize; i++) {
        sface1.sh = subfacearray[i];
        p1 = (point)sface1.sh[3];
        p2 = (point)sface1.sh[4];
        p3 = (point)sface1.sh[5];
        toleft = toright = false;
        if (p1[axis] < split) {
            toleft = true;
            if (p2[axis] >= split || p3[axis] >= split) {
                toright = true;
            }
        } else if (p1[axis] > split) {
            toright = true;
            if (p2[axis] <= split || p3[axis] <= split) {
                toleft = true;
            }
        } else {
            // p1[axis] == split;
            toleft = true;
            toright = true;
        }
        if (toleft) {
            leftarray[leftsize] = sface1.sh;
            leftsize++;
        }
        if (toright) {
            rightarray[rightsize] = sface1.sh;
            rightsize++;
        }
    }

    if (leftsize < arraysize && rightsize < arraysize) {
        // Continue to partition the input set. Now 'subfacearray' has been
        //   split into two sets, it's memory can be freed. 'leftarray' and
        //   'rightarray' will be freed in the next recursive (after they're
        //   partitioned again or performing tests).
        delete[] subfacearray;
        // Continue to split these two sets.
        if (axis == 0) {
            interecursive(leftarray, leftsize, 1, bxmin, split, bymin, bymax, bzmin, bzmax,
                          internum);
            interecursive(rightarray, rightsize, 1, split, bxmax, bymin, bymax, bzmin, bzmax,
                          internum);
        } else if (axis == 1) {
            interecursive(leftarray, leftsize, 2, bxmin, bxmax, bymin, split, bzmin, bzmax,
                          internum);
            interecursive(rightarray, rightsize, 2, bxmin, bxmax, split, bymax, bzmin, bzmax,
                          internum);
        } else {
            interecursive(leftarray, leftsize, 0, bxmin, bxmax, bymin, bymax, bzmin, split,
                          internum);
            interecursive(rightarray, rightsize, 0, bxmin, bxmax, bymin, bymax, split, bzmax,
                          internum);
        }
    } else {
        if (b->verbose > 1) {
            printf("  Checking intersecting faces.\n");
        }
        // Perform a brute-force compare on the set.
        for (i = 0; i < arraysize; i++) {
            sface1.sh = subfacearray[i];
            p1 = (point)sface1.sh[3];
            p2 = (point)sface1.sh[4];
            p3 = (point)sface1.sh[5];
            for (j = i + 1; j < arraysize; j++) {
                sface2.sh = subfacearray[j];
                p4 = (point)sface2.sh[3];
                p5 = (point)sface2.sh[4];
                p6 = (point)sface2.sh[5];
                intersect = (enum interresult)tri_tri_inter(p1, p2, p3, p4, p5, p6);
                if (intersect == INTERSECT || intersect == SHAREFACE) {
                    if (!b->quiet) {
                        if (intersect == INTERSECT) {
                            printf("  Facet #%d intersects facet #%d at triangles:\n",
                                   shellmark(sface1), shellmark(sface2));
                            printf("    (%4d, %4d, %4d) and (%4d, %4d, %4d)\n", pointmark(p1),
                                   pointmark(p2), pointmark(p3), pointmark(p4), pointmark(p5),
                                   pointmark(p6));
                        } else {
                            printf("  Facet #%d duplicates facet #%d at triangle:\n",
                                   shellmark(sface1), shellmark(sface2));
                            printf("    (%4d, %4d, %4d) and (%4d, %4d, %4d)\n", pointmark(p1),
                                   pointmark(p2), pointmark(p3), pointmark(p4), pointmark(p5),
                                   pointmark(p6));
                        }
                    }
                    // Increase the number of intersecting pairs.
                    (*internum)++;
                    // Infect these two faces (although they may already be infected).
                    sinfect(sface1);
                    sinfect(sface2);
                }
            }
        }
        // Don't forget to free all three arrays. No further partition.
        delete[] leftarray;
        delete[] rightarray;
        delete[] subfacearray;
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// detectinterfaces()    Detect intersecting triangles.                      //
//                                                                           //
// Given a set of triangles,  find the pairs of intersecting triangles from  //
// them.  Here the set of triangles is in 'subfaces' which is a surface mesh //
// of a PLC (.poly or .smesh).                                               //
//                                                                           //
// To detect whether two triangles are intersecting is done by the routine   //
// 'tri_tri_inter()'.  The algorithm for the test is very simple and stable. //
// It is based on geometric orientation test which uses exact arithmetics.   //
//                                                                           //
// Use divide-and-conquer algorithm for reducing the number of intersection  //
// tests.  Start from the bounding box of the input point set, recursively   //
// partition the box into smaller boxes, until the number of triangles in a  //
// box is not decreased anymore. Then perform triangle-triangle tests on the //
// remaining set of triangles.  The memory allocated in the input set is     //
// freed immediately after it has been partitioned into two arrays.  So it   //
// can be re-used for the consequent partitions.                             //
//                                                                           //
// On return, the pool 'subfaces' will be cleared, and only the intersecting //
// triangles remain for output (to a .face file).                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::detectinterfaces() {
    shellface** subfacearray;
    face shloop;
    int internum;
    int i;

    if (!b->quiet) {
        printf("Detecting self-intersecting facets...\n");
    }

    // Construct a map from indices to subfaces;
    subfacearray = new shellface*[subfaces->items];
    subfaces->traversalinit();
    shloop.sh = shellfacetraverse(subfaces);
    i = 0;
    while (shloop.sh != (shellface*)NULL) {
        subfacearray[i] = shloop.sh;
        shloop.sh = shellfacetraverse(subfaces);
        i++;
    }

    internum = 0;
    // Recursively split the set of triangles into two sets using a cut plane
    //   parallel to x-, or, y-, or z-axis.  Stop splitting when the number
    //   of subfaces is not decreasing anymore. Do tests on the current set.
    interecursive(subfacearray, subfaces->items, 0, xmin, xmax, ymin, ymax, zmin, zmax, &internum);

    if (!b->quiet) {
        if (internum > 0) {
            printf("\n!! Found %d pairs of faces are intersecting.\n\n", internum);
        } else {
            printf("\nNo faces are intersecting.\n\n");
        }
    }

    if (internum > 0) {
        // Traverse all subfaces, deallocate those have not been infected (they
        //   are not intersecting faces). Uninfect those have been infected.
        //   After this loop, only intersecting faces remain.
        subfaces->traversalinit();
        shloop.sh = shellfacetraverse(subfaces);
        while (shloop.sh != (shellface*)NULL) {
            if (sinfected(shloop)) {
                suninfect(shloop);
            } else {
                shellfacedealloc(subfaces, shloop.sh);
            }
            shloop.sh = shellfacetraverse(subfaces);
        }
    } else {
        // Deallocate all subfaces.
        subfaces->restart();
    }
}

////                                                                       ////
////                                                                       ////
//// surface_cxx //////////////////////////////////////////////////////////////

//// constrained_cxx //////////////////////////////////////////////////////////
////                                                                       ////
////                                                                       ////

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// makesegmentendpointsmap()    Create a map from a segment to its endpoints.//
//                                                                           //
// The map is saved in the array 'segmentendpointslist'. The length of this  //
// array is twice the number of segments.  Each segment is assigned a unique //
// index (starting from 0).                                                  //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::makesegmentendpointsmap() {
    arraypool* segptlist;
    face segloop, prevseg, nextseg;
    point eorg, edest, *parypt;
    int segindex = 0, idx = 0;
    int i;

    if (b->verbose > 0) {
        printf("  Creating the segment-endpoints map.\n");
    }

    segptlist = new arraypool(2 * sizeof(point), 10);

    // A segment s may have been split into many subsegments. Operate the one
    //   which contains the origin of s. Then mark the rest of subsegments.
    subsegs->traversalinit();
    segloop.sh = shellfacetraverse(subsegs);
    segloop.shver = 0;
    while (segloop.sh != NULL) {
        senext2(segloop, prevseg);
        spivotself(prevseg);
        if (prevseg.sh == NULL) {
            eorg = sorg(segloop);
            edest = sdest(segloop);
            setfacetindex(segloop, segindex);
            senext(segloop, nextseg);
            spivotself(nextseg);
            while (nextseg.sh != NULL) {
                setfacetindex(nextseg, segindex);
                nextseg.shver = 0;
                if (sorg(nextseg) != edest) sesymself(nextseg);
                edest = sdest(nextseg);
                // Go the next connected subsegment at edest.
                senextself(nextseg);
                spivotself(nextseg);
            }
            segptlist->newindex((void**)&parypt);
            parypt[0] = eorg;
            parypt[1] = edest;
            segindex++;
        }
        segloop.sh = shellfacetraverse(subsegs);
    }

    if (b->verbose) {
        printf("  Found %ld segments.\n", segptlist->objects);
    }

    segmentendpointslist = new point[segptlist->objects * 2];

    totalworkmemory += (segptlist->objects * 2) * sizeof(point*);

    for (i = 0; i < segptlist->objects; i++) {
        parypt = (point*)fastlookup(segptlist, i);
        segmentendpointslist[idx++] = parypt[0];
        segmentendpointslist[idx++] = parypt[1];
    }

    delete segptlist;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// finddirection()    Find the tet on the path from one point to another.    //
//                                                                           //
// The path starts from 'searchtet''s origin and ends at 'endpt'. On finish, //
// 'searchtet' contains a tet on the path, its origin does not change.       //
//                                                                           //
// The return value indicates one of the following cases (let 'searchtet' be //
// abcd, a is the origin of the path):                                       //
//   - ACROSSVERT, edge ab is collinear with the path;                       //
//   - ACROSSEDGE, edge bc intersects with the path;                         //
//   - ACROSSFACE, face bcd intersects with the path.                        //
//                                                                           //
// WARNING: This routine is designed for convex triangulations, and will not //
// generally work after the holes and concavities have been carved.          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

enum tetgenmesh::interresult tetgenmesh::finddirection(triface* searchtet, point endpt) {
    triface neightet;
    point pa, pb, pc, pd;
    enum { HMOVE, RMOVE, LMOVE } nextmove;
    REAL hori, rori, lori;
    int t1ver;
    int s;

    // The origin is fixed.
    pa = org(*searchtet);
    if ((point)searchtet->tet[7] == dummypoint) {
        // A hull tet. Choose the neighbor of its base face.
        decode(searchtet->tet[3], *searchtet);
        // Reset the origin to be pa.
        if ((point)searchtet->tet[4] == pa) {
            searchtet->ver = 11;
        } else if ((point)searchtet->tet[5] == pa) {
            searchtet->ver = 3;
        } else if ((point)searchtet->tet[6] == pa) {
            searchtet->ver = 7;
        } else {
            searchtet->ver = 0;
        }
    }

    pb = dest(*searchtet);
    // Check whether the destination or apex is 'endpt'.
    if (pb == endpt) {
        // pa->pb is the search edge.
        return ACROSSVERT;
    }

    pc = apex(*searchtet);
    if (pc == endpt) {
        // pa->pc is the search edge.
        eprevesymself(*searchtet);
        return ACROSSVERT;
    }

    // Walk through tets around pa until the right one is found.
    while (1) {

        pd = oppo(*searchtet);
        // Check whether the opposite vertex is 'endpt'.
        if (pd == endpt) {
            // pa->pd is the search edge.
            esymself(*searchtet);
            enextself(*searchtet);
            return ACROSSVERT;
        }
        // Check if we have entered outside of the domain.
        if (pd == dummypoint) {
            // This is possible when the mesh is non-convex.
            if (nonconvex) {
                return ACROSSFACE; // return ACROSSSUB; // Hit a bounday.
            } else {
                terminatetetgen(this, 2);
            }
        }

        // Now assume that the base face abc coincides with the horizon plane,
        //   and d lies above the horizon.  The search point 'endpt' may lie
        //   above or below the horizon.  We test the orientations of 'endpt'
        //   with respect to three planes: abc (horizon), bad (right plane),
        //   and acd (left plane).
        hori = orient3d(pa, pb, pc, endpt);
        rori = orient3d(pb, pa, pd, endpt);
        lori = orient3d(pa, pc, pd, endpt);

        // Now decide the tet to move.  It is possible there are more than one
        //   tets are viable moves. Is so, randomly choose one.
        if (hori > 0) {
            if (rori > 0) {
                if (lori > 0) {
                    // Any of the three neighbors is a viable move.
                    s = randomnation(3);
                    if (s == 0) {
                        nextmove = HMOVE;
                    } else if (s == 1) {
                        nextmove = RMOVE;
                    } else {
                        nextmove = LMOVE;
                    }
                } else {
                    // Two tets, below horizon and below right, are viable.
                    if (randomnation(2)) {
                        nextmove = HMOVE;
                    } else {
                        nextmove = RMOVE;
                    }
                }
            } else {
                if (lori > 0) {
                    // Two tets, below horizon and below left, are viable.
                    if (randomnation(2)) {
                        nextmove = HMOVE;
                    } else {
                        nextmove = LMOVE;
                    }
                } else {
                    // The tet below horizon is chosen.
                    nextmove = HMOVE;
                }
            }
        } else {
            if (rori > 0) {
                if (lori > 0) {
                    // Two tets, below right and below left, are viable.
                    if (randomnation(2)) {
                        nextmove = RMOVE;
                    } else {
                        nextmove = LMOVE;
                    }
                } else {
                    // The tet below right is chosen.
                    nextmove = RMOVE;
                }
            } else {
                if (lori > 0) {
                    // The tet below left is chosen.
                    nextmove = LMOVE;
                } else {
                    // 'endpt' lies either on the plane(s) or across face bcd.
                    if (hori == 0) {
                        if (rori == 0) {
                            // pa->'endpt' is COLLINEAR with pa->pb.
                            return ACROSSVERT;
                        }
                        if (lori == 0) {
                            // pa->'endpt' is COLLINEAR with pa->pc.
                            eprevesymself(*searchtet); // [a,c,d]
                            return ACROSSVERT;
                        }
                        // pa->'endpt' crosses the edge pb->pc.
                        return ACROSSEDGE;
                    }
                    if (rori == 0) {
                        if (lori == 0) {
                            // pa->'endpt' is COLLINEAR with pa->pd.
                            esymself(*searchtet);  // face bad.
                            enextself(*searchtet); // face [a,d,b]
                            return ACROSSVERT;
                        }
                        // pa->'endpt' crosses the edge pb->pd.
                        esymself(*searchtet);  // face bad.
                        enextself(*searchtet); // face adb
                        return ACROSSEDGE;
                    }
                    if (lori == 0) {
                        // pa->'endpt' crosses the edge pc->pd.
                        eprevesymself(*searchtet); // [a,c,d]
                        return ACROSSEDGE;
                    }
                    // pa->'endpt' crosses the face bcd.
                    return ACROSSFACE;
                }
            }
        }

        // Move to the next tet, fix pa as its origin.
        if (nextmove == RMOVE) {
            fnextself(*searchtet);
        } else if (nextmove == LMOVE) {
            eprevself(*searchtet);
            fnextself(*searchtet);
            enextself(*searchtet);
        } else { // HMOVE
            fsymself(*searchtet);
            enextself(*searchtet);
        }
        pb = dest(*searchtet);
        pc = apex(*searchtet);

    } // while (1)
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// scoutsegment()    Search an edge in the tetrahedralization.               //
//                                                                           //
// If the edge is found, it returns SHAREEDGE, and 'searchtet' returns the   //
// edge from startpt to endpt.                                               //
//                                                                           //
// If the edge is missing, it returns either ACROSSEDGE or ACROSSFACE, which //
// indicates that the edge intersects an edge or a face.  If 'refpt' is NULL,//
// 'searchtet' returns the edge or face. If 'refpt' is not NULL, it returns  //
// a vertex which encroaches upon this edge, and 'searchtet' returns a tet   //
// which containing 'refpt'.                                                 //
//                                                                           //
// The parameter 'sedge' is used to report self-intersection. It is the      //
// whose endpoints are 'startpt' and 'endpt'. It must not be a NULL.
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

enum tetgenmesh::interresult tetgenmesh::scoutsegment(point startpt, point endpt, face* sedge,
                                                      triface* searchtet, point* refpt,
                                                      arraypool* intfacelist) {
    point pd;
    enum interresult dir;
    int t1ver;

    if (b->verbose > 2) {
        printf("      Scout seg (%d, %d).\n", pointmark(startpt), pointmark(endpt));
    }

    point2tetorg(startpt, *searchtet);
    dir = finddirection(searchtet, endpt);

    if (dir == ACROSSVERT) {
        pd = dest(*searchtet);
        if (pd == endpt) {
            if (issubseg(*searchtet)) {
                report_selfint_edge(startpt, endpt, sedge, searchtet, dir);
            }
            return SHAREEDGE;
        } else {
            // A point is on the path.
            report_selfint_edge(startpt, endpt, sedge, searchtet, dir);
            return ACROSSVERT;
        }
    }

    // dir is either ACROSSEDGE or ACROSSFACE.
    enextesymself(*searchtet); // Go to the opposite face.
    fsymself(*searchtet);      // Enter the adjacent tet.

    if (dir == ACROSSEDGE) {
        // Check whether two segments are intersecting.
        if (issubseg(*searchtet)) {
            report_selfint_edge(startpt, endpt, sedge, searchtet, dir);
        }
    } else if (dir == ACROSSFACE) {
        if (checksubfaceflag) {
            // Check whether a segment and a subface are intersecting.
            if (issubface(*searchtet)) {
                report_selfint_edge(startpt, endpt, sedge, searchtet, dir);
            }
        }
    } else {
        terminatetetgen(this, 2);
    }

    if (refpt == NULL) {
        // Do not need a reference point. Return.
        return dir;
    }

    triface neightet, reftet;
    point pa, pb, pc;
    REAL angmax, ang;
    int types[2], poss[4];
    int pos = 0, i, j;

    pa = org(*searchtet);
    angmax = interiorangle(pa, startpt, endpt, NULL);
    *refpt = pa;
    pb = dest(*searchtet);
    ang = interiorangle(pb, startpt, endpt, NULL);
    if (ang > angmax) {
        angmax = ang;
        *refpt = pb;
    }
    pc = apex(*searchtet);
    ang = interiorangle(pc, startpt, endpt, NULL);
    if (ang > angmax) {
        angmax = ang;
        *refpt = pc;
    }
    reftet = *searchtet; // Save the tet containing the refpt.

    // Search intersecting faces along the segment.
    while (1) {

        pd = oppo(*searchtet);

        // Stop if we meet 'endpt'.
        if (pd == endpt) break;

        ang = interiorangle(pd, startpt, endpt, NULL);
        if (ang > angmax) {
            angmax = ang;
            *refpt = pd;
            reftet = *searchtet;
        }

        // Find a face intersecting the segment.
        if (dir == ACROSSFACE) {
            // One of the three oppo faces in 'searchtet' intersects the segment.
            neightet = *searchtet;
            j = (neightet.ver & 3); // j is the current face number.
            for (i = j + 1; i < j + 4; i++) {
                neightet.ver = (i % 4);
                pa = org(neightet);
                pb = dest(neightet);
                pc = apex(neightet);
                pd = oppo(neightet); // The above point.
                if (tri_edge_test(pa, pb, pc, startpt, endpt, pd, 1, types, poss)) {
                    dir = (enum interresult)types[0];
                    pos = poss[0];
                    break;
                } else {
                    dir = DISJOINT;
                    pos = 0;
                }
            }
        } else if (dir == ACROSSEDGE) {
            // Check the two opposite faces (of the edge) in 'searchtet'.
            for (i = 0; i < 2; i++) {
                if (i == 0) {
                    enextesym(*searchtet, neightet);
                } else {
                    eprevesym(*searchtet, neightet);
                }
                pa = org(neightet);
                pb = dest(neightet);
                pc = apex(neightet);
                pd = oppo(neightet); // The above point.
                if (tri_edge_test(pa, pb, pc, startpt, endpt, pd, 1, types, poss)) {
                    dir = (enum interresult)types[0];
                    pos = poss[0];
                    break;
                } else {
                    dir = DISJOINT;
                    pos = 0;
                }
            }
            if (dir == DISJOINT) {
                // No intersection. Rotate to the next tet at the edge.
                dir = ACROSSEDGE;
                fnextself(*searchtet);
                continue;
            }
        }

        if (dir == ACROSSVERT) {
            // This segment passing a vertex. Choose it and return.
            for (i = 0; i < pos; i++) {
                enextself(neightet);
            }
            eprev(neightet, *searchtet);
            // dest(*searchtet) lies on the segment.
            report_selfint_edge(startpt, endpt, sedge, searchtet, dir);
            return ACROSSVERT;
        } else if (dir == ACROSSEDGE) {
            // Get the edge intersects with the segment.
            for (i = 0; i < pos; i++) {
                enextself(neightet);
            }
        }
        // Go to the next tet.
        fsym(neightet, *searchtet);

        if (dir == ACROSSEDGE) {
            // Check whether two segments are intersecting.
            if (issubseg(*searchtet)) {
                report_selfint_edge(startpt, endpt, sedge, searchtet, dir);
            }
        } else if (dir == ACROSSFACE) {
            if (checksubfaceflag) {
                // Check whether a segment and a subface are intersecting.
                if (issubface(*searchtet)) {
                    report_selfint_edge(startpt, endpt, sedge, searchtet, dir);
                }
            }
        } else {
            terminatetetgen(this, 2);
        }

    } // while (1)

    // A valid reference point should inside the diametrial circumsphere of
    //   the missing segment, i.e., it encroaches upon it.
    if (2.0 * angmax < PI) {
        *refpt = NULL;
    }

    *searchtet = reftet;
    return dir;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// getsteinerpointonsegment()    Get a Steiner point on a segment.           //
//                                                                           //
// Return '1' if 'refpt' lies on an adjacent segment of this segment. Other- //
// wise, return '0'.                                                         //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::getsteinerptonsegment(face* seg, point refpt, point steinpt) {
    point ei = sorg(*seg);
    point ej = sdest(*seg);
    int adjflag = 0, i;

    if (refpt != NULL) {
        REAL L, L1, t;

        if (pointtype(refpt) == FREESEGVERTEX) {
            face parentseg;
            sdecode(point2sh(refpt), parentseg);
            int sidx1 = getfacetindex(parentseg);
            point far_pi = segmentendpointslist[sidx1 * 2];
            point far_pj = segmentendpointslist[sidx1 * 2 + 1];
            int sidx2 = getfacetindex(*seg);
            point far_ei = segmentendpointslist[sidx2 * 2];
            point far_ej = segmentendpointslist[sidx2 * 2 + 1];
            if ((far_pi == far_ei) || (far_pj == far_ei)) {
                // Create a Steiner point at the intersection of the segment
                //   [far_ei, far_ej] and the sphere centered at far_ei with
                //   radius |far_ei - refpt|.
                L = distance(far_ei, far_ej);
                L1 = distance(far_ei, refpt);
                t = L1 / L;
                for (i = 0; i < 3; i++) {
                    steinpt[i] = far_ei[i] + t * (far_ej[i] - far_ei[i]);
                }
                adjflag = 1;
            } else if ((far_pi == far_ej) || (far_pj == far_ej)) {
                L = distance(far_ei, far_ej);
                L1 = distance(far_ej, refpt);
                t = L1 / L;
                for (i = 0; i < 3; i++) {
                    steinpt[i] = far_ej[i] + t * (far_ei[i] - far_ej[i]);
                }
                adjflag = 1;
            } else {
                // Cut the segment by the projection point of refpt.
                projpt2edge(refpt, ei, ej, steinpt);
            }
        } else {
            // Cut the segment by the projection point of refpt.
            projpt2edge(refpt, ei, ej, steinpt);
        }

        // Make sure that steinpt is not too close to ei and ej.
        L = distance(ei, ej);
        L1 = distance(steinpt, ei);
        t = L1 / L;
        if ((t < 0.2) || (t > 0.8)) {
            // Split the point at the middle.
            for (i = 0; i < 3; i++) {
                steinpt[i] = ei[i] + 0.5 * (ej[i] - ei[i]);
            }
        }
    } else {
        // Split the point at the middle.
        for (i = 0; i < 3; i++) {
            steinpt[i] = ei[i] + 0.5 * (ej[i] - ei[i]);
        }
    }

    return adjflag;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// delaunizesegments()    Recover segments in a DT.                          //
//                                                                           //
// All segments need to be recovered are in 'subsegstack' (Q).  They will be //
// be recovered one by one (in a random order).                              //
//                                                                           //
// Given a segment s in the Q, this routine first queries s in the DT, if s  //
// matches an edge in DT, it is 'locked' at the edge. Otherwise, s is split  //
// by inserting a new point p in both the DT and itself. The two new subseg- //
// ments of s are queued in Q.  The process continues until Q is empty.      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::delaunizesegments() {
    triface searchtet, spintet;
    face searchsh;
    face sseg, *psseg;
    point refpt, newpt;
    enum interresult dir;
    insertvertexflags ivf;
    int t1ver;

    ivf.bowywat = 1;        // Use Bowyer-Watson insertion.
    ivf.sloc = (int)ONEDGE; // on 'sseg'.
    ivf.sbowywat = 1;       // Use Bowyer-Watson insertion.
    ivf.assignmeshsize = b->metric;
    ivf.smlenflag = useinsertradius; // Return the closet mesh vertex.

    // Loop until 'subsegstack' is empty.
    while (subsegstack->objects > 0l) {
        // seglist is used as a stack.
        subsegstack->objects--;
        psseg = (face*)fastlookup(subsegstack, subsegstack->objects);
        sseg = *psseg;

        // Check if this segment has been recovered.
        sstpivot1(sseg, searchtet);
        if (searchtet.tet != NULL) {
            continue; // Not a missing segment.
        }

        // Search the segment.
        dir = scoutsegment(sorg(sseg), sdest(sseg), &sseg, &searchtet, &refpt, NULL);

        if (dir == SHAREEDGE) {
            // Found this segment, insert it.
            // Let the segment remember an adjacent tet.
            sstbond1(sseg, searchtet);
            // Bond the segment to all tets containing it.
            spintet = searchtet;
            do {
                tssbond1(spintet, sseg);
                fnextself(spintet);
            } while (spintet.tet != searchtet.tet);
        } else {
            if ((dir == ACROSSFACE) || (dir == ACROSSEDGE)) {
                // The segment is missing. Split it.
                // Create a new point.
                makepoint(&newpt, FREESEGVERTEX);
                // setpointtype(newpt, FREESEGVERTEX);
                getsteinerptonsegment(&sseg, refpt, newpt);

                // Start searching from 'searchtet'.
                ivf.iloc = (int)OUTSIDE;
                // Insert the new point into the tetrahedralization T.
                //   Missing segments and subfaces are queued for recovery.
                //   Note that T is convex (nonconvex = 0).
                if (insertpoint(newpt, &searchtet, &searchsh, &sseg, &ivf)) {
                    // The new point has been inserted.
                    st_segref_count++;
                    if (steinerleft > 0) steinerleft--;
                    if (useinsertradius) {
                        save_segmentpoint_insradius(newpt, ivf.parentpt, ivf.smlen);
                    }
                } else {
                    if (ivf.iloc == (int)NEARVERTEX) {
                        // The new point (in the segment) is very close to an existing
                        //   vertex -- a small feature is detected.
                        point nearpt = org(searchtet);
                        if (pointtype(nearpt) == FREESEGVERTEX) {
                            face parentseg;
                            sdecode(point2sh(nearpt), parentseg);
                            point p1 = farsorg(sseg);
                            point p2 = farsdest(sseg);
                            point p3 = farsorg(parentseg);
                            point p4 = farsdest(parentseg);
                            printf("Two segments are very close to each other.\n");
                            printf("  Segment 1: [%d, %d] #%d\n", pointmark(p1), pointmark(p2),
                                   shellmark(sseg));
                            printf("  Segment 2: [%d, %d] #%d\n", pointmark(p3), pointmark(p4),
                                   shellmark(parentseg));
                            terminatetetgen(this, 4);
                        } else {
                            terminatetetgen(this, 2);
                        }
                    } else if (ivf.iloc == (int)ONVERTEX) {
                        // The new point (in the segment) is coincident with an existing
                        //   vertex -- a self-intersection is detected.
                        eprevself(searchtet);
                        report_selfint_edge(sorg(sseg), sdest(sseg), &sseg, &searchtet, ACROSSVERT);
                    } else {
                        // An unknown case. Report a bug.
                        terminatetetgen(this, 2);
                    }
                }
            } else {
                // An unknown case. Report a bug.
                terminatetetgen(this, 2);
            }
        }
    } // while
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// scoutsubface()    Search subface in the tetrahedralization.               //
//                                                                           //
// 'searchsh' is searched in T. If it exists, it is 'locked' at the face in  //
// T. 'searchtet' refers to the face. Otherwise, it is missing.              //
//                                                                           //
// The parameter 'shflag' indicates whether 'searchsh' is a boundary face or //
// not. It is possible that 'searchsh' is a temporarily subface that is used //
// as a cavity boundary face.                                                //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::scoutsubface(face* searchsh, triface* searchtet, int shflag) {
    point pa = sorg(*searchsh);
    point pb = sdest(*searchsh);

    // Get a tet whose origin is a.
    point2tetorg(pa, *searchtet);
    // Search the edge [a,b].
    enum interresult dir = finddirection(searchtet, pb);
    if (dir == ACROSSVERT) {
        // Check validity of a PLC.
        if (dest(*searchtet) != pb) {
            if (shflag) {
                // A vertex lies on the search edge.
                report_selfint_edge(pa, pb, searchsh, searchtet, dir);
            } else {
                terminatetetgen(this, 2);
            }
        }
        int t1ver;
        // The edge exists. Check if the face exists.
        point pc = sapex(*searchsh);
        // Searchtet holds edge [a,b]. Search a face with apex c.
        triface spintet = *searchtet;
        while (1) {
            if (apex(spintet) == pc) {
                // Found a face matching to 'searchsh'!
                if (!issubface(spintet)) {
                    // Insert 'searchsh'.
                    tsbond(spintet, *searchsh);
                    fsymself(spintet);
                    sesymself(*searchsh);
                    tsbond(spintet, *searchsh);
                    *searchtet = spintet;
                    return 1;
                } else {
                    terminatetetgen(this, 2);
                }
            }
            fnextself(spintet);
            if (spintet.tet == searchtet->tet) break;
        }
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// formregion()    Form the missing region of a missing subface.             //
//                                                                           //
// 'missh' is a missing subface. From it we form a missing region R which is //
// a connected region formed by a set of missing subfaces of a facet.        //
// Comment: There should be no segment inside R.                             //
//                                                                           //
// 'missingshs' returns the list of subfaces in R. All subfaces in this list //
// are oriented as the 'missh'.  'missingshbds' returns the list of boundary //
// edges (tetrahedral handles) of R.  'missingshverts' returns all vertices  //
// of R. They are all pmarktested.                                           //
//                                                                           //
// Except the first one (which is 'missh') in 'missingshs', each subface in  //
// this list represents an internal edge of R, i.e., it is missing in the    //
// tetrahedralization. Since R may contain interior vertices, not all miss-  //
// ing edges can be found by this way.                                       //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::formregion(face* missh, arraypool* missingshs, arraypool* missingshbds,
                            arraypool* missingshverts) {
    triface searchtet, spintet;
    face neighsh, *parysh;
    face neighseg, fakeseg;
    point pa, pb, *parypt;
    enum interresult dir;
    int t1ver;
    int i, j;

    smarktest(*missh);
    missingshs->newindex((void**)&parysh);
    *parysh = *missh;

    // Incrementally find other missing subfaces.
    for (i = 0; i < missingshs->objects; i++) {
        missh = (face*)fastlookup(missingshs, i);
        for (j = 0; j < 3; j++) {
            pa = sorg(*missh);
            pb = sdest(*missh);
            point2tetorg(pa, searchtet);
            dir = finddirection(&searchtet, pb);
            if (dir != ACROSSVERT) {
                // This edge is missing. Its neighbor is a missing subface.
                spivot(*missh, neighsh);
                if (!smarktested(neighsh)) {
                    // Adjust the face orientation.
                    if (sorg(neighsh) != pb) sesymself(neighsh);
                    smarktest(neighsh);
                    missingshs->newindex((void**)&parysh);
                    *parysh = neighsh;
                }
            } else {
                if (dest(searchtet) != pb) {
                    // Report a PLC problem.
                    report_selfint_edge(pa, pb, missh, &searchtet, dir);
                }
            }
            // Collect the vertices of R.
            if (!pmarktested(pa)) {
                pmarktest(pa);
                missingshverts->newindex((void**)&parypt);
                *parypt = pa;
            }
            senextself(*missh);
        } // j
    }     // i

    // Get the boundary edges of R.
    for (i = 0; i < missingshs->objects; i++) {
        missh = (face*)fastlookup(missingshs, i);
        for (j = 0; j < 3; j++) {
            spivot(*missh, neighsh);
            if ((neighsh.sh == NULL) || !smarktested(neighsh)) {
                // A boundary edge of R.
                // Let the segment point to the adjacent tet.
                point2tetorg(sorg(*missh), searchtet);
                finddirection(&searchtet, sdest(*missh));
                missingshbds->newindex((void**)&parysh);
                *parysh = *missh;
                // Check if this edge is a segment.
                sspivot(*missh, neighseg);
                if (neighseg.sh == NULL) {
                    // Temporarily create a segment at this edge.
                    makeshellface(subsegs, &fakeseg);
                    setsorg(fakeseg, sorg(*missh));
                    setsdest(fakeseg, sdest(*missh));
                    sinfect(fakeseg); // Mark it as faked.
                    // Connect it to all tets at this edge.
                    spintet = searchtet;
                    while (1) {
                        tssbond1(spintet, fakeseg);
                        fnextself(spintet);
                        if (spintet.tet == searchtet.tet) break;
                    }
                    neighseg = fakeseg;
                }
                // Let the segment and the boundary edge point to each other.
                ssbond(*missh, neighseg);
                sstbond1(neighseg, searchtet);
            }
            senextself(*missh);
        } // j
    }     // i

    // Unmarktest collected missing subfaces.
    for (i = 0; i < missingshs->objects; i++) {
        parysh = (face*)fastlookup(missingshs, i);
        sunmarktest(*parysh);
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// scoutcrossedge()    Search an edge that crosses the missing region.       //
//                                                                           //
// Return 1 if a crossing edge is found. It is returned by 'crosstet'. More- //
// over, the edge is oriented such that its origin lies below R.  Return 0   //
// if no such edge is found.                                                 //
//                                                                           //
// Assumption: All vertices of the missing region are marktested.            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::scoutcrossedge(triface& crosstet, arraypool* missingshbds, arraypool* missingshs) {
    triface searchtet, spintet, neightet;
    face oldsh, searchsh, *parysh;
    face neighseg;
    point pa, pb, pc, pd, pe;
    REAL ori;
    int types[2], poss[4];
    int searchflag, interflag;
    int t1ver;
    int i, j;

    searchflag = 0;

    // Search the first new subface to fill the region.
    for (i = 0; i < missingshbds->objects && !searchflag; i++) {
        parysh = (face*)fastlookup(missingshbds, i);
        sspivot(*parysh, neighseg);
        sstpivot1(neighseg, searchtet);
        if (org(searchtet) != sorg(*parysh)) {
            esymself(searchtet);
        }
        spintet = searchtet;
        while (1) {
            if (pmarktested(apex(spintet))) {
                // A possible interior face.
                neightet = spintet;
                oldsh = *parysh;
                // Try to recover an interior edge.
                for (j = 0; j < 2; j++) {
                    enextself(neightet);
                    if (!issubseg(neightet)) {
                        if (j == 0) {
                            senext(oldsh, searchsh);
                        } else {
                            senext2(oldsh, searchsh);
                            sesymself(searchsh);
                            esymself(neightet);
                        }
                        // Calculate a lifted point.
                        pa = sorg(searchsh);
                        pb = sdest(searchsh);
                        pc = sapex(searchsh);
                        pd = dest(neightet);
                        calculateabovepoint4(pa, pb, pc, pd);
                        // The lifted point must lie above 'searchsh'.
                        ori = orient3d(pa, pb, pc, dummypoint);
                        if (ori > 0) {
                            sesymself(searchsh);
                            senextself(searchsh);
                        } else if (ori == 0) {
                            terminatetetgen(this, 2);
                        }
                        if (sscoutsegment(&searchsh, dest(neightet), 0, 0, 1) == SHAREEDGE) {
                            // Insert a temp segment to protect the recovered edge.
                            face tmpseg;
                            makeshellface(subsegs, &tmpseg);
                            ssbond(searchsh, tmpseg);
                            spivotself(searchsh);
                            ssbond(searchsh, tmpseg);
                            // Recover locally Delaunay edges.
                            lawsonflip();
                            // Delete the tmp segment.
                            spivot(tmpseg, searchsh);
                            ssdissolve(searchsh);
                            spivotself(searchsh);
                            ssdissolve(searchsh);
                            shellfacedealloc(subsegs, tmpseg.sh);
                            searchflag = 1;
                        } else {
                            // Undo the performed flips.
                            if (flipstack != NULL) {
                                lawsonflip();
                            }
                        }
                        break;
                    } // if (!issubseg(neightet))
                }     // j
                if (searchflag) break;
            } // if (pmarktested(apex(spintet)))
            fnextself(spintet);
            if (spintet.tet == searchtet.tet) break;
        }
    } // i

    if (searchflag) {
        // Remove faked segments.
        face checkseg;
        // Remark: We should not use the array 'missingshbds', since the flips may
        //   change the subfaces. We search them from the subfaces in R.
        for (i = 0; i < missingshs->objects; i++) {
            parysh = (face*)fastlookup(missingshs, i);
            oldsh = *parysh;
            for (j = 0; j < 3; j++) {
                if (isshsubseg(oldsh)) {
                    sspivot(oldsh, checkseg);
                    if (sinfected(checkseg)) {
                        // It's a faked segment. Delete it.
                        sstpivot1(checkseg, searchtet);
                        spintet = searchtet;
                        while (1) {
                            tssdissolve1(spintet);
                            fnextself(spintet);
                            if (spintet.tet == searchtet.tet) break;
                        }
                        shellfacedealloc(subsegs, checkseg.sh);
                        ssdissolve(oldsh);
                    }
                }
                senextself(oldsh);
            } // j
        }

        fillregioncount++;

        return 0;
    } // if (i < missingshbds->objects)

    searchflag = -1;

    for (j = 0; j < missingshbds->objects && (searchflag == -1); j++) {
        parysh = (face*)fastlookup(missingshbds, j);
        sspivot(*parysh, neighseg);
        sstpivot1(neighseg, searchtet);
        interflag = 0;
        // Let 'spintet' be [#,#,d,e] where [#,#] is the boundary edge of R.
        spintet = searchtet;
        while (1) {
            pd = apex(spintet);
            pe = oppo(spintet);
            // Skip a hull edge.
            if ((pd != dummypoint) && (pe != dummypoint)) {
                // Skip an edge containing a vertex of R.
                if (!pmarktested(pd) && !pmarktested(pe)) {
                    // Check if [d,e] intersects R.
                    for (i = 0; i < missingshs->objects && !interflag; i++) {
                        parysh = (face*)fastlookup(missingshs, i);
                        pa = sorg(*parysh);
                        pb = sdest(*parysh);
                        pc = sapex(*parysh);
                        interflag = tri_edge_test(pa, pb, pc, pd, pe, NULL, 1, types, poss);
                        if (interflag > 0) {
                            if (interflag == 2) {
                                // They intersect at a single point.
                                if ((types[0] == (int)ACROSSFACE) ||
                                    (types[0] == (int)ACROSSEDGE)) {
                                    // Go to the crossing edge [d,e,#,#].
                                    edestoppo(spintet, crosstet); // // [d,e,#,#].
                                    if (issubseg(crosstet)) {
                                        // It is a segment. Report a PLC problem.
                                        report_selfint_face(pa, pb, pc, parysh, &crosstet,
                                                            interflag, types, poss);
                                    } else {
                                        triface chkface = crosstet;
                                        while (1) {
                                            if (issubface(chkface)) break;
                                            fsymself(chkface);
                                            if (chkface.tet == crosstet.tet) break;
                                        }
                                        if (issubface(chkface)) {
                                            // Two subfaces are intersecting.
                                            report_selfint_face(pa, pb, pc, parysh, &chkface,
                                                                interflag, types, poss);
                                        }
                                    }
                                    // Adjust the edge such that d lies below [a,b,c].
                                    ori = orient3d(pa, pb, pc, pd);
                                    if (ori < 0) {
                                        esymself(crosstet);
                                    }
                                    searchflag = 1;
                                } else {
                                    // An improper intersection type, ACROSSVERT, TOUCHFACE,
                                    //   TOUCHEDGE, SHAREVERT, ...
                                    // Maybe it is due to a PLC problem.
                                    report_selfint_face(pa, pb, pc, parysh, &crosstet, interflag,
                                                        types, poss);
                                }
                            }
                            break;
                        } // if (interflag > 0)
                    }
                }
            }
            // Leave search at this bdry edge if an intersection is found.
            if (interflag > 0) break;
            // Go to the next tetrahedron.
            fnextself(spintet);
            if (spintet.tet == searchtet.tet) break;
        } // while (1)
    }     // j

    return searchflag;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// formcavity()    Form the cavity of a missing region.                      //
//                                                                           //
// The missing region R is formed by a set of missing subfaces 'missingshs'. //
// In the following, we assume R is horizontal and oriented. (All subfaces   //
// of R are oriented in the same way.)  'searchtet' is a tetrahedron [d,e,#, //
// #] which intersects R in its interior, where the edge [d,e] intersects R, //
// and d lies below R.                                                       //
//                                                                           //
// 'crosstets' returns the set of crossing tets. Every tet in it has the     //
// form [d,e,#,#] where [d,e] is a crossing edge, and d lies below R.  The   //
// set of tets form the cavity C, which is divided into two parts by R, one  //
// at top and one at bottom. 'topfaces' and 'botfaces' return the upper and  //
// lower boundary faces of C. 'toppoints' contains vertices of 'crosstets'   //
// in the top part of C, and so does 'botpoints'. Both 'toppoints' and       //
// 'botpoints' contain vertices of R.                                        //
//                                                                           //
// Important: This routine assumes all vertices of the facet containing this //
// subface are marked, i.e., pmarktested(p) returns true.                    //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenmesh::formcavity(triface* searchtet, arraypool* missingshs, arraypool* crosstets,
                            arraypool* topfaces, arraypool* botfaces, arraypool* toppoints,
                            arraypool* botpoints) {
    arraypool* crossedges;
    triface spintet, neightet, chkface, *parytet;
    face* parysh = NULL;
    point pa, pd, pe, *parypt;
    bool testflag, invalidflag;
    int intflag, types[2], poss[4];
    int t1ver;
    int i, j, k;

    // Temporarily re-use 'topfaces' for all crossing edges.
    crossedges = topfaces;

    if (b->verbose > 2) {
        printf("      Form the cavity of a missing region.\n");
    }
    // Mark this edge to avoid testing it later.
    markedge(*searchtet);
    crossedges->newindex((void**)&parytet);
    *parytet = *searchtet;

    invalidflag = 0;
    // Collect all crossing tets.  Each cross tet is saved in the standard
    //   form [d,e,#,#], where [d,e] is a crossing edge, d lies below R.
    //   NEITHER d NOR e is a vertex of R (!pmarktested).
    for (i = 0; i < crossedges->objects && !invalidflag; i++) {
        // Get a crossing edge [d,e,#,#].
        searchtet = (triface*)fastlookup(crossedges, i);
        // Sort vertices into the bottom and top arrays.
        pd = org(*searchtet);
        if (!pinfected(pd)) {
            pinfect(pd);
            botpoints->newindex((void**)&parypt);
            *parypt = pd;
        }
        pe = dest(*searchtet);
        if (!pinfected(pe)) {
            pinfect(pe);
            toppoints->newindex((void**)&parypt);
            *parypt = pe;
        }

        // All tets sharing this edge are crossing tets.
        spintet = *searchtet;
        while (1) {
            if (!infected(spintet)) {
                infect(spintet);
                crosstets->newindex((void**)&parytet);
                *parytet = spintet;
            }
            // Go to the next crossing tet.
            fnextself(spintet);
            if (spintet.tet == searchtet->tet) break;
        } // while (1)

        // Detect new crossing edges.
        spintet = *searchtet;
        while (1) {
            // spintet is [d,e,a,#], where d lies below R, and e lies above R.
            pa = apex(spintet);
            if (pa != dummypoint) {
                if (!pmarktested(pa)) {
                    // There exists a crossing edge, either [e,a] or [a,d]. First check
                    //   if the crossing edge has already be added, i.e.,to check if one
                    //   of the tetrahedron at this edge has been marked.
                    testflag = true;
                    for (j = 0; j < 2 && testflag; j++) {
                        if (j == 0) {
                            enext(spintet, neightet);
                        } else {
                            eprev(spintet, neightet);
                        }
                        while (1) {
                            if (edgemarked(neightet)) {
                                // This crossing edge has already been tested. Skip it.
                                testflag = false;
                                break;
                            }
                            fnextself(neightet);
                            if (neightet.tet == spintet.tet) break;
                        }
                    } // j
                    if (testflag) {
                        // Test if [e,a] or [a,d] intersects R.
                        // Do a brute-force search in the set of subfaces of R. Slow!
                        //   Need to be improved!
                        pd = org(spintet);
                        pe = dest(spintet);
                        for (k = 0; k < missingshs->objects; k++) {
                            parysh = (face*)fastlookup(missingshs, k);
                            intflag = tri_edge_test(sorg(*parysh), sdest(*parysh), sapex(*parysh),
                                                    pe, pa, NULL, 1, types, poss);
                            if (intflag > 0) {
                                // Found intersection. 'a' lies below R.
                                if (intflag == 2) {
                                    enext(spintet, neightet);
                                    if ((types[0] == (int)ACROSSFACE) ||
                                        (types[0] == (int)ACROSSEDGE)) {
                                        // Only this case is valid.
                                    } else {
                                        // A non-valid intersection. Maybe a PLC problem.
                                        invalidflag = 1;
                                    }
                                } else {
                                    // Coplanar intersection. Maybe a PLC problem.
                                    invalidflag = 1;
                                }
                                break;
                            }
                            intflag = tri_edge_test(sorg(*parysh), sdest(*parysh), sapex(*parysh),
                                                    pa, pd, NULL, 1, types, poss);
                            if (intflag > 0) {
                                // Found intersection. 'a' lies above R.
                                if (intflag == 2) {
                                    eprev(spintet, neightet);
                                    if ((types[0] == (int)ACROSSFACE) ||
                                        (types[0] == (int)ACROSSEDGE)) {
                                        // Only this case is valid.
                                    } else {
                                        // A non-valid intersection. Maybe a PLC problem.
                                        invalidflag = 1;
                                    }
                                } else {
                                    // Coplanar intersection. Maybe a PLC problem.
                                    invalidflag = 1;
                                }
                                break;
                            }
                        } // k
                        if (k < missingshs->objects) {
                            // Found a pair of triangle - edge intersection.
                            if (invalidflag) {
                                break; // the while (1) loop
                            }
                            // Adjust the edge direction, so that its origin lies below R,
                            //   and its destination lies above R.
                            esymself(neightet);
                            // This edge may be a segment.
                            if (issubseg(neightet)) {
                                report_selfint_face(sorg(*parysh), sdest(*parysh), sapex(*parysh),
                                                    parysh, &neightet, intflag, types, poss);
                            }
                            // Check if it is an edge of a subface.
                            chkface = neightet;
                            while (1) {
                                if (issubface(chkface)) break;
                                fsymself(chkface);
                                if (chkface.tet == neightet.tet) break;
                            }
                            if (issubface(chkface)) {
                                // Two subfaces are intersecting.
                                report_selfint_face(sorg(*parysh), sdest(*parysh), sapex(*parysh),
                                                    parysh, &chkface, intflag, types, poss);
                            }

                            // Mark this edge to avoid testing it again.
                            markedge(neightet);
                            crossedges->newindex((void**)&parytet);
                            *parytet = neightet;
                        } else {
                            // No intersection is found. It may be a PLC problem.
                            invalidflag = 1;
                            break; // the while (1) loop
                        }          // if (k == missingshs->objects)
                    }              // if (testflag)
                }
            } // if (pa != dummypoint)
            // Go to the next crossing tet.
            fnextself(spintet);
            if (spintet.tet == searchtet->tet) break;
        } // while (1)
    }     // i

    // Unmark all marked edges.
    for (i = 0; i < crossedges->objects; i++) {
        searchtet = (triface*)fastlookup(crossedges, i);
        unmarkedge(*searchtet);
    }
    crossedges->restart();

    if (invalidflag) {
        // Unmark all collected tets.
        for (i = 0; i < crosstets->objects; i++) {
            searchtet = (triface*)fastlookup(crosstets, i);
            uninfect(*searchtet);
        }
        // Unmark all collected vertices.
        for (i = 0; i < botpoints->objects; i++) {
            parypt = (point*)fastlookup(botpoints, i);
            puninfect(*parypt);
        }
        for (i = 0; i < toppoints->objects; i++) {
            parypt = (point*)fastlookup(toppoints, i);
            puninfect(*parypt);
        }
        crosstets->restart();
        botpoints->restart();
        toppoints->restart();

        // Randomly split an interior edge of R.
        i = randomnation(missingshs->objects - 1);
        recentsh = *(face*)fastlookup(missingshs, i);
        return false;
    }

    if (b->verbose > 2) {
        printf("      Formed cavity: %ld (%ld) cross tets (edges).\n", crosstets->objects,
               crossedges->objects);
    }

    // Collect the top and bottom faces and the middle vertices. Since all top
    //   and bottom vertices have been infected. Uninfected vertices must be
    //   middle vertices (i.e., the vertices of R).
    // NOTE 1: Hull tets may be collected. Process them as a normal one.
    // NOTE 2: Some previously recovered subfaces may be completely inside the
    //   cavity. In such case, we remove these subfaces from the cavity and put
    //   them into 'subfacstack'. They will be recovered later.
    // NOTE 3: Some segments may be completely inside the cavity, e.g., they
    //   attached to a subface which is inside the cavity. Such segments are
    //   put in 'subsegstack'. They will be recovered later.
    // NOTE4 : The interior subfaces and segments mentioned in NOTE 2 and 3
    //   are identified in the routine "carvecavity()".

    for (i = 0; i < crosstets->objects; i++) {
        searchtet = (triface*)fastlookup(crosstets, i);
        // searchtet is [d,e,a,b].
        eorgoppo(*searchtet, spintet);
        fsym(spintet, neightet); // neightet is [a,b,e,#]
        if (!infected(neightet)) {
            // A top face.
            topfaces->newindex((void**)&parytet);
            *parytet = neightet;
        }
        edestoppo(*searchtet, spintet);
        fsym(spintet, neightet); // neightet is [b,a,d,#]
        if (!infected(neightet)) {
            // A bottom face.
            botfaces->newindex((void**)&parytet);
            *parytet = neightet;
        }
        // Add middle vertices if there are (skip dummypoint).
        pa = org(neightet);
        if (!pinfected(pa)) {
            if (pa != dummypoint) {
                pinfect(pa);
                botpoints->newindex((void**)&parypt);
                *parypt = pa;
                toppoints->newindex((void**)&parypt);
                *parypt = pa;
            }
        }
        pa = dest(neightet);
        if (!pinfected(pa)) {
            if (pa != dummypoint) {
                pinfect(pa);
                botpoints->newindex((void**)&parypt);
                *parypt = pa;
                toppoints->newindex((void**)&parypt);
                *parypt = pa;
            }
        }
    } // i

    // Uninfect all collected top, bottom, and middle vertices.
    for (i = 0; i < toppoints->objects; i++) {
        parypt = (point*)fastlookup(toppoints, i);
        puninfect(*parypt);
    }
    for (i = 0; i < botpoints->objects; i++) {
        parypt = (point*)fastlookup(botpoints, i);
        puninfect(*parypt);
    }
    cavitycount++;

    return true;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// delaunizecavity()    Fill a cavity by Delaunay tetrahedra.                //
//                                                                           //
// The cavity C to be tetrahedralized is the top or bottom part of a whole   //
// cavity. 'cavfaces' contains the boundary faces of C. NOTE: faces in 'cav- //
// faces' do not form a closed polyhedron.  The "open" side are subfaces of  //
// the missing facet. These faces will be recovered later in fillcavity().   //
//                                                                           //
// This routine first constructs the DT of the vertices. Then it identifies  //
// the half boundary faces of the cavity in DT. Possiblely the cavity C will //
// be enlarged.                                                              //
//                                                                           //
// The DT is returned in 'newtets'.                                          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::delaunizecavity(arraypool* cavpoints, arraypool* cavfaces, arraypool* cavshells,
                                 arraypool* newtets, arraypool* crosstets, arraypool* misfaces) {
    triface searchtet, neightet, *parytet, *parytet1;
    face tmpsh, *parysh;
    point pa, pb, pc, pd, pt[3], *parypt;
    insertvertexflags ivf;
    REAL ori;
    long baknum, bakhullsize;
    int bakchecksubsegflag, bakchecksubfaceflag;
    int t1ver;
    int i, j;

    if (b->verbose > 2) {
        printf("      Delaunizing cavity: %ld points, %ld faces.\n", cavpoints->objects,
               cavfaces->objects);
    }
    // Remember the current number of crossing tets. It may be enlarged later.
    baknum = crosstets->objects;
    bakhullsize = hullsize;
    bakchecksubsegflag = checksubsegflag;
    bakchecksubfaceflag = checksubfaceflag;
    hullsize = 0l;
    checksubsegflag = 0;
    checksubfaceflag = 0;
    b->verbose--; // Suppress informations for creating Delaunay tetra.
    b->plc = 0;   // Do not check near vertices.

    ivf.bowywat = 1; // Use Bowyer-Watson algorithm.

    // Get four non-coplanar points (no dummypoint).
    pa = pb = pc = NULL;
    for (i = 0; i < cavfaces->objects; i++) {
        parytet = (triface*)fastlookup(cavfaces, i);
        parytet->ver = epivot[parytet->ver];
        if (apex(*parytet) != dummypoint) {
            pa = org(*parytet);
            pb = dest(*parytet);
            pc = apex(*parytet);
            break;
        }
    }
    pd = NULL;
    for (; i < cavfaces->objects; i++) {
        parytet = (triface*)fastlookup(cavfaces, i);
        pt[0] = org(*parytet);
        pt[1] = dest(*parytet);
        pt[2] = apex(*parytet);
        for (j = 0; j < 3; j++) {
            if (pt[j] != dummypoint) { // Do not include a hull point.
                ori = orient3d(pa, pb, pc, pt[j]);
                if (ori != 0) {
                    pd = pt[j];
                    if (ori > 0) { // Swap pa and pb.
                        pt[j] = pa;
                        pa = pb;
                        pb = pt[j];
                    }
                    break;
                }
            }
        }
        if (pd != NULL) break;
    }

    // Create an init DT.
    initialdelaunay(pa, pb, pc, pd);

    // Incrementally insert the vertices (duplicated vertices are ignored).
    for (i = 0; i < cavpoints->objects; i++) {
        pt[0] = *(point*)fastlookup(cavpoints, i);
        searchtet = recenttet;
        ivf.iloc = (int)OUTSIDE;
        insertpoint(pt[0], &searchtet, NULL, NULL, &ivf);
    }

    if (b->verbose > 2) {
        printf("      Identifying %ld boundary faces of the cavity.\n", cavfaces->objects);
    }

    while (1) {

        // Identify boundary faces. Mark interior tets. Save missing faces.
        for (i = 0; i < cavfaces->objects; i++) {
            parytet = (triface*)fastlookup(cavfaces, i);
            // Skip an interior face (due to the enlargement of the cavity).
            if (infected(*parytet)) continue;
            parytet->ver = epivot[parytet->ver];
            pt[0] = org(*parytet);
            pt[1] = dest(*parytet);
            pt[2] = apex(*parytet);
            // Create a temp subface.
            makeshellface(subfaces, &tmpsh);
            setshvertices(tmpsh, pt[0], pt[1], pt[2]);
            // Insert tmpsh in DT.
            searchtet.tet = NULL;
            if (scoutsubface(&tmpsh, &searchtet, 0)) { // shflag = 0
                // Inserted! 'tmpsh' must face toward the inside of the cavity.
                // Remember the boundary tet (outside the cavity) in tmpsh
                //   (use the adjacent tet slot).
                tmpsh.sh[0] = (shellface)encode(*parytet);
                // Save this subface.
                cavshells->newindex((void**)&parysh);
                *parysh = tmpsh;
            } else {
                // This boundary face is missing.
                shellfacedealloc(subfaces, tmpsh.sh);
                // Save this face in list.
                misfaces->newindex((void**)&parytet1);
                *parytet1 = *parytet;
            }
        } // i

        if (misfaces->objects > 0) {
            if (b->verbose > 2) {
                printf("      Enlarging the cavity. %ld missing bdry faces\n", misfaces->objects);
            }

            // Removing all temporary subfaces.
            for (i = 0; i < cavshells->objects; i++) {
                parysh = (face*)fastlookup(cavshells, i);
                stpivot(*parysh, neightet);
                tsdissolve(neightet); // Detach it from adj. tets.
                fsymself(neightet);
                tsdissolve(neightet);
                shellfacedealloc(subfaces, parysh->sh);
            }
            cavshells->restart();

            // Infect the points which are of the cavity.
            for (i = 0; i < cavpoints->objects; i++) {
                pt[0] = *(point*)fastlookup(cavpoints, i);
                pinfect(pt[0]); // Mark it as inserted.
            }

            // Enlarge the cavity.
            for (i = 0; i < misfaces->objects; i++) {
                // Get a missing face.
                parytet = (triface*)fastlookup(misfaces, i);
                if (!infected(*parytet)) {
                    // Put it into crossing tet list.
                    infect(*parytet);
                    crosstets->newindex((void**)&parytet1);
                    *parytet1 = *parytet;
                    // Insert the opposite point if it is not in DT.
                    pd = oppo(*parytet);
                    if (!pinfected(pd)) {
                        searchtet = recenttet;
                        ivf.iloc = (int)OUTSIDE;
                        insertpoint(pd, &searchtet, NULL, NULL, &ivf);
                        pinfect(pd);
                        cavpoints->newindex((void**)&parypt);
                        *parypt = pd;
                    }
                    // Add three opposite faces into the boundary list.
                    for (j = 0; j < 3; j++) {
                        esym(*parytet, neightet);
                        fsymself(neightet);
                        if (!infected(neightet)) {
                            cavfaces->newindex((void**)&parytet1);
                            *parytet1 = neightet;
                        }
                        enextself(*parytet);
                    } // j
                }     // if (!infected(parytet))
            }         // i

            // Uninfect the points which are of the cavity.
            for (i = 0; i < cavpoints->objects; i++) {
                pt[0] = *(point*)fastlookup(cavpoints, i);
                puninfect(pt[0]);
            }

            misfaces->restart();
            continue;
        } // if (misfaces->objects > 0)

        break;

    } // while (1)

    // Collect all tets of the DT. All new tets are marktested.
    marktest(recenttet);
    newtets->newindex((void**)&parytet);
    *parytet = recenttet;
    for (i = 0; i < newtets->objects; i++) {
        searchtet = *(triface*)fastlookup(newtets, i);
        for (j = 0; j < 4; j++) {
            decode(searchtet.tet[j], neightet);
            if (!marktested(neightet)) {
                marktest(neightet);
                newtets->newindex((void**)&parytet);
                *parytet = neightet;
            }
        }
    }

    cavpoints->restart();
    cavfaces->restart();

    if (crosstets->objects > baknum) {
        // The cavity has been enlarged.
        cavityexpcount++;
    }

    // Restore the original values.
    hullsize = bakhullsize;
    checksubsegflag = bakchecksubsegflag;
    checksubfaceflag = bakchecksubfaceflag;
    b->verbose++;
    b->plc = 1;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// fillcavity()    Fill new tets into the cavity.                            //
//                                                                           //
// The new tets are stored in two disjoint sets(which share the same facet). //
// 'topfaces' and 'botfaces' are the boundaries of these two sets, respect-  //
// ively. 'midfaces' is empty on input, and will store faces in the facet.   //
//                                                                           //
// Important: This routine assumes all vertices of the missing region R are  //
// marktested, i.e., pmarktested(p) returns true.                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

bool tetgenmesh::fillcavity(arraypool* topshells, arraypool* botshells, arraypool* midfaces,
                            arraypool* missingshs, arraypool* topnewtets, arraypool* botnewtets,
                            triface* crossedge) {
    arraypool* cavshells;
    triface bdrytet, neightet, *parytet;
    triface searchtet, spintet;
    face* parysh;
    face checkseg;
    point pa, pb, pc;
    bool mflag;
    int t1ver;
    int i, j;

    // Connect newtets to tets outside the cavity.  These connections are needed
    //   for identifying the middle faces (which belong to R).
    for (j = 0; j < 2; j++) {
        cavshells = (j == 0 ? topshells : botshells);
        if (cavshells != NULL) {
            for (i = 0; i < cavshells->objects; i++) {
                // Get a temp subface.
                parysh = (face*)fastlookup(cavshells, i);
                // Get the boundary tet outside the cavity (saved in sh[0]).
                decode(parysh->sh[0], bdrytet);
                pa = org(bdrytet);
                pb = dest(bdrytet);
                pc = apex(bdrytet);
                // Get the adjacent new tet inside the cavity.
                stpivot(*parysh, neightet);
                // Mark neightet as an interior tet of this cavity.
                infect(neightet);
                // Connect the two tets (the old connections are replaced).
                bond(bdrytet, neightet);
                tsdissolve(neightet); // Clear the pointer to tmpsh.
                // Update the point-to-tets map.
                setpoint2tet(pa, (tetrahedron)neightet.tet);
                setpoint2tet(pb, (tetrahedron)neightet.tet);
                setpoint2tet(pc, (tetrahedron)neightet.tet);
            } // i
        }     // if (cavshells != NULL)
    }         // j

    if (crossedge != NULL) {
        // Glue top and bottom tets at their common facet.
        triface toptet, bottet, spintet, *midface;
        point pd, pe;
        REAL ori;
        int types[2], poss[4];
        int interflag;
        int bflag;

        mflag = false;
        pd = org(*crossedge);
        pe = dest(*crossedge);

        // Search the first (middle) face in R.
        // Since R may be non-convex, we must make sure that the face is in the
        //   interior of R.  We search a face in 'topnewtets' whose three vertices
        //   are on R and it intersects 'crossedge' in its interior. Then search
        //   a matching face in 'botnewtets'.
        for (i = 0; i < topnewtets->objects && !mflag; i++) {
            searchtet = *(triface*)fastlookup(topnewtets, i);
            for (searchtet.ver = 0; searchtet.ver < 4 && !mflag; searchtet.ver++) {
                pa = org(searchtet);
                if (pmarktested(pa)) {
                    pb = dest(searchtet);
                    if (pmarktested(pb)) {
                        pc = apex(searchtet);
                        if (pmarktested(pc)) {
                            // Check if this face intersects [d,e].
                            interflag = tri_edge_test(pa, pb, pc, pd, pe, NULL, 1, types, poss);
                            if (interflag == 2) {
                                // They intersect at a single point. Found.
                                toptet = searchtet;
                                // The face lies in the interior of R.
                                // Get the tet (in topnewtets) which lies above R.
                                ori = orient3d(pa, pb, pc, pd);
                                if (ori < 0) {
                                    fsymself(toptet);
                                    pa = org(toptet);
                                    pb = dest(toptet);
                                } else if (ori == 0) {
                                    terminatetetgen(this, 2);
                                }
                                // Search the face [b,a,c] in 'botnewtets'.
                                for (j = 0; j < botnewtets->objects; j++) {
                                    neightet = *(triface*)fastlookup(botnewtets, j);
                                    // Is neightet contains 'b'.
                                    if ((point)neightet.tet[4] == pb) {
                                        neightet.ver = 11;
                                    } else if ((point)neightet.tet[5] == pb) {
                                        neightet.ver = 3;
                                    } else if ((point)neightet.tet[6] == pb) {
                                        neightet.ver = 7;
                                    } else if ((point)neightet.tet[7] == pb) {
                                        neightet.ver = 0;
                                    } else {
                                        continue;
                                    }
                                    // Is the 'neightet' contains edge [b,a].
                                    if (dest(neightet) == pa) {
                                        // 'neightet' is just the edge.
                                    } else if (apex(neightet) == pa) {
                                        eprevesymself(neightet);
                                    } else if (oppo(neightet) == pa) {
                                        esymself(neightet);
                                        enextself(neightet);
                                    } else {
                                        continue;
                                    }
                                    // Is 'neightet' the face [b,a,c].
                                    if (apex(neightet) == pc) {
                                        bottet = neightet;
                                        mflag = true;
                                        break;
                                    }
                                } // j
                            }     // if (interflag == 2)
                        }         // pc
                    }             // pb
                }                 // pa
            }                     // toptet.ver
        }                         // i

        if (mflag) {
            // Found a pair of matched faces in 'toptet' and 'bottet'.
            bond(toptet, bottet);
            // Both are interior tets.
            infect(toptet);
            infect(bottet);
            // Add this face into search list.
            markface(toptet);
            midfaces->newindex((void**)&parytet);
            *parytet = toptet;
        } else {
            // No pair of 'toptet' and 'bottet'.
            toptet.tet = NULL;
            // Randomly split an interior edge of R.
            i = randomnation(missingshs->objects - 1);
            recentsh = *(face*)fastlookup(missingshs, i);
        }

        // Find other middle faces, connect top and bottom tets.
        for (i = 0; i < midfaces->objects && mflag; i++) {
            // Get a matched middle face [a, b, c]
            midface = (triface*)fastlookup(midfaces, i);
            // Check the neighbors at the edges of this face.
            for (j = 0; j < 3 && mflag; j++) {
                toptet = *midface;
                bflag = false;
                while (1) {
                    // Go to the next face in the same tet.
                    esymself(toptet);
                    pc = apex(toptet);
                    if (pmarktested(pc)) {
                        break; // Find a subface.
                    }
                    if (pc == dummypoint) {
                        terminatetetgen(this, 2); // Check this case.
                        break;                    // Find a subface.
                    }
                    // Go to the adjacent tet.
                    fsymself(toptet);
                    // Do we walk outside the cavity?
                    if (!marktested(toptet)) {
                        // Yes, the adjacent face is not a middle face.
                        bflag = true;
                        break;
                    }
                }
                if (!bflag) {
                    if (!facemarked(toptet)) {
                        fsym(*midface, bottet);
                        spintet = bottet;
                        while (1) {
                            esymself(bottet);
                            pd = apex(bottet);
                            if (pd == pc) break; // Face matched.
                            fsymself(bottet);
                            if (bottet.tet == spintet.tet) {
                                // Not found a matched bottom face.
                                mflag = false;
                                break;
                            }
                        } // while (1)
                        if (mflag) {
                            if (marktested(bottet)) {
                                // Connect two tets together.
                                bond(toptet, bottet);
                                // Both are interior tets.
                                infect(toptet);
                                infect(bottet);
                                // Add this face into list.
                                markface(toptet);
                                midfaces->newindex((void**)&parytet);
                                *parytet = toptet;
                            } else {
                                // The 'bottet' is not inside the cavity!
                                terminatetetgen(this, 2); // Check this case
                            }
                        } else { // mflag == false
                            // Adjust 'toptet' and 'bottet' to be the crossing edges.
                            fsym(*midface, bottet);
                            spintet = bottet;
                            while (1) {
                                esymself(bottet);
                                pd = apex(bottet);
                                if (pmarktested(pd)) {
                                    // assert(pd != pc);
                                    // Let 'toptet' be [a,b,c,#], and 'bottet' be [b,a,d,*].
                                    // Adjust 'toptet' and 'bottet' to be the crossing edges.
                                    // Test orient3d(b,c,#,d).
                                    ori = orient3d(dest(toptet), pc, oppo(toptet), pd);
                                    if (ori < 0) {
                                        // Edges [a,d] and [b,c] cross each other.
                                        enextself(toptet); // [b,c]
                                        enextself(bottet); // [a,d]
                                    } else if (ori > 0) {
                                        // Edges [a,c] and [b,d] cross each other.
                                        eprevself(toptet); // [c,a]
                                        eprevself(bottet); // [d,b]
                                    } else {
                                        // b,c,#,and d are coplanar!.
                                        terminatetetgen(this, 2); // assert(0);
                                    }
                                    break; // Not matched
                                }
                                fsymself(bottet);
                            }
                        } // if (!mflag)
                    }     // if (!facemarked(toptet))
                }         // if (!bflag)
                enextself(*midface);
            } // j
        }     // i

        if (mflag) {
            if (b->verbose > 2) {
                printf("      Found %ld middle subfaces.\n", midfaces->objects);
            }
            face oldsh, newsh, casout, casin, neighsh;

            oldsh = *(face*)fastlookup(missingshs, 0);

            // Create new subfaces to fill the region R.
            for (i = 0; i < midfaces->objects; i++) {
                // Get a matched middle face [a, b, c]
                midface = (triface*)fastlookup(midfaces, i);
                unmarkface(*midface);
                makeshellface(subfaces, &newsh);
                setsorg(newsh, org(*midface));
                setsdest(newsh, dest(*midface));
                setsapex(newsh, apex(*midface));
                // The new subface gets its markers from the old one.
                setshellmark(newsh, shellmark(oldsh));
                if (checkconstraints) {
                    setareabound(newsh, areabound(oldsh));
                }
                if (useinsertradius) {
                    setfacetindex(newsh, getfacetindex(oldsh));
                }
                // Connect the new subface to adjacent tets.
                tsbond(*midface, newsh);
                fsym(*midface, neightet);
                sesymself(newsh);
                tsbond(neightet, newsh);
            }

            // Connect new subfaces together and to the bdry of R.
            // Delete faked segments.
            for (i = 0; i < midfaces->objects; i++) {
                // Get a matched middle face [a, b, c]
                midface = (triface*)fastlookup(midfaces, i);
                for (j = 0; j < 3; j++) {
                    tspivot(*midface, newsh);
                    spivot(newsh, casout);
                    if (casout.sh == NULL) {
                        // Search its neighbor.
                        fnext(*midface, searchtet);
                        while (1) {
                            // (1) First check if this side is a bdry edge of R.
                            tsspivot1(searchtet, checkseg);
                            if (checkseg.sh != NULL) {
                                // It's a bdry edge of R.
                                // Get the old subface.
                                checkseg.shver = 0;
                                spivot(checkseg, oldsh);
                                if (sinfected(checkseg)) {
                                    // It's a faked segment. Delete it.
                                    spintet = searchtet;
                                    while (1) {
                                        tssdissolve1(spintet);
                                        fnextself(spintet);
                                        if (spintet.tet == searchtet.tet) break;
                                    }
                                    shellfacedealloc(subsegs, checkseg.sh);
                                    ssdissolve(oldsh);
                                    checkseg.sh = NULL;
                                }
                                spivot(oldsh, casout);
                                if (casout.sh != NULL) {
                                    casin = casout;
                                    if (checkseg.sh != NULL) {
                                        // Make sure that the subface has the right ori at the
                                        //   segment.
                                        checkseg.shver = 0;
                                        if (sorg(newsh) != sorg(checkseg)) {
                                            sesymself(newsh);
                                        }
                                        spivot(casin, neighsh);
                                        while (neighsh.sh != oldsh.sh) {
                                            casin = neighsh;
                                            spivot(casin, neighsh);
                                        }
                                    }
                                    sbond1(newsh, casout);
                                    sbond1(casin, newsh);
                                }
                                if (checkseg.sh != NULL) {
                                    ssbond(newsh, checkseg);
                                }
                                break;
                            } // if (checkseg.sh != NULL)
                            // (2) Second check if this side is an interior edge of R.
                            tspivot(searchtet, neighsh);
                            if (neighsh.sh != NULL) {
                                // Found an adjacent subface of newsh (an interior edge).
                                sbond(newsh, neighsh);
                                break;
                            }
                            fnextself(searchtet);
                        } // while (1)
                    }     // if (casout.sh == NULL)
                    enextself(*midface);
                } // j
            }     // i

            // Delete old subfaces.
            for (i = 0; i < missingshs->objects; i++) {
                parysh = (face*)fastlookup(missingshs, i);
                shellfacedealloc(subfaces, parysh->sh);
            }
        } else {
            if (toptet.tet != NULL) {
                // Faces at top and bottom are not matched.
                // Choose a Steiner point in R.
                // Split one of the crossing edges.
                pa = org(toptet);
                pb = dest(toptet);
                pc = org(bottet);
                pd = dest(bottet);
                // Search an edge in R which is either [a,b] or [c,d].
                // Reminder:  Subfaces in this list 'missingshs', except the first
                //   one, represents an interior edge of R.
                parysh = NULL; // Avoid a warning in MSVC
                for (i = 1; i < missingshs->objects; i++) {
                    parysh = (face*)fastlookup(missingshs, i);
                    if (((sorg(*parysh) == pa) && (sdest(*parysh) == pb)) ||
                        ((sorg(*parysh) == pb) && (sdest(*parysh) == pa)))
                        break;
                    if (((sorg(*parysh) == pc) && (sdest(*parysh) == pd)) ||
                        ((sorg(*parysh) == pd) && (sdest(*parysh) == pc)))
                        break;
                }
                if (i < missingshs->objects) {
                    // Found. Return it.
                    recentsh = *parysh;
                } else {
                    terminatetetgen(this, 2); // assert(0);
                }
            } else {
                // terminatetetgen(this, 2); // Report a bug
            }
        }

        midfaces->restart();
    } else {
        mflag = true;
    }

    // Delete the temp subfaces.
    for (j = 0; j < 2; j++) {
        cavshells = (j == 0 ? topshells : botshells);
        if (cavshells != NULL) {
            for (i = 0; i < cavshells->objects; i++) {
                parysh = (face*)fastlookup(cavshells, i);
                shellfacedealloc(subfaces, parysh->sh);
            }
        }
    }

    topshells->restart();
    if (botshells != NULL) {
        botshells->restart();
    }

    return mflag;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// carvecavity()    Delete old tets and outer new tets of the cavity.        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::carvecavity(arraypool* crosstets, arraypool* topnewtets, arraypool* botnewtets) {
    arraypool* newtets;
    shellface *sptr, *ssptr;
    triface *parytet, *pnewtet, newtet, neightet, spintet;
    face checksh, *parysh;
    face checkseg, *paryseg;
    int t1ver;
    int i, j;

    if (b->verbose > 2) {
        printf("      Carve cavity: %ld old tets.\n", crosstets->objects);
    }

    // First process subfaces and segments which are adjacent to the cavity.
    //   They must be re-connected to new tets in the cavity.
    // Comment: It is possible that some subfaces and segments are completely
    //   inside the cavity. This can happen even if the cavity is not enlarged.
    //   Before deleting the old tets, find and queue all interior subfaces
    //   and segments. They will be recovered later. 2010-05-06.

    // Collect all subfaces and segments which attached to the old tets.
    for (i = 0; i < crosstets->objects; i++) {
        parytet = (triface*)fastlookup(crosstets, i);
        if ((sptr = (shellface*)parytet->tet[9]) != NULL) {
            for (j = 0; j < 4; j++) {
                if (sptr[j]) {
                    sdecode(sptr[j], checksh);
                    if (!sinfected(checksh)) {
                        sinfect(checksh);
                        cavetetshlist->newindex((void**)&parysh);
                        *parysh = checksh;
                    }
                }
            } // j
        }
        if ((ssptr = (shellface*)parytet->tet[8]) != NULL) {
            for (j = 0; j < 6; j++) {
                if (ssptr[j]) {
                    sdecode(ssptr[j], checkseg);
                    // Skip a deleted segment (was a faked segment)
                    if (checkseg.sh[3] != NULL) {
                        if (!sinfected(checkseg)) {
                            sinfect(checkseg);
                            cavetetseglist->newindex((void**)&paryseg);
                            *paryseg = checkseg;
                        }
                    }
                }
            } // j
        }
    } // i

    // Uninfect collected subfaces.
    for (i = 0; i < cavetetshlist->objects; i++) {
        parysh = (face*)fastlookup(cavetetshlist, i);
        suninfect(*parysh);
    }
    // Uninfect collected segments.
    for (i = 0; i < cavetetseglist->objects; i++) {
        paryseg = (face*)fastlookup(cavetetseglist, i);
        suninfect(*paryseg);
    }

    // Connect subfaces to new tets.
    for (i = 0; i < cavetetshlist->objects; i++) {
        parysh = (face*)fastlookup(cavetetshlist, i);
        // Get an adjacent tet at this subface.
        stpivot(*parysh, neightet);
        // Does this tet lie inside the cavity.
        if (infected(neightet)) {
            // Yes. Get the other adjacent tet at this subface.
            sesymself(*parysh);
            stpivot(*parysh, neightet);
            // Does this tet lie inside the cavity.
            if (infected(neightet)) {
                checksh = *parysh;
                stdissolve(checksh);
                caveencshlist->newindex((void**)&parysh);
                *parysh = checksh;
            }
        }
        if (!infected(neightet)) {
            // Found an outside tet. Re-connect this subface to a new tet.
            fsym(neightet, newtet);
            sesymself(*parysh);
            tsbond(newtet, *parysh);
        }
    } // i

    for (i = 0; i < cavetetseglist->objects; i++) {
        checkseg = *(face*)fastlookup(cavetetseglist, i);
        // Check if the segment is inside the cavity.
        sstpivot1(checkseg, neightet);
        spintet = neightet;
        while (1) {
            if (!infected(spintet)) {
                // This segment is on the boundary of the cavity.
                break;
            }
            fnextself(spintet);
            if (spintet.tet == neightet.tet) {
                sstdissolve1(checkseg);
                caveencseglist->newindex((void**)&paryseg);
                *paryseg = checkseg;
                break;
            }
        }
        if (!infected(spintet)) {
            // A boundary segment. Connect this segment to the new tets.
            sstbond1(checkseg, spintet);
            neightet = spintet;
            while (1) {
                tssbond1(spintet, checkseg);
                fnextself(spintet);
                if (spintet.tet == neightet.tet) break;
            }
        }
    } // i

    cavetetshlist->restart();
    cavetetseglist->restart();

    // Delete the old tets in cavity.
    for (i = 0; i < crosstets->objects; i++) {
        parytet = (triface*)fastlookup(crosstets, i);
        if (ishulltet(*parytet)) {
            hullsize--;
        }
        tetrahedrondealloc(parytet->tet);
    }

    crosstets->restart(); // crosstets will be re-used.

    // Collect new tets in cavity.  Some new tets have already been found
    //   (and infected) in the fillcavity(). We first collect them.
    for (j = 0; j < 2; j++) {
        newtets = (j == 0 ? topnewtets : botnewtets);
        if (newtets != NULL) {
            for (i = 0; i < newtets->objects; i++) {
                parytet = (triface*)fastlookup(newtets, i);
                if (infected(*parytet)) {
                    crosstets->newindex((void**)&pnewtet);
                    *pnewtet = *parytet;
                }
            } // i
        }
    } // j

    // Now we collect all new tets in cavity.
    for (i = 0; i < crosstets->objects; i++) {
        parytet = (triface*)fastlookup(crosstets, i);
        for (j = 0; j < 4; j++) {
            decode(parytet->tet[j], neightet);
            if (marktested(neightet)) { // Is it a new tet?
                if (!infected(neightet)) {
                    // Find an interior tet.
                    // assert((point) neightet.tet[7] != dummypoint); // SELF_CHECK
                    infect(neightet);
                    crosstets->newindex((void**)&pnewtet);
                    *pnewtet = neightet;
                }
            }
        } // j
    }     // i

    parytet = (triface*)fastlookup(crosstets, 0);
    recenttet = *parytet; // Remember a live handle.

    // Delete outer new tets.
    for (j = 0; j < 2; j++) {
        newtets = (j == 0 ? topnewtets : botnewtets);
        if (newtets != NULL) {
            for (i = 0; i < newtets->objects; i++) {
                parytet = (triface*)fastlookup(newtets, i);
                if (infected(*parytet)) {
                    // This is an interior tet.
                    uninfect(*parytet);
                    unmarktest(*parytet);
                    if (ishulltet(*parytet)) {
                        hullsize++;
                    }
                } else {
                    // An outer tet. Delete it.
                    tetrahedrondealloc(parytet->tet);
                }
            }
        }
    }

    crosstets->restart();
    topnewtets->restart();
    if (botnewtets != NULL) {
        botnewtets->restart();
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// restorecavity()    Reconnect old tets and delete new tets of the cavity.  //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::restorecavity(arraypool* crosstets, arraypool* topnewtets, arraypool* botnewtets,
                               arraypool* missingshbds) {
    triface *parytet, neightet, spintet;
    face* parysh;
    face checkseg;
    point* ppt;
    int t1ver;
    int i, j;

    // Reconnect crossing tets to cavity boundary.
    for (i = 0; i < crosstets->objects; i++) {
        parytet = (triface*)fastlookup(crosstets, i);
        parytet->ver = 0;
        for (parytet->ver = 0; parytet->ver < 4; parytet->ver++) {
            fsym(*parytet, neightet);
            if (!infected(neightet)) {
                // Restore the old connections of tets.
                bond(*parytet, neightet);
            }
        }
        // Update the point-to-tet map.
        parytet->ver = 0;
        ppt = (point*)&(parytet->tet[4]);
        for (j = 0; j < 4; j++) {
            setpoint2tet(ppt[j], encode(*parytet));
        }
    }

    // Uninfect all crossing tets.
    for (i = 0; i < crosstets->objects; i++) {
        parytet = (triface*)fastlookup(crosstets, i);
        uninfect(*parytet);
    }

    // Remember a live handle.
    if (crosstets->objects > 0) {
        recenttet = *(triface*)fastlookup(crosstets, 0);
    }

    // Delete faked segments.
    for (i = 0; i < missingshbds->objects; i++) {
        parysh = (face*)fastlookup(missingshbds, i);
        sspivot(*parysh, checkseg);
        if (checkseg.sh[3] != NULL) {
            if (sinfected(checkseg)) {
                // It's a faked segment. Delete it.
                sstpivot1(checkseg, neightet);
                spintet = neightet;
                while (1) {
                    tssdissolve1(spintet);
                    fnextself(spintet);
                    if (spintet.tet == neightet.tet) break;
                }
                shellfacedealloc(subsegs, checkseg.sh);
                ssdissolve(*parysh);
                // checkseg.sh = NULL;
            }
        }
    } // i

    // Delete new tets.
    for (i = 0; i < topnewtets->objects; i++) {
        parytet = (triface*)fastlookup(topnewtets, i);
        tetrahedrondealloc(parytet->tet);
    }

    if (botnewtets != NULL) {
        for (i = 0; i < botnewtets->objects; i++) {
            parytet = (triface*)fastlookup(botnewtets, i);
            tetrahedrondealloc(parytet->tet);
        }
    }

    crosstets->restart();
    topnewtets->restart();
    if (botnewtets != NULL) {
        botnewtets->restart();
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// flipcertify()    Insert a crossing face into priority queue.              //
//                                                                           //
// A crossing face of a facet must have at least one top and one bottom ver- //
// tex of the facet.                                                         //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::flipcertify(triface* chkface, badface** pqueue, point plane_pa, point plane_pb,
                             point plane_pc) {
    badface *parybf, *prevbf, *nextbf;
    triface neightet;
    face checksh;
    point p[5];
    REAL w[5];
    REAL insph, ori4;
    int topi, boti;
    int i;

    // Compute the flip time \tau.
    fsym(*chkface, neightet);

    p[0] = org(*chkface);
    p[1] = dest(*chkface);
    p[2] = apex(*chkface);
    p[3] = oppo(*chkface);
    p[4] = oppo(neightet);

    // Check if the face is a crossing face.
    topi = boti = 0;
    for (i = 0; i < 3; i++) {
        if (pmarktest2ed(p[i])) topi++;
        if (pmarktest3ed(p[i])) boti++;
    }
    if ((topi == 0) || (boti == 0)) {
        // It is not a crossing face.
        // return;
        for (i = 3; i < 5; i++) {
            if (pmarktest2ed(p[i])) topi++;
            if (pmarktest3ed(p[i])) boti++;
        }
        if ((topi == 0) || (boti == 0)) {
            // The two tets sharing at this face are on one side of the facet.
            // Check if this face is locally Delaunay (due to rounding error).
            if ((p[3] != dummypoint) && (p[4] != dummypoint)) {
                // Do not check it if it is a subface.
                tspivot(*chkface, checksh);
                if (checksh.sh == NULL) {
                    insph = insphere_s(p[1], p[0], p[2], p[3], p[4]);
                    if (insph > 0) {
                        // Add the face into queue.
                        if (b->verbose > 2) {
                            printf("      A locally non-Delanay face (%d, %d, %d)-%d,%d\n",
                                   pointmark(p[0]), pointmark(p[1]), pointmark(p[2]),
                                   pointmark(p[3]), pointmark(p[4]));
                        }
                        parybf = (badface*)flippool->alloc();
                        parybf->key = 0.; // tau = 0, do immediately.
                        parybf->tt = *chkface;
                        parybf->forg = p[0];
                        parybf->fdest = p[1];
                        parybf->fapex = p[2];
                        parybf->foppo = p[3];
                        parybf->noppo = p[4];
                        // Add it at the top of the priority queue.
                        if (*pqueue == NULL) {
                            *pqueue = parybf;
                            parybf->nextitem = NULL;
                        } else {
                            parybf->nextitem = *pqueue;
                            *pqueue = parybf;
                        }
                    } // if (insph > 0)
                }     // if (checksh.sh == NULL)
            }
        }
        return; // Test: omit this face.
    }

    // Decide the "height" for each point.
    for (i = 0; i < 5; i++) {
        if (pmarktest2ed(p[i])) {
            // A top point has a positive weight.
            w[i] = orient3dfast(plane_pa, plane_pb, plane_pc, p[i]);
            if (w[i] < 0) w[i] = -w[i];
        } else {
            w[i] = 0;
        }
    }

    insph = insphere(p[1], p[0], p[2], p[3], p[4]);
    ori4 = orient4d(p[1], p[0], p[2], p[3], p[4], w[1], w[0], w[2], w[3], w[4]);
    if (ori4 > 0) {
        // Add the face into queue.
        if (b->verbose > 2) {
            printf("      Insert face (%d, %d, %d) - %d, %d\n", pointmark(p[0]), pointmark(p[1]),
                   pointmark(p[2]), pointmark(p[3]), pointmark(p[4]));
        }

        parybf = (badface*)flippool->alloc();

        parybf->key = -insph / ori4;
        parybf->tt = *chkface;
        parybf->forg = p[0];
        parybf->fdest = p[1];
        parybf->fapex = p[2];
        parybf->foppo = p[3];
        parybf->noppo = p[4];

        // Push the face into priority queue.
        // pq.push(bface);
        if (*pqueue == NULL) {
            *pqueue = parybf;
            parybf->nextitem = NULL;
        } else {
            // Search an item whose key is larger or equal to current key.
            prevbf = NULL;
            nextbf = *pqueue;
            // if (!b->flipinsert_random) { // Default use a priority queue.
            // Insert the item into priority queue.
            while (nextbf != NULL) {
                if (nextbf->key < parybf->key) {
                    prevbf = nextbf;
                    nextbf = nextbf->nextitem;
                } else {
                    break;
                }
            }
            //} // if (!b->flipinsert_random)
            // Insert the new item between prev and next items.
            if (prevbf == NULL) {
                *pqueue = parybf;
            } else {
                prevbf->nextitem = parybf;
            }
            parybf->nextitem = nextbf;
        }
    } else if (ori4 == 0) {
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// flipinsertfacet()    Insert a facet into a CDT by flips.                  //
//                                                                           //
// The algorithm is described in Shewchuk's paper "Updating and Constructing //
// Constrained Delaunay and Constrained Regular Triangulations by Flips", in //
// Proc. 19th Ann. Symp. on Comput. Geom., 86--95, 2003.                     //
//                                                                           //
// 'crosstets' contains the set of crossing tetrahedra (infected) of the     //
// facet.  'toppoints' and 'botpoints' are points lies above and below the   //
// facet, not on the facet.                                                  //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::flipinsertfacet(arraypool* crosstets, arraypool* toppoints, arraypool* botpoints,
                                 arraypool* midpoints) {
    arraypool *crossfaces, *bfacearray;
    triface fliptets[6], baktets[2], fliptet, newface;
    triface neightet, *parytet;
    badface* pqueue;
    badface *popbf, bface;
    point plane_pa, plane_pb, plane_pc;
    point p1, p2, pd, pe;
    point* parypt;
    flipconstraints fc;
    REAL ori[3];
    int convcount, copcount;
    int flipflag, fcount;
    int n, i;
    long f23count, f32count, f44count;
    long totalfcount;

    f23count = flip23count;
    f32count = flip32count;
    f44count = flip44count;

    // Get three affinely independent vertices in the missing region R.
    calculateabovepoint(midpoints, &plane_pa, &plane_pb, &plane_pc);

    // Mark top and bottom points. Do not mark midpoints.
    for (i = 0; i < toppoints->objects; i++) {
        parypt = (point*)fastlookup(toppoints, i);
        if (!pmarktested(*parypt)) {
            pmarktest2(*parypt);
        }
    }
    for (i = 0; i < botpoints->objects; i++) {
        parypt = (point*)fastlookup(botpoints, i);
        if (!pmarktested(*parypt)) {
            pmarktest3(*parypt);
        }
    }

    // Collect crossing faces.
    crossfaces = cavetetlist; // Re-use array 'cavetetlist'.

    // Each crossing face contains at least one bottom vertex and
    //   one top vertex.
    for (i = 0; i < crosstets->objects; i++) {
        parytet = (triface*)fastlookup(crosstets, i);
        fliptet = *parytet;
        for (fliptet.ver = 0; fliptet.ver < 4; fliptet.ver++) {
            fsym(fliptet, neightet);
            if (infected(neightet)) {        // It is an interior face.
                if (!marktested(neightet)) { // It is an unprocessed face.
                    crossfaces->newindex((void**)&parytet);
                    *parytet = fliptet;
                }
            }
        }
        marktest(fliptet);
    }

    if (b->verbose > 1) {
        printf("    Found %ld crossing faces.\n", crossfaces->objects);
    }

    for (i = 0; i < crosstets->objects; i++) {
        parytet = (triface*)fastlookup(crosstets, i);
        unmarktest(*parytet);
        uninfect(*parytet);
    }

    // Initialize the priority queue.
    pqueue = NULL;

    for (i = 0; i < crossfaces->objects; i++) {
        parytet = (triface*)fastlookup(crossfaces, i);
        flipcertify(parytet, &pqueue, plane_pa, plane_pb, plane_pc);
    }
    crossfaces->restart();

    // The list for temporarily storing unflipable faces.
    bfacearray = new arraypool(sizeof(triface), 4);

    fcount = 0; // Count the number of flips.

    // Flip insert the facet.
    while (pqueue != NULL) {

        // Pop a face from the priority queue.
        popbf = pqueue;
        bface = *popbf;
        // Update the queue.
        pqueue = pqueue->nextitem;
        // Delete the popped item from the pool.
        flippool->dealloc((void*)popbf);

        if (!isdeadtet(bface.tt)) {
            if ((org(bface.tt) == bface.forg) && (dest(bface.tt) == bface.fdest) &&
                (apex(bface.tt) == bface.fapex) && (oppo(bface.tt) == bface.foppo)) {
                // It is still a crossing face of R.
                fliptet = bface.tt;
                fsym(fliptet, neightet);
                if (oppo(neightet) == bface.noppo) {
                    pd = oppo(fliptet);
                    pe = oppo(neightet);

                    if (b->verbose > 2) {
                        printf("      Get face (%d, %d, %d) - %d, %d, tau = %.17g\n",
                               pointmark(bface.forg), pointmark(bface.fdest),
                               pointmark(bface.fapex), pointmark(bface.foppo),
                               pointmark(bface.noppo), bface.key);
                    }
                    flipflag = 0;

                    // Check for which type of flip can we do.
                    convcount = 3;
                    copcount = 0;
                    for (i = 0; i < 3; i++) {
                        p1 = org(fliptet);
                        p2 = dest(fliptet);
                        ori[i] = orient3d(p1, p2, pd, pe);
                        if (ori[i] < 0) {
                            convcount--;
                            // break;
                        } else if (ori[i] == 0) {
                            convcount--; // Possible 4-to-4 flip.
                            copcount++;
                            // break;
                        }
                        enextself(fliptet);
                    }

                    if (convcount == 3) {
                        // A 2-to-3 flip is found.
                        fliptets[0] = fliptet;  // abcd, d may be the new vertex.
                        fliptets[1] = neightet; // bace.
                        flip23(fliptets, 1, &fc);
                        // Put the link faces into check list.
                        for (i = 0; i < 3; i++) {
                            eprevesym(fliptets[i], newface);
                            crossfaces->newindex((void**)&parytet);
                            *parytet = newface;
                        }
                        for (i = 0; i < 3; i++) {
                            enextesym(fliptets[i], newface);
                            crossfaces->newindex((void**)&parytet);
                            *parytet = newface;
                        }
                        flipflag = 1;
                    } else if (convcount == 2) {
                        // if (copcount <= 1) {
                        // A 3-to-2 or 4-to-4 may be possible.
                        // Get the edge which is locally non-convex or flat.
                        for (i = 0; i < 3; i++) {
                            if (ori[i] <= 0) break;
                            enextself(fliptet);
                        }

                        // Collect tets sharing at this edge.
                        esym(fliptet, fliptets[0]); // [b,a,d,c]
                        n = 0;
                        do {
                            p1 = apex(fliptets[n]);
                            if (!(pmarktested(p1) || pmarktest2ed(p1) || pmarktest3ed(p1))) {
                                // This apex is not on the cavity. Hence the face does not
                                //   lie inside the cavity. Do not flip this edge.
                                n = 1000;
                                break;
                            }
                            fnext(fliptets[n], fliptets[n + 1]);
                            n++;
                        } while ((fliptets[n].tet != fliptet.tet) && (n < 5));

                        if (n == 3) {
                            // Found a 3-to-2 flip.
                            flip32(fliptets, 1, &fc);
                            // Put the link faces into check list.
                            for (i = 0; i < 3; i++) {
                                esym(fliptets[0], newface);
                                crossfaces->newindex((void**)&parytet);
                                *parytet = newface;
                                enextself(fliptets[0]);
                            }
                            for (i = 0; i < 3; i++) {
                                esym(fliptets[1], newface);
                                crossfaces->newindex((void**)&parytet);
                                *parytet = newface;
                                enextself(fliptets[1]);
                            }
                            flipflag = 1;
                        } else if (n == 4) {
                            if (copcount == 1) {
                                // Found a 4-to-4 flip.
                                // Let the six vertices are: a,b,c,d,e,f, where
                                //   fliptets[0] = [b,a,d,c]
                                //           [1] = [b,a,c,e]
                                //           [2] = [b,a,e,f]
                                //           [3] = [b,a,f,d]
                                // After the 4-to-4 flip, edge [a,b] is flipped, edge [e,d]
                                //   is created.
                                // First do a 2-to-3 flip.
                                // Comment: This flip temporarily creates a degenerated
                                //   tet (whose volume is zero). It will be removed by the
                                //   followed 3-to-2 flip.
                                fliptets[0] = fliptet; // = [a,b,c,d], d is the new vertex.
                                // fliptets[1];        // = [b,a,c,e].
                                baktets[0] = fliptets[2]; // = [b,a,e,f]
                                baktets[1] = fliptets[3]; // = [b,a,f,d]
                                // The flip may involve hull tets.
                                flip23(fliptets, 1, &fc);
                                // Put the "outer" link faces into check list.
                                //   fliptets[0] = [e,d,a,b] => will be flipped, so
                                //   [a,b,d] and [a,b,e] are not "outer" link faces.
                                for (i = 1; i < 3; i++) {
                                    eprevesym(fliptets[i], newface);
                                    crossfaces->newindex((void**)&parytet);
                                    *parytet = newface;
                                }
                                for (i = 1; i < 3; i++) {
                                    enextesym(fliptets[i], newface);
                                    crossfaces->newindex((void**)&parytet);
                                    *parytet = newface;
                                }
                                // Then do a 3-to-2 flip.
                                enextesymself(fliptets[0]); // fliptets[0] is [e,d,a,b].
                                eprevself(fliptets[0]);     // = [b,a,d,c], d is the new vertex.
                                fliptets[1] = baktets[0];   // = [b,a,e,f]
                                fliptets[2] = baktets[1];   // = [b,a,f,d]
                                flip32(fliptets, 1, &fc);
                                // Put the "outer" link faces into check list.
                                //   fliptets[0] = [d,e,f,a]
                                //   fliptets[1] = [e,d,f,b]
                                //   Faces [a,b,d] and [a,b,e] are not "outer" link faces.
                                enextself(fliptets[0]);
                                for (i = 1; i < 3; i++) {
                                    esym(fliptets[0], newface);
                                    crossfaces->newindex((void**)&parytet);
                                    *parytet = newface;
                                    enextself(fliptets[0]);
                                }
                                enextself(fliptets[1]);
                                for (i = 1; i < 3; i++) {
                                    esym(fliptets[1], newface);
                                    crossfaces->newindex((void**)&parytet);
                                    *parytet = newface;
                                    enextself(fliptets[1]);
                                }
                                flip23count--;
                                flip32count--;
                                flip44count++;
                                flipflag = 1;
                            }
                        }
                    } else {
                        // There are more than 1 non-convex or coplanar cases.
                        flipflag = -1; // Ignore this face.
                        if (b->verbose > 2) {
                            printf("        Ignore face (%d, %d, %d) - %d, %d, tau = %.17g\n",
                                   pointmark(bface.forg), pointmark(bface.fdest),
                                   pointmark(bface.fapex), pointmark(bface.foppo),
                                   pointmark(bface.noppo), bface.key);
                        }
                    } // if (convcount == 1)

                    if (flipflag == 1) {
                        // Update the priority queue.
                        for (i = 0; i < crossfaces->objects; i++) {
                            parytet = (triface*)fastlookup(crossfaces, i);
                            flipcertify(parytet, &pqueue, plane_pa, plane_pb, plane_pc);
                        }
                        crossfaces->restart();
                        if (1) { // if (!b->flipinsert_random) {
                            // Insert all queued unflipped faces.
                            for (i = 0; i < bfacearray->objects; i++) {
                                parytet = (triface*)fastlookup(bfacearray, i);
                                // This face may be changed.
                                if (!isdeadtet(*parytet)) {
                                    flipcertify(parytet, &pqueue, plane_pa, plane_pb, plane_pc);
                                }
                            }
                            bfacearray->restart();
                        }
                        fcount++;
                    } else if (flipflag == 0) {
                        // Queue an unflippable face. To process it later.
                        bfacearray->newindex((void**)&parytet);
                        *parytet = fliptet;
                    }
                } // if (pe == bface.noppo)
            }     // if ((pa == bface.forg) && ...)
        }         // if (bface.tt != NULL)

    } // while (pqueue != NULL)

    if (bfacearray->objects > 0) {
        if (fcount == 0) {
            printf("!! No flip is found in %ld faces.\n", bfacearray->objects);
            terminatetetgen(this, 2); // assert(0);
        }
    }

    delete bfacearray;

    // Un-mark top and bottom points.
    for (i = 0; i < toppoints->objects; i++) {
        parypt = (point*)fastlookup(toppoints, i);
        punmarktest2(*parypt);
    }
    for (i = 0; i < botpoints->objects; i++) {
        parypt = (point*)fastlookup(botpoints, i);
        punmarktest3(*parypt);
    }

    f23count = flip23count - f23count;
    f32count = flip32count - f32count;
    f44count = flip44count - f44count;
    totalfcount = f23count + f32count + f44count;
    if (b->verbose > 2) {
        printf("      Total %ld flips. f23(%ld), f32(%ld), f44(%ld).\n", totalfcount, f23count,
               f32count, f44count);
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// insertpoint_cdt()    Insert a new point into a CDT.                       //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::insertpoint_cdt(point newpt, triface* searchtet, face* splitsh, face* splitseg,
                                insertvertexflags* ivf, arraypool* cavpoints, arraypool* cavfaces,
                                arraypool* cavshells, arraypool* newtets, arraypool* crosstets,
                                arraypool* misfaces) {
    triface neightet, *parytet;
    face checksh, *parysh, *parysh1;
    face *paryseg, *paryseg1;
    point* parypt;
    int t1ver;
    int i;

    if (b->verbose > 2) {
        printf("      Insert point %d into CDT\n", pointmark(newpt));
    }

    if (!insertpoint(newpt, searchtet, NULL, NULL, ivf)) {
        // Point is not inserted. Check ivf->iloc for reason.
        return 0;
    }

    for (i = 0; i < cavetetvertlist->objects; i++) {
        cavpoints->newindex((void**)&parypt);
        *parypt = *(point*)fastlookup(cavetetvertlist, i);
    }
    // Add the new point into the point list.
    cavpoints->newindex((void**)&parypt);
    *parypt = newpt;

    for (i = 0; i < cavebdrylist->objects; i++) {
        cavfaces->newindex((void**)&parytet);
        *parytet = *(triface*)fastlookup(cavebdrylist, i);
    }

    for (i = 0; i < caveoldtetlist->objects; i++) {
        crosstets->newindex((void**)&parytet);
        *parytet = *(triface*)fastlookup(caveoldtetlist, i);
    }

    cavetetvertlist->restart();
    cavebdrylist->restart();
    caveoldtetlist->restart();

    // Insert the point using the cavity algorithm.
    delaunizecavity(cavpoints, cavfaces, cavshells, newtets, crosstets, misfaces);
    fillcavity(cavshells, NULL, NULL, NULL, NULL, NULL, NULL);
    carvecavity(crosstets, newtets, NULL);

    if ((splitsh != NULL) || (splitseg != NULL)) {
        // Insert the point into the surface mesh.
        sinsertvertex(newpt, splitsh, splitseg, ivf->sloc, ivf->sbowywat, 0);

        // Put all new subfaces into stack.
        for (i = 0; i < caveshbdlist->objects; i++) {
            // Get an old subface at edge [a, b].
            parysh = (face*)fastlookup(caveshbdlist, i);
            spivot(*parysh, checksh); // The new subface [a, b, p].
            // Do not recover a deleted new face (degenerated).
            if (checksh.sh[3] != NULL) {
                subfacstack->newindex((void**)&parysh);
                *parysh = checksh;
            }
        }

        if (splitseg != NULL) {
            // Queue two new subsegments in C(p) for recovery.
            for (i = 0; i < cavesegshlist->objects; i++) {
                paryseg = (face*)fastlookup(cavesegshlist, i);
                subsegstack->newindex((void**)&paryseg1);
                *paryseg1 = *paryseg;
            }
        } // if (splitseg != NULL)

        // Delete the old subfaces in sC(p).
        for (i = 0; i < caveshlist->objects; i++) {
            parysh = (face*)fastlookup(caveshlist, i);
            if (checksubfaceflag) {
                // It is possible that this subface still connects to adjacent
                //   tets which are not in C(p). If so, clear connections in the
                //   adjacent tets at this subface.
                stpivot(*parysh, neightet);
                if (neightet.tet != NULL) {
                    if (neightet.tet[4] != NULL) {
                        // Found an adjacent tet. It must be not in C(p).
                        tsdissolve(neightet);
                        fsymself(neightet);
                        tsdissolve(neightet);
                    }
                }
            }
            shellfacedealloc(subfaces, parysh->sh);
        }
        if (splitseg != NULL) {
            // Delete the old segment in sC(p).
            shellfacedealloc(subsegs, splitseg->sh);
        }

        // Clear working lists.
        caveshlist->restart();
        caveshbdlist->restart();
        cavesegshlist->restart();
    } // if ((splitsh != NULL) || (splitseg != NULL))

    // Put all interior subfaces into stack for recovery.
    // They were collected in carvecavity().
    // Note: Some collected subfaces may be deleted by sinsertvertex().
    for (i = 0; i < caveencshlist->objects; i++) {
        parysh = (face*)fastlookup(caveencshlist, i);
        if (parysh->sh[3] != NULL) {
            subfacstack->newindex((void**)&parysh1);
            *parysh1 = *parysh;
        }
    }

    // Put all interior segments into stack for recovery.
    // They were collected in carvecavity().
    // Note: Some collected segments may be deleted by sinsertvertex().
    for (i = 0; i < caveencseglist->objects; i++) {
        paryseg = (face*)fastlookup(caveencseglist, i);
        if (paryseg->sh[3] != NULL) {
            subsegstack->newindex((void**)&paryseg1);
            *paryseg1 = *paryseg;
        }
    }

    caveencshlist->restart();
    caveencseglist->restart();

    return 1;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// refineregion()    Refine a missing region by inserting points.            //
//                                                                           //
// 'splitsh' represents an edge of the facet to be split. It must be not a   //
// segment.
//                                                                           //
// Assumption: The current mesh is a CDT and is convex.                      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::refineregion(face& splitsh, arraypool* cavpoints, arraypool* cavfaces,
                              arraypool* cavshells, arraypool* newtets, arraypool* crosstets,
                              arraypool* misfaces) {
    triface searchtet, spintet;
    face splitseg, *paryseg;
    point steinpt, pa, pb, refpt;
    insertvertexflags ivf;
    enum interresult dir;
    long baknum = points->items;
    int t1ver;
    int i;

    // Do not split a segment.
    for (i = 0; i < 3; i++) {
        sspivot(splitsh, splitseg);
        if (splitseg.sh == NULL) break;
        senextself(splitsh);
    }

    if (b->verbose > 2) {
        printf("      Refining region at edge (%d, %d, %d).\n", pointmark(sorg(splitsh)),
               pointmark(sdest(splitsh)), pointmark(sapex(splitsh)));
    }

    // Add the Steiner point at the barycenter of the face.
    pa = sorg(splitsh);
    pb = sdest(splitsh);
    // Create a new point.
    makepoint(&steinpt, FREEFACETVERTEX);
    for (i = 0; i < 3; i++) {
        steinpt[i] = 0.5 * (pa[i] + pb[i]);
    }

    ivf.bowywat = 1; // Use the Bowyer-Watson algorrithm.
    ivf.cdtflag = 1; // Only create the initial cavity.
    ivf.sloc = (int)ONEDGE;
    ivf.sbowywat = 1;
    ivf.assignmeshsize = b->metric;
    ivf.smlenflag = useinsertradius; // Return the closet mesh vertex.

    point2tetorg(pa, searchtet); // Start location from it.
    ivf.iloc = (int)OUTSIDE;

    ivf.rejflag = 1; // Reject it if it encroaches upon any segment.
    if (!insertpoint_cdt(steinpt, &searchtet, &splitsh, NULL, &ivf, cavpoints, cavfaces, cavshells,
                         newtets, crosstets, misfaces)) {
        if (ivf.iloc == (int)ENCSEGMENT) {
            pointdealloc(steinpt);
            // Split an encroached segment.
            i = randomnation(encseglist->objects);
            paryseg = (face*)fastlookup(encseglist, i);
            splitseg = *paryseg;
            encseglist->restart();

            // Split the segment.
            pa = sorg(splitseg);
            pb = sdest(splitseg);
            // Create a new point.
            makepoint(&steinpt, FREESEGVERTEX);
            for (i = 0; i < 3; i++) {
                steinpt[i] = 0.5 * (pa[i] + pb[i]);
            }
            point2tetorg(pa, searchtet);
            ivf.iloc = (int)OUTSIDE;
            ivf.rejflag = 0;
            if (!insertpoint_cdt(steinpt, &searchtet, &splitsh, &splitseg, &ivf, cavpoints,
                                 cavfaces, cavshells, newtets, crosstets, misfaces)) {
                terminatetetgen(this, 2);
            }
            if (useinsertradius) {
                save_segmentpoint_insradius(steinpt, ivf.parentpt, ivf.smlen);
            }
            st_segref_count++;
            if (steinerleft > 0) steinerleft--;
        } else {
            terminatetetgen(this, 2); // assert(0);
        }
    } else {
        if (useinsertradius) {
            save_facetpoint_insradius(steinpt, ivf.parentpt, ivf.smlen);
        }
        st_facref_count++;
        if (steinerleft > 0) steinerleft--;
    }

    while (subsegstack->objects > 0l) {
        // seglist is used as a stack.
        subsegstack->objects--;
        paryseg = (face*)fastlookup(subsegstack, subsegstack->objects);
        splitseg = *paryseg;

        // Check if this segment has been recovered.
        sstpivot1(splitseg, searchtet);
        if (searchtet.tet != NULL) continue;

        // Search the segment.
        dir = scoutsegment(sorg(splitseg), sdest(splitseg), &splitseg, &searchtet, &refpt, NULL);
        if (dir == SHAREEDGE) {
            // Found this segment, insert it.
            // Let the segment remember an adjacent tet.
            sstbond1(splitseg, searchtet);
            // Bond the segment to all tets containing it.
            spintet = searchtet;
            do {
                tssbond1(spintet, splitseg);
                fnextself(spintet);
            } while (spintet.tet != searchtet.tet);
        } else {
            if ((dir == ACROSSFACE) || (dir == ACROSSEDGE)) {
                // Split the segment.
                makepoint(&steinpt, FREESEGVERTEX);
                getsteinerptonsegment(&splitseg, refpt, steinpt);
                ivf.iloc = (int)OUTSIDE;
                ivf.rejflag = 0;
                if (!insertpoint_cdt(steinpt, &searchtet, &splitsh, &splitseg, &ivf, cavpoints,
                                     cavfaces, cavshells, newtets, crosstets, misfaces)) {
                    terminatetetgen(this, 2);
                }
                if (useinsertradius) {
                    save_segmentpoint_insradius(steinpt, ivf.parentpt, ivf.smlen);
                }
                st_segref_count++;
                if (steinerleft > 0) steinerleft--;
            } else {
                terminatetetgen(this, 2);
            }
        }
    } // while

    if (b->verbose > 2) {
        printf("      Added %ld Steiner points.\n", points->items - baknum);
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// constrainedfacets()    Recover constrained facets in a CDT.               //
//                                                                           //
// All unrecovered subfaces are queued in 'subfacestack'.                    //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::constrainedfacets() {
    arraypool *tg_crosstets, *tg_topnewtets, *tg_botnewtets;
    arraypool *tg_topfaces, *tg_botfaces, *tg_midfaces;
    arraypool *tg_topshells, *tg_botshells, *tg_facfaces;
    arraypool *tg_toppoints, *tg_botpoints;
    arraypool *tg_missingshs, *tg_missingshbds, *tg_missingshverts;
    triface searchtet, neightet, crossedge;
    face searchsh, *parysh, *parysh1;
    face* paryseg;
    point* parypt;
    enum interresult dir;
    int facetcount;
    int success;
    int t1ver;
    int i, j;

    // Initialize arrays.
    tg_crosstets = new arraypool(sizeof(triface), 10);
    tg_topnewtets = new arraypool(sizeof(triface), 10);
    tg_botnewtets = new arraypool(sizeof(triface), 10);
    tg_topfaces = new arraypool(sizeof(triface), 10);
    tg_botfaces = new arraypool(sizeof(triface), 10);
    tg_midfaces = new arraypool(sizeof(triface), 10);
    tg_toppoints = new arraypool(sizeof(point), 8);
    tg_botpoints = new arraypool(sizeof(point), 8);
    tg_facfaces = new arraypool(sizeof(face), 10);
    tg_topshells = new arraypool(sizeof(face), 10);
    tg_botshells = new arraypool(sizeof(face), 10);
    tg_missingshs = new arraypool(sizeof(face), 10);
    tg_missingshbds = new arraypool(sizeof(face), 10);
    tg_missingshverts = new arraypool(sizeof(point), 8);
    // This is a global array used by refineregion().
    encseglist = new arraypool(sizeof(face), 4);

    facetcount = 0;

    while (subfacstack->objects > 0l) {

        subfacstack->objects--;
        parysh = (face*)fastlookup(subfacstack, subfacstack->objects);
        searchsh = *parysh;

        if (searchsh.sh[3] == NULL) continue; // It is dead.
        if (isshtet(searchsh)) continue;      // It is recovered.

        // Collect all unrecovered subfaces which are co-facet.
        smarktest(searchsh);
        tg_facfaces->newindex((void**)&parysh);
        *parysh = searchsh;
        for (i = 0; i < tg_facfaces->objects; i++) {
            parysh = (face*)fastlookup(tg_facfaces, i);
            for (j = 0; j < 3; j++) {
                if (!isshsubseg(*parysh)) {
                    spivot(*parysh, searchsh);
                    if (!smarktested(searchsh)) {
                        if (!isshtet(searchsh)) {
                            smarktest(searchsh);
                            tg_facfaces->newindex((void**)&parysh1);
                            *parysh1 = searchsh;
                        }
                    }
                }
                senextself(*parysh);
            } // j
        }     // i
        // Have found all facet subfaces. Unmark them.
        for (i = 0; i < tg_facfaces->objects; i++) {
            parysh = (face*)fastlookup(tg_facfaces, i);
            sunmarktest(*parysh);
        }

        if (b->verbose > 1) {
            printf("    Recovering facet #%d: %ld subfaces.\n", facetcount + 1,
                   tg_facfaces->objects);
        }
        facetcount++;

        while (tg_facfaces->objects > 0l) {

            tg_facfaces->objects--;
            parysh = (face*)fastlookup(tg_facfaces, tg_facfaces->objects);
            searchsh = *parysh;

            if (searchsh.sh[3] == NULL) continue; // It is dead.
            if (isshtet(searchsh)) continue;      // It is recovered.

            searchtet.tet = NULL;
            if (scoutsubface(&searchsh, &searchtet, 1)) continue;

            // The subface is missing. Form the missing region.
            //   Re-use 'tg_crosstets' for 'adjtets'.
            formregion(&searchsh, tg_missingshs, tg_missingshbds, tg_missingshverts);

            int searchflag = scoutcrossedge(searchtet, tg_missingshbds, tg_missingshs);
            if (searchflag > 0) {
                // Save this crossing edge, will be used by fillcavity().
                crossedge = searchtet;
                // Form a cavity of crossing tets.
                success = formcavity(&searchtet, tg_missingshs, tg_crosstets, tg_topfaces,
                                     tg_botfaces, tg_toppoints, tg_botpoints);
                if (success) {
                    if (!b->flipinsert) {
                        // Tetrahedralize the top part. Re-use 'tg_midfaces'.
                        delaunizecavity(tg_toppoints, tg_topfaces, tg_topshells, tg_topnewtets,
                                        tg_crosstets, tg_midfaces);
                        // Tetrahedralize the bottom part. Re-use 'tg_midfaces'.
                        delaunizecavity(tg_botpoints, tg_botfaces, tg_botshells, tg_botnewtets,
                                        tg_crosstets, tg_midfaces);
                        // Fill the cavity with new tets.
                        success = fillcavity(tg_topshells, tg_botshells, tg_midfaces, tg_missingshs,
                                             tg_topnewtets, tg_botnewtets, &crossedge);
                        if (success) {
                            // Cavity is remeshed. Delete old tets and outer new tets.
                            carvecavity(tg_crosstets, tg_topnewtets, tg_botnewtets);
                        } else {
                            restorecavity(tg_crosstets, tg_topnewtets, tg_botnewtets,
                                          tg_missingshbds);
                        }
                    } else {
                        // Use the flip algorithm of Shewchuk to recover the subfaces.
                        flipinsertfacet(tg_crosstets, tg_toppoints, tg_botpoints,
                                        tg_missingshverts);
                        // Put all subfaces in R back to tg_facfaces.
                        for (i = 0; i < tg_missingshs->objects; i++) {
                            parysh = (face*)fastlookup(tg_missingshs, i);
                            tg_facfaces->newindex((void**)&parysh1);
                            *parysh1 = *parysh;
                        }
                        success = 1;
                        // Clear working lists.
                        tg_crosstets->restart();
                        tg_topfaces->restart();
                        tg_botfaces->restart();
                        tg_toppoints->restart();
                        tg_botpoints->restart();
                    } // b->flipinsert

                    if (success) {
                        // Recover interior subfaces.
                        for (i = 0; i < caveencshlist->objects; i++) {
                            parysh = (face*)fastlookup(caveencshlist, i);
                            if (!scoutsubface(parysh, &searchtet, 1)) {
                                // Add this face at the end of the list, so it will be
                                //   processed immediately.
                                tg_facfaces->newindex((void**)&parysh1);
                                *parysh1 = *parysh;
                            }
                        }
                        caveencshlist->restart();
                        // Recover interior segments. This should always be recovered.
                        for (i = 0; i < caveencseglist->objects; i++) {
                            paryseg = (face*)fastlookup(caveencseglist, i);
                            dir = scoutsegment(sorg(*paryseg), sdest(*paryseg), paryseg, &searchtet,
                                               NULL, NULL);
                            if (dir != SHAREEDGE) {
                                terminatetetgen(this, 2);
                            }
                            // Insert this segment.
                            // Let the segment remember an adjacent tet.
                            sstbond1(*paryseg, searchtet);
                            // Bond the segment to all tets containing it.
                            neightet = searchtet;
                            do {
                                tssbond1(neightet, *paryseg);
                                fnextself(neightet);
                            } while (neightet.tet != searchtet.tet);
                        }
                        caveencseglist->restart();
                    } // success - remesh cavity
                }     // success - form cavity
                else {
                    terminatetetgen(this, 2); // Report a bug.
                }                             // Not success - form cavity
            } else {
                // Put all subfaces in R back to tg_facfaces.
                for (i = 0; i < tg_missingshs->objects; i++) {
                    parysh = (face*)fastlookup(tg_missingshs, i);
                    tg_facfaces->newindex((void**)&parysh1);
                    *parysh1 = *parysh;
                }
                if (searchflag != -1) {
                    // Some edge(s) in the missing regions were flipped.
                    success = 1;
                } else {
                    restorecavity(tg_crosstets, tg_topnewtets, tg_botnewtets,
                                  tg_missingshbds); // Only remove fake segments.
                    // Choose an edge to split (set in recentsh)
                    recentsh = searchsh;
                    success = 0; // Do refineregion();
                }
            } // if (scoutcrossedge)

            // Unmarktest all points of the missing region.
            for (i = 0; i < tg_missingshverts->objects; i++) {
                parypt = (point*)fastlookup(tg_missingshverts, i);
                punmarktest(*parypt);
            }
            tg_missingshverts->restart();
            tg_missingshbds->restart();
            tg_missingshs->restart();

            if (!success) {
                // The missing region can not be recovered. Refine it.
                refineregion(recentsh, tg_toppoints, tg_topfaces, tg_topshells, tg_topnewtets,
                             tg_crosstets, tg_midfaces);
            }
        } // while (tg_facfaces->objects)

    } // while ((subfacstack->objects)

    // Accumulate the dynamic memory.
    totalworkmemory +=
        (tg_crosstets->totalmemory + tg_topnewtets->totalmemory + tg_botnewtets->totalmemory +
         tg_topfaces->totalmemory + tg_botfaces->totalmemory + tg_midfaces->totalmemory +
         tg_toppoints->totalmemory + tg_botpoints->totalmemory + tg_facfaces->totalmemory +
         tg_topshells->totalmemory + tg_botshells->totalmemory + tg_missingshs->totalmemory +
         tg_missingshbds->totalmemory + tg_missingshverts->totalmemory + encseglist->totalmemory);

    // Delete arrays.
    delete tg_crosstets;
    delete tg_topnewtets;
    delete tg_botnewtets;
    delete tg_topfaces;
    delete tg_botfaces;
    delete tg_midfaces;
    delete tg_toppoints;
    delete tg_botpoints;
    delete tg_facfaces;
    delete tg_topshells;
    delete tg_botshells;
    delete tg_missingshs;
    delete tg_missingshbds;
    delete tg_missingshverts;
    delete encseglist;
    encseglist = NULL;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// constraineddelaunay()    Create a constrained Delaunay tetrahedralization.//
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::constraineddelaunay(clock_t& tv) {
    face searchsh, *parysh;
    face searchseg, *paryseg;
    int s, i;

    // Statistics.
    long bakfillregioncount;
    long bakcavitycount, bakcavityexpcount;
    long bakseg_ref_count;

    if (!b->quiet) {
        printf("Constrained Delaunay...\n");
    }

    makesegmentendpointsmap();
    makefacetverticesmap();

    if (b->verbose) {
        printf("  Delaunizing segments.\n");
    }

    checksubsegflag = 1;

    // Put all segments into the list (in random order).
    subsegs->traversalinit();
    for (i = 0; i < subsegs->items; i++) {
        s = randomnation(i + 1);
        // Move the s-th seg to the i-th.
        subsegstack->newindex((void**)&paryseg);
        *paryseg = *(face*)fastlookup(subsegstack, s);
        // Put i-th seg to be the s-th.
        searchseg.sh = shellfacetraverse(subsegs);
        // sinfect(searchseg);  // Only save it once.
        paryseg = (face*)fastlookup(subsegstack, s);
        *paryseg = searchseg;
    }

    // Recover non-Delaunay segments.
    delaunizesegments();

    if (b->verbose) {
        printf("  Inserted %ld Steiner points.\n", st_segref_count);
    }

    tv = clock();

    if (b->verbose) {
        printf("  Constraining facets.\n");
    }

    // Subfaces will be introduced.
    checksubfaceflag = 1;

    bakfillregioncount = fillregioncount;
    bakcavitycount = cavitycount;
    bakcavityexpcount = cavityexpcount;
    bakseg_ref_count = st_segref_count;

    // Randomly order the subfaces.
    subfaces->traversalinit();
    for (i = 0; i < subfaces->items; i++) {
        s = randomnation(i + 1);
        // Move the s-th subface to the i-th.
        subfacstack->newindex((void**)&parysh);
        *parysh = *(face*)fastlookup(subfacstack, s);
        // Put i-th subface to be the s-th.
        searchsh.sh = shellfacetraverse(subfaces);
        parysh = (face*)fastlookup(subfacstack, s);
        *parysh = searchsh;
    }

    // Recover facets.
    constrainedfacets();

    if (b->verbose) {
        if (fillregioncount > bakfillregioncount) {
            printf("  Remeshed %ld regions.\n", fillregioncount - bakfillregioncount);
        }
        if (cavitycount > bakcavitycount) {
            printf("  Remeshed %ld cavities", cavitycount - bakcavitycount);
            if (cavityexpcount - bakcavityexpcount) {
                printf(" (%ld enlarged)", cavityexpcount - bakcavityexpcount);
            }
            printf(".\n");
        }
        if (st_segref_count + st_facref_count - bakseg_ref_count > 0) {
            printf("  Inserted %ld (%ld, %ld) refine points.\n",
                   st_segref_count + st_facref_count - bakseg_ref_count,
                   st_segref_count - bakseg_ref_count, st_facref_count);
        }
    }
}

////                                                                       ////
////                                                                       ////
//// constrained_cxx //////////////////////////////////////////////////////////

//// steiner_cxx //////////////////////////////////////////////////////////////
////                                                                       ////
////                                                                       ////

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// checkflipeligibility()    A call back function for boundary recovery.     //
//                                                                           //
// 'fliptype' indicates which elementary flip will be performed: 1 : 2-to-3, //
// and 2 : 3-to-2, respectively.                                             //
//                                                                           //
// 'pa, ..., pe' are the vertices involved in this flip, where [a,b,c] is    //
// the flip face, and [d,e] is the flip edge. NOTE: 'pc' may be 'dummypoint',//
// other points must not be 'dummypoint'.                                    //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::checkflipeligibility(int fliptype, point pa, point pb, point pc, point pd, point pe,
                                     int level, int edgepivot, flipconstraints* fc) {
    point tmppts[3];
    enum interresult dir;
    int types[2], poss[4];
    int intflag;
    int rejflag = 0;
    int i;

    if (fc->seg[0] != NULL) {
        // A constraining edge is given (e.g., for edge recovery).
        if (fliptype == 1) {
            // A 2-to-3 flip: [a,b,c] => [e,d,a], [e,d,b], [e,d,c].
            tmppts[0] = pa;
            tmppts[1] = pb;
            tmppts[2] = pc;
            for (i = 0; i < 3 && !rejflag; i++) {
                if (tmppts[i] != dummypoint) {
                    // Test if the face [e,d,#] intersects the edge.
                    intflag = tri_edge_test(pe, pd, tmppts[i], fc->seg[0], fc->seg[1], NULL, 1,
                                            types, poss);
                    if (intflag == 2) {
                        // They intersect at a single point.
                        dir = (enum interresult)types[0];
                        if (dir == ACROSSFACE) {
                            // The interior of [e,d,#] intersect the segment.
                            rejflag = 1;
                        } else if (dir == ACROSSEDGE) {
                            if (poss[0] == 0) {
                                // The interior of [e,d] intersect the segment.
                                // Since [e,d] is the newly created edge. Reject this flip.
                                rejflag = 1;
                            }
                        }
                    } else if (intflag == 4) {
                        // They may intersect at either a point or a line segment.
                        dir = (enum interresult)types[0];
                        if (dir == ACROSSEDGE) {
                            if (poss[0] == 0) {
                                // The interior of [e,d] intersect the segment.
                                // Since [e,d] is the newly created edge. Reject this flip.
                                rejflag = 1;
                            }
                        }
                    }
                } // if (tmppts[0] != dummypoint)
            }     // i
        } else if (fliptype == 2) {
            // A 3-to-2 flip: [e,d,a], [e,d,b], [e,d,c] => [a,b,c]
            if (pc != dummypoint) {
                // Check if the new face [a,b,c] intersect the edge in its interior.
                intflag = tri_edge_test(pa, pb, pc, fc->seg[0], fc->seg[1], NULL, 1, types, poss);
                if (intflag == 2) {
                    // They intersect at a single point.
                    dir = (enum interresult)types[0];
                    if (dir == ACROSSFACE) {
                        // The interior of [a,b,c] intersect the segment.
                        rejflag = 1; // Do not flip.
                    }
                } else if (intflag == 4) {
                    // [a,b,c] is coplanar with the edge.
                    dir = (enum interresult)types[0];
                    if (dir == ACROSSEDGE) {
                        // The boundary of [a,b,c] intersect the segment.
                        rejflag = 1; // Do not flip.
                    }
                }
            } // if (pc != dummypoint)
        }
    } // if (fc->seg[0] != NULL)

    if ((fc->fac[0] != NULL) && !rejflag) {
        // A constraining face is given (e.g., for face recovery).
        if (fliptype == 1) {
            // A 2-to-3 flip.
            // Test if the new edge [e,d] intersects the face.
            intflag =
                tri_edge_test(fc->fac[0], fc->fac[1], fc->fac[2], pe, pd, NULL, 1, types, poss);
            if (intflag == 2) {
                // They intersect at a single point.
                dir = (enum interresult)types[0];
                if (dir == ACROSSFACE) {
                    rejflag = 1;
                } else if (dir == ACROSSEDGE) {
                    rejflag = 1;
                }
            } else if (intflag == 4) {
                // The edge [e,d] is coplanar with the face.
                // There may be two intersections.
                for (i = 0; i < 2 && !rejflag; i++) {
                    dir = (enum interresult)types[i];
                    if (dir == ACROSSFACE) {
                        rejflag = 1;
                    } else if (dir == ACROSSEDGE) {
                        rejflag = 1;
                    }
                }
            }
        } // if (fliptype == 1)
    }     // if (fc->fac[0] != NULL)

    if ((fc->remvert != NULL) && !rejflag) {
        // The vertex is going to be removed. Do not create a new edge which
        //   contains this vertex.
        if (fliptype == 1) {
            // A 2-to-3 flip.
            if ((pd == fc->remvert) || (pe == fc->remvert)) {
                rejflag = 1;
            }
        }
    }

    if (fc->remove_large_angle && !rejflag) {
        // Remove a large dihedral angle. Do not create a new small angle.
        REAL cosmaxd = 0, diff;
        if (fliptype == 1) {
            // We assume that neither 'a' nor 'b' is dummypoint.
            // A 2-to-3 flip: [a,b,c] => [e,d,a], [e,d,b], [e,d,c].
            // The new tet [e,d,a,b] will be flipped later. Only two new tets:
            //   [e,d,b,c] and [e,d,c,a] need to be checked.
            if ((pc != dummypoint) && (pe != dummypoint) && (pd != dummypoint)) {
                // Get the largest dihedral angle of [e,d,b,c].
                tetalldihedral(pe, pd, pb, pc, NULL, &cosmaxd, NULL);
                diff = cosmaxd - fc->cosdihed_in;
                if (fabs(diff / fc->cosdihed_in) < b->epsilon) diff = 0.0; // Rounding.
                if (diff <= 0) { // if (cosmaxd <= fc->cosdihed_in) {
                    rejflag = 1;
                } else {
                    // Record the largest new angle.
                    if (cosmaxd < fc->cosdihed_out) {
                        fc->cosdihed_out = cosmaxd;
                    }
                    // Get the largest dihedral angle of [e,d,c,a].
                    tetalldihedral(pe, pd, pc, pa, NULL, &cosmaxd, NULL);
                    diff = cosmaxd - fc->cosdihed_in;
                    if (fabs(diff / fc->cosdihed_in) < b->epsilon) diff = 0.0; // Rounding.
                    if (diff <= 0) { // if (cosmaxd <= fc->cosdihed_in) {
                        rejflag = 1;
                    } else {
                        // Record the largest new angle.
                        if (cosmaxd < fc->cosdihed_out) {
                            fc->cosdihed_out = cosmaxd;
                        }
                    }
                }
            } // if (pc != dummypoint && ...)
        } else if (fliptype == 2) {
            // A 3-to-2 flip: [e,d,a], [e,d,b], [e,d,c] => [a,b,c]
            // We assume that neither 'e' nor 'd' is dummypoint.
            if (level == 0) {
                // Both new tets [a,b,c,d] and [b,a,c,e] are new tets.
                if ((pa != dummypoint) && (pb != dummypoint) && (pc != dummypoint)) {
                    // Get the largest dihedral angle of [a,b,c,d].
                    tetalldihedral(pa, pb, pc, pd, NULL, &cosmaxd, NULL);
                    diff = cosmaxd - fc->cosdihed_in;
                    if (fabs(diff / fc->cosdihed_in) < b->epsilon) diff = 0.0; // Rounding
                    if (diff <= 0) { // if (cosmaxd <= fc->cosdihed_in) {
                        rejflag = 1;
                    } else {
                        // Record the largest new angle.
                        if (cosmaxd < fc->cosdihed_out) {
                            fc->cosdihed_out = cosmaxd;
                        }
                        // Get the largest dihedral angle of [b,a,c,e].
                        tetalldihedral(pb, pa, pc, pe, NULL, &cosmaxd, NULL);
                        diff = cosmaxd - fc->cosdihed_in;
                        if (fabs(diff / fc->cosdihed_in) < b->epsilon) diff = 0.0; // Rounding
                        if (diff <= 0) { // if (cosmaxd <= fc->cosdihed_in) {
                            rejflag = 1;
                        } else {
                            // Record the largest new angle.
                            if (cosmaxd < fc->cosdihed_out) {
                                fc->cosdihed_out = cosmaxd;
                            }
                        }
                    }
                }
            } else { // level > 0
                if (edgepivot == 1) {
                    // The new tet [a,b,c,d] will be flipped. Only check [b,a,c,e].
                    if ((pa != dummypoint) && (pb != dummypoint) && (pc != dummypoint)) {
                        // Get the largest dihedral angle of [b,a,c,e].
                        tetalldihedral(pb, pa, pc, pe, NULL, &cosmaxd, NULL);
                        diff = cosmaxd - fc->cosdihed_in;
                        if (fabs(diff / fc->cosdihed_in) < b->epsilon) diff = 0.0; // Rounding
                        if (diff <= 0) { // if (cosmaxd <= fc->cosdihed_in) {
                            rejflag = 1;
                        } else {
                            // Record the largest new angle.
                            if (cosmaxd < fc->cosdihed_out) {
                                fc->cosdihed_out = cosmaxd;
                            }
                        }
                    }
                } else {
                    // The new tet [b,a,c,e] will be flipped. Only check [a,b,c,d].
                    if ((pa != dummypoint) && (pb != dummypoint) && (pc != dummypoint)) {
                        // Get the largest dihedral angle of [b,a,c,e].
                        tetalldihedral(pa, pb, pc, pd, NULL, &cosmaxd, NULL);
                        diff = cosmaxd - fc->cosdihed_in;
                        if (fabs(diff / fc->cosdihed_in) < b->epsilon) diff = 0.0; // Rounding
                        if (diff <= 0) { // if (cosmaxd <= fc->cosdihed_in) {
                            rejflag = 1;
                        } else {
                            // Record the largest new angle.
                            if (cosmaxd < fc->cosdihed_out) {
                                fc->cosdihed_out = cosmaxd;
                            }
                        }
                    }
                } // edgepivot
            }     // level
        }
    }

    return rejflag;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// removeedgebyflips()    Attempt to remove an edge by flips.                //
//                                                                           //
// 'flipedge' is a non-convex or flat edge [a,b,#,#] to be removed.          //
//                                                                           //
// The return value is a positive integer, it indicates whether the edge is  //
// removed or not.  A value "2" means the edge is removed, otherwise, the    //
// edge is not removed and the value (must >= 3) is the current number of    //
// tets in the edge star.                                                    //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::removeedgebyflips(triface* flipedge, flipconstraints* fc) {
    triface *abtets, spintet;
    int t1ver;
    int n, nn, i;

    if (checksubsegflag) {
        // Do not flip a segment.
        if (issubseg(*flipedge)) {
            if (fc->collectencsegflag) {
                face checkseg, *paryseg;
                tsspivot1(*flipedge, checkseg);
                if (!sinfected(checkseg)) {
                    // Queue this segment in list.
                    sinfect(checkseg);
                    caveencseglist->newindex((void**)&paryseg);
                    *paryseg = checkseg;
                }
            }
            return 0;
        }
    }

    // Count the number of tets at edge [a,b].
    n = 0;
    spintet = *flipedge;
    while (1) {
        n++;
        fnextself(spintet);
        if (spintet.tet == flipedge->tet) break;
    }
    if (n < 3) {
        // It is only possible when the mesh contains inverted tetrahedra.
        terminatetetgen(this, 2); // Report a bug
    }

    if ((b->flipstarsize > 0) && (n > b->flipstarsize)) {
        // The star size exceeds the limit.
        return 0; // Do not flip it.
    }

    // Allocate spaces.
    abtets = new triface[n];
    // Collect the tets at edge [a,b].
    spintet = *flipedge;
    i = 0;
    while (1) {
        abtets[i] = spintet;
        setelemcounter(abtets[i], 1);
        i++;
        fnextself(spintet);
        if (spintet.tet == flipedge->tet) break;
    }

    // Try to flip the edge (level = 0, edgepivot = 0).
    nn = flipnm(abtets, n, 0, 0, fc);

    if (nn > 2) {
        // Edge is not flipped. Unmarktest the remaining tets in Star(ab).
        for (i = 0; i < nn; i++) {
            setelemcounter(abtets[i], 0);
        }
        // Restore the input edge (needed by Lawson's flip).
        *flipedge = abtets[0];
    }

    // Release the temporary allocated spaces.
    // NOTE: fc->unflip must be 0.
    int bakunflip = fc->unflip;
    fc->unflip = 0;
    flipnm_post(abtets, n, nn, 0, fc);
    fc->unflip = bakunflip;

    delete[] abtets;

    return nn;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// removefacebyflips()    Remove a face by flips.                            //
//                                                                           //
// Return 1 if the face is removed. Otherwise, return 0.                     //
//                                                                           //
// ASSUMPTIONS:                                                              //
//   - 'flipface' must not be a subface.                                     //
//   - 'flipface' must not be a hull face.                                   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::removefacebyflips(triface* flipface, flipconstraints* fc) {
    triface fliptets[3], flipedge;
    point pa, pb, pc, pd, pe;
    REAL ori;
    int reducflag = 0;

    fliptets[0] = *flipface;
    fsym(*flipface, fliptets[1]);
    pa = org(fliptets[0]);
    pb = dest(fliptets[0]);
    pc = apex(fliptets[0]);
    pd = oppo(fliptets[0]);
    pe = oppo(fliptets[1]);

    ori = orient3d(pa, pb, pd, pe);
    if (ori > 0) {
        ori = orient3d(pb, pc, pd, pe);
        if (ori > 0) {
            ori = orient3d(pc, pa, pd, pe);
            if (ori > 0) {
                // Found a 2-to-3 flip.
                reducflag = 1;
            } else {
                eprev(*flipface, flipedge); // [c,a]
            }
        } else {
            enext(*flipface, flipedge); // [b,c]
        }
    } else {
        flipedge = *flipface; // [a,b]
    }

    if (reducflag) {
        // A 2-to-3 flip is found.
        flip23(fliptets, 0, fc);
        return 1;
    } else {
        // Try to flip the selected edge of this face.
        if (removeedgebyflips(&flipedge, fc) == 2) {
            return 1;
        }
    }

    // Face is not removed.
    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// recoveredge()    Recover an edge in current tetrahedralization.           //
//                                                                           //
// If the edge is recovered, 'searchtet' returns a tet containing the edge.  //
//                                                                           //
// This edge may intersect a set of faces and edges in the mesh.  All these  //
// faces or edges are needed to be removed.                                  //
//                                                                           //
// If the parameter 'fullsearch' is set, it tries to flip any face or edge   //
// that intersects the recovering edge.  Otherwise, only the face or edge    //
// which is visible by 'startpt' is tried.                                   //
//                                                                           //
// The parameter 'sedge' is used to report self-intersection. If it is not   //
// a NULL, it is EITHER a segment OR a subface that contains this edge.      //
//                                                                           //
// Note that this routine assumes that the tetrahedralization is convex.     //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::recoveredgebyflips(point startpt, point endpt, face* sedge, triface* searchtet,
                                   int fullsearch) {
    flipconstraints fc;
    enum interresult dir;

    fc.seg[0] = startpt;
    fc.seg[1] = endpt;
    fc.checkflipeligibility = 1;

    // The mainloop of the edge reocvery.
    while (1) { // Loop I

        // Search the edge from 'startpt'.
        point2tetorg(startpt, *searchtet);
        dir = finddirection(searchtet, endpt);
        if (dir == ACROSSVERT) {
            if (dest(*searchtet) == endpt) {
                return 1; // Edge is recovered.
            } else {
                if (sedge) {
                    return report_selfint_edge(startpt, endpt, sedge, searchtet, dir);
                } else {
                    return 0;
                }
            }
        }

        // The edge is missing.

        // Try to remove the first intersecting face/edge.
        enextesymself(*searchtet); // Go to the opposite face.
        if (dir == ACROSSFACE) {
            if (checksubfaceflag) {
                if (issubface(*searchtet)) {
                    if (sedge) {
                        return report_selfint_edge(startpt, endpt, sedge, searchtet, dir);
                    } else {
                        return 0; // Cannot flip a subface.
                    }
                }
            }
            // Try to flip a crossing face.
            if (removefacebyflips(searchtet, &fc)) {
                continue;
            }
        } else if (dir == ACROSSEDGE) {
            if (checksubsegflag) {
                if (issubseg(*searchtet)) {
                    if (sedge) {
                        return report_selfint_edge(startpt, endpt, sedge, searchtet, dir);
                    } else {
                        return 0; // Cannot flip a segment.
                    }
                }
            }
            // Try to flip an intersecting edge.
            if (removeedgebyflips(searchtet, &fc) == 2) {
                continue;
            }
        }

        // The edge is missing.

        if (fullsearch) {
            // Try to flip one of the faces/edges which intersects the edge.
            triface neightet, spintet;
            point pa, pb, pc, pd;
            badface bakface;
            enum interresult dir1;
            int types[2], poss[4], pos = 0;
            int success = 0;
            int t1ver;
            int i, j;

            // Loop through the sequence of intersecting faces/edges from
            //   'startpt' to 'endpt'.
            point2tetorg(startpt, *searchtet);
            dir = finddirection(searchtet, endpt);

            // Go to the face/edge intersecting the searching edge.
            enextesymself(*searchtet); // Go to the opposite face.
            // This face/edge has been tried in previous step.

            while (1) { // Loop I-I

                // Find the next intersecting face/edge.
                fsymself(*searchtet);
                if (dir == ACROSSFACE) {
                    neightet = *searchtet;
                    j = (neightet.ver & 3); // j is the current face number.
                    for (i = j + 1; i < j + 4; i++) {
                        neightet.ver = (i % 4);
                        pa = org(neightet);
                        pb = dest(neightet);
                        pc = apex(neightet);
                        pd = oppo(neightet); // The above point.
                        if (tri_edge_test(pa, pb, pc, startpt, endpt, pd, 1, types, poss)) {
                            dir = (enum interresult)types[0];
                            pos = poss[0];
                            break;
                        } else {
                            dir = DISJOINT;
                            pos = 0;
                        }
                    } // i
                    // There must be an intersection face/edge.
                    if (dir == DISJOINT) {
                        terminatetetgen(this, 2);
                    }
                } else if (dir == ACROSSEDGE) {
                    while (1) { // Loop I-I-I
                        // Check the two opposite faces (of the edge) in 'searchtet'.
                        for (i = 0; i < 2; i++) {
                            if (i == 0) {
                                enextesym(*searchtet, neightet);
                            } else {
                                eprevesym(*searchtet, neightet);
                            }
                            pa = org(neightet);
                            pb = dest(neightet);
                            pc = apex(neightet);
                            pd = oppo(neightet); // The above point.
                            if (tri_edge_test(pa, pb, pc, startpt, endpt, pd, 1, types, poss)) {
                                dir = (enum interresult)types[0];
                                pos = poss[0];
                                break; // for loop
                            } else {
                                dir = DISJOINT;
                                pos = 0;
                            }
                        } // i
                        if (dir != DISJOINT) {
                            // Find an intersection face/edge.
                            break; // Loop I-I-I
                        }
                        // No intersection. Rotate to the next tet at the edge.
                        fnextself(*searchtet);
                    } // while (1) // Loop I-I-I
                } else {
                    terminatetetgen(this, 2); // Report a bug
                }

                // Adjust to the intersecting edge/vertex.
                for (i = 0; i < pos; i++) {
                    enextself(neightet);
                }

                if (dir == SHAREVERT) {
                    // Check if we have reached the 'endpt'.
                    pd = org(neightet);
                    if (pd == endpt) {
                        // Failed to recover the edge.
                        break; // Loop I-I
                    } else {
                        terminatetetgen(this, 2); // Report a bug
                    }
                }

                // The next to be flipped face/edge.
                *searchtet = neightet;

                // Bakup this face (tetrahedron).
                bakface.forg = org(*searchtet);
                bakface.fdest = dest(*searchtet);
                bakface.fapex = apex(*searchtet);
                bakface.foppo = oppo(*searchtet);

                // Try to flip this intersecting face/edge.
                if (dir == ACROSSFACE) {
                    if (checksubfaceflag) {
                        if (issubface(*searchtet)) {
                            if (sedge) {
                                return report_selfint_edge(startpt, endpt, sedge, searchtet, dir);
                            } else {
                                return 0; // Cannot flip a subface.
                            }
                        }
                    }
                    if (removefacebyflips(searchtet, &fc)) {
                        success = 1;
                        break; // Loop I-I
                    }
                } else if (dir == ACROSSEDGE) {
                    if (checksubsegflag) {
                        if (issubseg(*searchtet)) {
                            if (sedge) {
                                return report_selfint_edge(startpt, endpt, sedge, searchtet, dir);
                            } else {
                                return 0; // Cannot flip a segment.
                            }
                        }
                    }
                    if (removeedgebyflips(searchtet, &fc) == 2) {
                        success = 1;
                        break; // Loop I-I
                    }
                } else if (dir == ACROSSVERT) {
                    if (sedge) {
                        // return report_selfint_edge(startpt, endpt, sedge, searchtet, dir);
                        terminatetetgen(this, 2);
                    } else {
                        return 0;
                    }
                } else {
                    terminatetetgen(this, 2);
                }

                // The face/edge is not flipped.
                if ((searchtet->tet == NULL) || (org(*searchtet) != bakface.forg) ||
                    (dest(*searchtet) != bakface.fdest) || (apex(*searchtet) != bakface.fapex) ||
                    (oppo(*searchtet) != bakface.foppo)) {
                    // 'searchtet' was flipped. We must restore it.
                    point2tetorg(bakface.forg, *searchtet);
                    dir1 = finddirection(searchtet, bakface.fdest);
                    if (dir1 == ACROSSVERT) {
                        if (dest(*searchtet) == bakface.fdest) {
                            spintet = *searchtet;
                            while (1) {
                                if (apex(spintet) == bakface.fapex) {
                                    // Found the face.
                                    *searchtet = spintet;
                                    break;
                                }
                                fnextself(spintet);
                                if (spintet.tet == searchtet->tet) {
                                    searchtet->tet = NULL;
                                    break; // Not find.
                                }
                            } // while (1)
                            if (searchtet->tet != NULL) {
                                if (oppo(*searchtet) != bakface.foppo) {
                                    fsymself(*searchtet);
                                    if (oppo(*searchtet) != bakface.foppo) {
                                        // The original (intersecting) tet has been flipped.
                                        searchtet->tet = NULL;
                                        break; // Not find.
                                    }
                                }
                            }
                        } else {
                            searchtet->tet = NULL; // Not find.
                        }
                    } else {
                        searchtet->tet = NULL; // Not find.
                    }
                    if (searchtet->tet == NULL) {
                        success = 0; // This face/edge has been destroyed.
                        break;       // Loop I-I
                    }
                }
            } // while (1) // Loop I-I

            if (success) {
                // One of intersecting faces/edges is flipped.
                continue;
            }

        } // if (fullsearch)

        // The edge is missing.
        break; // Loop I

    } // while (1) // Loop I

    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// add_steinerpt_in_schoenhardtpoly()    Insert a Steiner point in a Schoen- //
//                                       hardt polyhedron.                   //
//                                                                           //
// 'abtets' is an array of n tets which all share at the edge [a,b]. Let the //
// tets are [a,b,p0,p1], [a,b,p1,p2], ..., [a,b,p_(n-2),p_(n-1)].  Moreover, //
// the edge [p0,p_(n-1)] intersects all of the tets in 'abtets'.  A special  //
// case is that the edge [p0,p_(n-1)] is coplanar with the edge [a,b].       //
// Such set of tets arises when we want to recover an edge from 'p0' to 'p_  //
// (n-1)', and the number of tets at [a,b] can not be reduced by any flip.   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::add_steinerpt_in_schoenhardtpoly(triface* abtets, int n, int chkencflag) {
    triface worktet, *parytet;
    triface faketet1, faketet2;
    point pc, pd, steinerpt;
    insertvertexflags ivf;
    optparameters opm;
    REAL vcd[3], sampt[3], smtpt[3];
    REAL maxminvol = 0.0, minvol = 0.0, ori;
    int success, maxidx = 0;
    int it, i;

    pc = apex(abtets[0]);     // pc = p0
    pd = oppo(abtets[n - 1]); // pd = p_(n-1)

    // Find an optimial point in edge [c,d]. It is visible by all outer faces
    //   of 'abtets', and it maxmizes the min volume.

    // initialize the list of 2n boundary faces.
    for (i = 0; i < n; i++) {
        edestoppo(abtets[i], worktet); // [p_i,p_i+1,a]
        cavetetlist->newindex((void**)&parytet);
        *parytet = worktet;
        eorgoppo(abtets[i], worktet); // [p_i+1,p_i,b]
        cavetetlist->newindex((void**)&parytet);
        *parytet = worktet;
    }

    int N = 100;
    REAL stepi = 0.01;

    // Search the point along the edge [c,d].
    for (i = 0; i < 3; i++)
        vcd[i] = pd[i] - pc[i];

    // Sample N points in edge [c,d].
    for (it = 1; it < N; it++) {
        for (i = 0; i < 3; i++) {
            sampt[i] = pc[i] + (stepi * (double)it) * vcd[i];
        }
        for (i = 0; i < cavetetlist->objects; i++) {
            parytet = (triface*)fastlookup(cavetetlist, i);
            ori = orient3d(dest(*parytet), org(*parytet), apex(*parytet), sampt);
            if (i == 0) {
                minvol = ori;
            } else {
                if (minvol > ori) minvol = ori;
            }
        } // i
        if (it == 1) {
            maxminvol = minvol;
            maxidx = it;
        } else {
            if (maxminvol < minvol) {
                maxminvol = minvol;
                maxidx = it;
            }
        }
    } // it

    if (maxminvol <= 0) {
        cavetetlist->restart();
        return 0;
    }

    for (i = 0; i < 3; i++) {
        smtpt[i] = pc[i] + (stepi * (double)maxidx) * vcd[i];
    }

    // Create two faked tets to hold the two non-existing boundary faces:
    //   [d,c,a] and [c,d,b].
    maketetrahedron(&faketet1);
    setvertices(faketet1, pd, pc, org(abtets[0]), dummypoint);
    cavetetlist->newindex((void**)&parytet);
    *parytet = faketet1;
    maketetrahedron(&faketet2);
    setvertices(faketet2, pc, pd, dest(abtets[0]), dummypoint);
    cavetetlist->newindex((void**)&parytet);
    *parytet = faketet2;

    // Point smooth options.
    opm.max_min_volume = 1;
    opm.numofsearchdirs = 20;
    opm.searchstep = 0.001;
    opm.maxiter = 100; // Limit the maximum iterations.
    opm.initval = 0.0; // Initial volume is zero.

    // Try to relocate the point into the inside of the polyhedron.
    success = smoothpoint(smtpt, cavetetlist, 1, &opm);

    if (success) {
        while (opm.smthiter == 100) {
            // It was relocated and the prescribed maximum iteration reached.
            // Try to increase the search stepsize.
            opm.searchstep *= 10.0;
            // opm.maxiter = 100; // Limit the maximum iterations.
            opm.initval = opm.imprval;
            opm.smthiter = 0; // Init.
            smoothpoint(smtpt, cavetetlist, 1, &opm);
        }
    } // if (success)

    // Delete the two faked tets.
    tetrahedrondealloc(faketet1.tet);
    tetrahedrondealloc(faketet2.tet);

    cavetetlist->restart();

    if (!success) {
        return 0;
    }

    // Insert the Steiner point.
    makepoint(&steinerpt, FREEVOLVERTEX);
    for (i = 0; i < 3; i++)
        steinerpt[i] = smtpt[i];

    // Insert the created Steiner point.
    for (i = 0; i < n; i++) {
        infect(abtets[i]);
        caveoldtetlist->newindex((void**)&parytet);
        *parytet = abtets[i];
    }
    worktet = abtets[0]; // No need point location.
    ivf.iloc = (int)INSTAR;
    ivf.chkencflag = chkencflag;
    ivf.assignmeshsize = b->metric;
    if (ivf.assignmeshsize) {
        // Search the tet containing 'steinerpt' for size interpolation.
        locate(steinerpt, &(abtets[0]));
        worktet = abtets[0];
    }

    // Insert the new point into the tetrahedralization T.
    // Note that T is convex (nonconvex = 0).
    if (insertpoint(steinerpt, &worktet, NULL, NULL, &ivf)) {
        // The vertex has been inserted.
        st_volref_count++;
        if (steinerleft > 0) steinerleft--;
        return 1;
    } else {
        // Not inserted.
        pointdealloc(steinerpt);
        return 0;
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// add_steinerpt_in_segment()    Add a Steiner point inside a segment.       //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::add_steinerpt_in_segment(face* misseg, int searchlevel) {
    triface searchtet;
    face *paryseg, candseg;
    point startpt, endpt, pc, pd;
    flipconstraints fc;
    enum interresult dir;
    REAL P[3], Q[3], tp, tq;
    REAL len, smlen = 0, split = 0, split_q = 0;
    int success;
    int i;

    startpt = sorg(*misseg);
    endpt = sdest(*misseg);

    fc.seg[0] = startpt;
    fc.seg[1] = endpt;
    fc.checkflipeligibility = 1;
    fc.collectencsegflag = 1;

    point2tetorg(startpt, searchtet);
    dir = finddirection(&searchtet, endpt);
    // Try to flip the first intersecting face/edge.
    enextesymself(searchtet); // Go to the opposite face.

    int bak_fliplinklevel = b->fliplinklevel;
    b->fliplinklevel = searchlevel;

    if (dir == ACROSSFACE) {
        // A face is intersected with the segment. Try to flip it.
        success = removefacebyflips(&searchtet, &fc);
    } else if (dir == ACROSSEDGE) {
        // An edge is intersected with the segment. Try to flip it.
        success = removeedgebyflips(&searchtet, &fc);
    }

    split = 0;
    for (i = 0; i < caveencseglist->objects; i++) {
        paryseg = (face*)fastlookup(caveencseglist, i);
        suninfect(*paryseg);
        // Calculate the shortest edge between the two lines.
        pc = sorg(*paryseg);
        pd = sdest(*paryseg);
        tp = tq = 0;
        if (linelineint(startpt, endpt, pc, pd, P, Q, &tp, &tq)) {
            // Does the shortest edge lie between the two segments?
            // Round tp and tq.
            if ((tp > 0) && (tq < 1)) {
                if (tp < 0.5) {
                    if (tp < (b->epsilon * 1e+3)) tp = 0.0;
                } else {
                    if ((1.0 - tp) < (b->epsilon * 1e+3)) tp = 1.0;
                }
            }
            if ((tp <= 0) || (tp >= 1)) continue;
            if ((tq > 0) && (tq < 1)) {
                if (tq < 0.5) {
                    if (tq < (b->epsilon * 1e+3)) tq = 0.0;
                } else {
                    if ((1.0 - tq) < (b->epsilon * 1e+3)) tq = 1.0;
                }
            }
            if ((tq <= 0) || (tq >= 1)) continue;
            // It is a valid shortest edge. Calculate its length.
            len = distance(P, Q);
            if (split == 0) {
                smlen = len;
                split = tp;
                split_q = tq;
                candseg = *paryseg;
            } else {
                if (len < smlen) {
                    smlen = len;
                    split = tp;
                    split_q = tq;
                    candseg = *paryseg;
                }
            }
        }
    }

    caveencseglist->restart();
    b->fliplinklevel = bak_fliplinklevel;

    if (split == 0) {
        // Found no crossing segment.
        return 0;
    }

    face splitsh;
    face splitseg;
    point steinerpt, *parypt;
    insertvertexflags ivf;

    if (b->addsteiner_algo == 1) {
        // Split the segment at the closest point to a near segment.
        makepoint(&steinerpt, FREESEGVERTEX);
        for (i = 0; i < 3; i++) {
            steinerpt[i] = startpt[i] + split * (endpt[i] - startpt[i]);
        }
    } else { // b->addsteiner_algo == 2
        for (i = 0; i < 3; i++) {
            P[i] = startpt[i] + split * (endpt[i] - startpt[i]);
        }
        pc = sorg(candseg);
        pd = sdest(candseg);
        for (i = 0; i < 3; i++) {
            Q[i] = pc[i] + split_q * (pd[i] - pc[i]);
        }
        makepoint(&steinerpt, FREEVOLVERTEX);
        for (i = 0; i < 3; i++) {
            steinerpt[i] = 0.5 * (P[i] + Q[i]);
        }
    }

    // We need to locate the point. Start searching from 'searchtet'.
    if (split < 0.5) {
        point2tetorg(startpt, searchtet);
    } else {
        point2tetorg(endpt, searchtet);
    }
    if (b->addsteiner_algo == 1) {
        splitseg = *misseg;
        spivot(*misseg, splitsh);
    } else {
        splitsh.sh = NULL;
        splitseg.sh = NULL;
    }
    ivf.iloc = (int)OUTSIDE;
    ivf.bowywat = 1;
    ivf.lawson = 0;
    ivf.rejflag = 0;
    ivf.chkencflag = 0;
    ivf.sloc = (int)ONEDGE;
    ivf.sbowywat = 1;
    ivf.splitbdflag = 0;
    ivf.validflag = 1;
    ivf.respectbdflag = 1;
    ivf.assignmeshsize = b->metric;

    if (!insertpoint(steinerpt, &searchtet, &splitsh, &splitseg, &ivf)) {
        pointdealloc(steinerpt);
        return 0;
    }

    if (b->addsteiner_algo == 1) {
        // Save this Steiner point (for removal).
        //   Re-use the array 'subvertstack'.
        subvertstack->newindex((void**)&parypt);
        *parypt = steinerpt;
        st_segref_count++;
    } else { // b->addsteiner_algo == 2
        // Queue the segment for recovery.
        subsegstack->newindex((void**)&paryseg);
        *paryseg = *misseg;
        st_volref_count++;
    }
    if (steinerleft > 0) steinerleft--;

    return 1;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// addsteiner4recoversegment()    Add a Steiner point for recovering a seg.  //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::addsteiner4recoversegment(face* misseg, int splitsegflag) {
    triface *abtets, searchtet, spintet;
    face splitsh;
    face* paryseg;
    point startpt, endpt;
    point pa, pb, pd, steinerpt, *parypt;
    enum interresult dir;
    insertvertexflags ivf;
    int types[2], poss[4];
    int n, endi, success;
    int t1ver;
    int i;

    startpt = sorg(*misseg);
    if (pointtype(startpt) == FREESEGVERTEX) {
        sesymself(*misseg);
        startpt = sorg(*misseg);
    }
    endpt = sdest(*misseg);

    // Try to recover the edge by adding Steiner points.
    point2tetorg(startpt, searchtet);
    dir = finddirection(&searchtet, endpt);
    enextself(searchtet);

    if (dir == ACROSSFACE) {
        // The segment is crossing at least 3 faces. Find the common edge of
        //   the first 3 crossing faces.
        esymself(searchtet);
        fsym(searchtet, spintet);
        pd = oppo(spintet);
        for (i = 0; i < 3; i++) {
            pa = org(spintet);
            pb = dest(spintet);
            if (tri_edge_test(pa, pb, pd, startpt, endpt, NULL, 1, types, poss)) {
                break; // Found the edge.
            }
            enextself(spintet);
            eprevself(searchtet);
        }
        esymself(searchtet);
    }

    spintet = searchtet;
    n = 0;
    endi = -1;
    while (1) {
        // Check if the endpt appears in the star.
        if (apex(spintet) == endpt) {
            endi = n; // Remember the position of endpt.
        }
        n++; // Count a tet in the star.
        fnextself(spintet);
        if (spintet.tet == searchtet.tet) break;
    }

    if (endi > 0) {
        // endpt is also in the edge star
        // Get all tets in the edge star.
        abtets = new triface[n];
        spintet = searchtet;
        for (i = 0; i < n; i++) {
            abtets[i] = spintet;
            fnextself(spintet);
        }

        success = 0;

        if (dir == ACROSSFACE) {
            // Find a Steiner points inside the polyhedron.
            if (add_steinerpt_in_schoenhardtpoly(abtets, endi, 0)) {
                success = 1;
            }
        } else if (dir == ACROSSEDGE) {
            // PLC check.
            if (issubseg(searchtet)) {
                terminatetetgen(this, 2);
            }
            if (n > 4) {
                // In this case, 'abtets' is separated by the plane (containing the
                //   two intersecting edges) into two parts, P1 and P2, where P1
                //   consists of 'endi' tets: abtets[0], abtets[1], ...,
                //   abtets[endi-1], and P2 consists of 'n - endi' tets:
                //   abtets[endi], abtets[endi+1], abtets[n-1].
                if (endi > 2) { // P1
                    // There are at least 3 tets in the first part.
                    if (add_steinerpt_in_schoenhardtpoly(abtets, endi, 0)) {
                        success++;
                    }
                }
                if ((n - endi) > 2) { // P2
                    // There are at least 3 tets in the first part.
                    if (add_steinerpt_in_schoenhardtpoly(&(abtets[endi]), n - endi, 0)) {
                        success++;
                    }
                }
            } else {
                // In this case, a 4-to-4 flip should be re-cover the edge [c,d].
                //   However, there will be invalid tets (either zero or negtive
                //   volume). Otherwise, [c,d] should already be recovered by the
                //   recoveredge() function.
                terminatetetgen(this, 2);
            }
        } else {
            terminatetetgen(this, 2);
        }

        delete[] abtets;

        if (success) {
            // Add the missing segment back to the recovering list.
            subsegstack->newindex((void**)&paryseg);
            *paryseg = *misseg;
            return 1;
        }
    } // if (endi > 0)

    if (!splitsegflag) {
        return 0;
    }

    if (b->verbose > 2) {
        printf("      Splitting segment (%d, %d)\n", pointmark(startpt), pointmark(endpt));
    }
    steinerpt = NULL;

    if (b->addsteiner_algo > 0) { // -Y/1 or -Y/2
        if (add_steinerpt_in_segment(misseg, 3)) {
            return 1;
        }
        sesymself(*misseg);
        if (add_steinerpt_in_segment(misseg, 3)) {
            return 1;
        }
        sesymself(*misseg);
    }

    if (steinerpt == NULL) {
        // Split the segment at its midpoint.
        makepoint(&steinerpt, FREESEGVERTEX);
        for (i = 0; i < 3; i++) {
            steinerpt[i] = 0.5 * (startpt[i] + endpt[i]);
        }

        // We need to locate the point.
        spivot(*misseg, splitsh);
        ivf.iloc = (int)OUTSIDE;
        ivf.bowywat = 1;
        ivf.lawson = 0;
        ivf.rejflag = 0;
        ivf.chkencflag = 0;
        ivf.sloc = (int)ONEDGE;
        ivf.sbowywat = 1;
        ivf.splitbdflag = 0;
        ivf.validflag = 1;
        ivf.respectbdflag = 1;
        ivf.assignmeshsize = b->metric;
        if (!insertpoint(steinerpt, &searchtet, &splitsh, misseg, &ivf)) {
            terminatetetgen(this, 2);
        }
    } // if (endi > 0)

    // Save this Steiner point (for removal).
    //   Re-use the array 'subvertstack'.
    subvertstack->newindex((void**)&parypt);
    *parypt = steinerpt;

    st_segref_count++;
    if (steinerleft > 0) steinerleft--;

    return 1;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// recoversegments()    Recover all segments.                                //
//                                                                           //
// All segments need to be recovered are in 'subsegstack'.                   //
//                                                                           //
// This routine first tries to recover each segment by only using flips. If  //
// no flip is possible, and the flag 'steinerflag' is set, it then tries to  //
// insert Steiner points near or in the segment.                             //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::recoversegments(arraypool* misseglist, int fullsearch, int steinerflag) {
    triface searchtet, spintet;
    face sseg, *paryseg;
    point startpt, endpt;
    int success;
    int t1ver;

    long bak_inpoly_count = st_volref_count;
    long bak_segref_count = st_segref_count;

    if (b->verbose > 1) {
        printf("    Recover segments [%s level = %2d] #:  %ld.\n",
               (b->fliplinklevel > 0) ? "fixed" : "auto",
               (b->fliplinklevel > 0) ? b->fliplinklevel : autofliplinklevel, subsegstack->objects);
    }

    // Loop until 'subsegstack' is empty.
    while (subsegstack->objects > 0l) {
        // seglist is used as a stack.
        subsegstack->objects--;
        paryseg = (face*)fastlookup(subsegstack, subsegstack->objects);
        sseg = *paryseg;

        // Check if this segment has been recovered.
        sstpivot1(sseg, searchtet);
        if (searchtet.tet != NULL) {
            continue; // Not a missing segment.
        }

        startpt = sorg(sseg);
        endpt = sdest(sseg);

        if (b->verbose > 2) {
            printf("      Recover segment (%d, %d).\n", pointmark(startpt), pointmark(endpt));
        }

        success = 0;

        if (recoveredgebyflips(startpt, endpt, &sseg, &searchtet, 0)) {
            success = 1;
        } else {
            // Try to recover it from the other direction.
            if (recoveredgebyflips(endpt, startpt, &sseg, &searchtet, 0)) {
                success = 1;
            }
        }

        if (!success && fullsearch) {
            if (recoveredgebyflips(startpt, endpt, &sseg, &searchtet, fullsearch)) {
                success = 1;
            }
        }

        if (success) {
            // Segment is recovered. Insert it.
            // Let the segment remember an adjacent tet.
            sstbond1(sseg, searchtet);
            // Bond the segment to all tets containing it.
            spintet = searchtet;
            do {
                tssbond1(spintet, sseg);
                fnextself(spintet);
            } while (spintet.tet != searchtet.tet);
        } else {
            if (steinerflag > 0) {
                // Try to recover the segment but do not split it.
                if (addsteiner4recoversegment(&sseg, 0)) {
                    success = 1;
                }
                if (!success && (steinerflag > 1)) {
                    // Split the segment.
                    addsteiner4recoversegment(&sseg, 1);
                    success = 1;
                }
            }
            if (!success) {
                if (misseglist != NULL) {
                    // Save this segment.
                    misseglist->newindex((void**)&paryseg);
                    *paryseg = sseg;
                }
            }
        }

    } // while (subsegstack->objects > 0l)

    if (steinerflag) {
        if (b->verbose > 1) {
            // Report the number of added Steiner points.
            if (st_volref_count > bak_inpoly_count) {
                printf("    Add %ld Steiner points in volume.\n",
                       st_volref_count - bak_inpoly_count);
            }
            if (st_segref_count > bak_segref_count) {
                printf("    Add %ld Steiner points in segments.\n",
                       st_segref_count - bak_segref_count);
            }
        }
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// recoverfacebyflips()    Recover a face by flips.                          //
//                                                                           //
// 'pa', 'pb', and 'pc' are the three vertices of this face.  This routine   //
// tries to recover it in the tetrahedral mesh. It is assumed that the three //
// edges, i.e., pa->pb, pb->pc, and pc->pa all exist.                        //
//                                                                           //
// If the face is recovered, it is returned by 'searchtet'.                  //
//                                                                           //
// If 'searchsh' is not NULL, it is a subface to be recovered.  Its vertices //
// must be pa, pb, and pc.  It is mainly used to check self-intersections.   //
// Another use of this subface is to split it when a Steiner point is found  //
// inside this subface.                                                      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::recoverfacebyflips(point pa, point pb, point pc, face* searchsh,
                                   triface* searchtet) {
    triface spintet, flipedge;
    point pd, pe;
    flipconstraints fc;
    int types[2], poss[4], intflag;
    int success;
    int t1ver;
    int i, j;

    fc.fac[0] = pa;
    fc.fac[1] = pb;
    fc.fac[2] = pc;
    fc.checkflipeligibility = 1;
    success = 0;

    for (i = 0; i < 3 && !success; i++) {
        while (1) {
            // Get a tet containing the edge [a,b].
            point2tetorg(fc.fac[i], *searchtet);
            finddirection(searchtet, fc.fac[(i + 1) % 3]);
            // Search the face [a,b,c]
            spintet = *searchtet;
            while (1) {
                if (apex(spintet) == fc.fac[(i + 2) % 3]) {
                    // Found the face.
                    *searchtet = spintet;
                    // Return the face [a,b,c].
                    for (j = i; j > 0; j--) {
                        eprevself(*searchtet);
                    }
                    success = 1;
                    break;
                }
                fnextself(spintet);
                if (spintet.tet == searchtet->tet) break;
            } // while (1)
            if (success) break;
            // The face is missing. Try to recover it.
            flipedge.tet = NULL;
            // Find a crossing edge of this face.
            spintet = *searchtet;
            while (1) {
                pd = apex(spintet);
                pe = oppo(spintet);
                if ((pd != dummypoint) && (pe != dummypoint)) {
                    // Check if [d,e] intersects [a,b,c]
                    intflag = tri_edge_test(pa, pb, pc, pd, pe, NULL, 1, types, poss);
                    if (intflag > 0) {
                        // By the assumption that all edges of the face exist, they can
                        //   only intersect at a single point.
                        if (intflag == 2) {
                            // Go to the edge [d,e].
                            edestoppo(spintet, flipedge); // [d,e,a,b]
                            if (searchsh != NULL) {
                                // Check the intersection type.
                                if ((types[0] == (int)ACROSSFACE) ||
                                    (types[0] == (int)ACROSSEDGE)) {
                                    // Check if [e,d] is a segment.
                                    if (issubseg(flipedge)) {
                                        return report_selfint_face(pa, pb, pc, searchsh, &flipedge,
                                                                   intflag, types, poss);
                                    } else {
                                        // Check if [e,d] is an edge of a subface.
                                        triface chkface = flipedge;
                                        while (1) {
                                            if (issubface(chkface)) break;
                                            fsymself(chkface);
                                            if (chkface.tet == flipedge.tet) break;
                                        }
                                        if (issubface(chkface)) {
                                            // Two subfaces are intersecting.
                                            return report_selfint_face(pa, pb, pc, searchsh,
                                                                       &chkface, intflag, types,
                                                                       poss);
                                        }
                                    }
                                } else if (types[0] == TOUCHFACE) {
                                    // This is possible when a Steiner point was added on it.
                                    point touchpt, *parypt;
                                    if (poss[1] == 0) {
                                        touchpt = pd; // pd is a coplanar vertex.
                                    } else {
                                        touchpt = pe; // pe is a coplanar vertex.
                                    }
                                    if (pointtype(touchpt) == FREEVOLVERTEX) {
                                        // A volume Steiner point was added in this subface.
                                        // Split this subface by this point.
                                        face checksh, *parysh;
                                        int siloc = (int)ONFACE;
                                        int sbowat = 0; // Only split this subface. A 1-to-3 flip.
                                        setpointtype(touchpt, FREEFACETVERTEX);
                                        sinsertvertex(touchpt, searchsh, NULL, siloc, sbowat, 0);
                                        st_volref_count--;
                                        st_facref_count++;
                                        // Queue this vertex for removal.
                                        subvertstack->newindex((void**)&parypt);
                                        *parypt = touchpt;
                                        // Queue new subfaces for recovery.
                                        // Put all new subfaces into stack for recovery.
                                        for (i = 0; i < caveshbdlist->objects; i++) {
                                            // Get an old subface at edge [a, b].
                                            parysh = (face*)fastlookup(caveshbdlist, i);
                                            spivot(*parysh, checksh); // The new subface [a, b, p].
                                            // Do not recover a deleted new face (degenerated).
                                            if (checksh.sh[3] != NULL) {
                                                subfacstack->newindex((void**)&parysh);
                                                *parysh = checksh;
                                            }
                                        }
                                        // Delete the old subfaces in sC(p).
                                        for (i = 0; i < caveshlist->objects; i++) {
                                            parysh = (face*)fastlookup(caveshlist, i);
                                            shellfacedealloc(subfaces, parysh->sh);
                                        }
                                        // Clear working lists.
                                        caveshlist->restart();
                                        caveshbdlist->restart();
                                        cavesegshlist->restart();
                                        // We can return this function.
                                        searchsh->sh = NULL; // It has been split.
                                        return 1;
                                    } else {
                                        // Other cases may be due to a bug or a PLC error.
                                        return report_selfint_face(pa, pb, pc, searchsh, &flipedge,
                                                                   intflag, types, poss);
                                    }
                                } else {
                                    // The other intersection types: ACROSSVERT, TOUCHEDGE,
                                    // SHAREVERTEX should not be possible or due to a PLC error.
                                    return report_selfint_face(pa, pb, pc, searchsh, &flipedge,
                                                               intflag, types, poss);
                                }
                            }    // if (searchsh != NULL)
                        } else { // intflag == 4. Coplanar case.
                            terminatetetgen(this, 2);
                        }
                        break;
                    } // if (intflag > 0)
                }
                fnextself(spintet);
                if (spintet.tet == searchtet->tet) {
                    terminatetetgen(this, 2);
                }
            } // while (1)
            // Try to flip the edge [d,e].
            if (removeedgebyflips(&flipedge, &fc) == 2) {
                // A crossing edge is removed.
                continue;
            }
            break;
        } // while (1)
    }     // i

    return success;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// recoversubfaces()    Recover all subfaces.                                //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::recoversubfaces(arraypool* misshlist, int steinerflag) {
    triface searchtet, neightet, spintet;
    face searchsh, neighsh, neineish, *parysh;
    face bdsegs[3];
    point startpt, endpt, apexpt, *parypt;
    point steinerpt;
    insertvertexflags ivf;
    int success;
    int t1ver;
    int i, j;

    if (b->verbose > 1) {
        printf("    Recover subfaces [%s level = %2d] #:  %ld.\n",
               (b->fliplinklevel > 0) ? "fixed" : "auto",
               (b->fliplinklevel > 0) ? b->fliplinklevel : autofliplinklevel, subfacstack->objects);
    }

    // Loop until 'subfacstack' is empty.
    while (subfacstack->objects > 0l) {

        subfacstack->objects--;
        parysh = (face*)fastlookup(subfacstack, subfacstack->objects);
        searchsh = *parysh;

        if (searchsh.sh[3] == NULL) continue; // Skip a dead subface.

        stpivot(searchsh, neightet);
        if (neightet.tet != NULL) continue; // Skip a recovered subface.

        if (b->verbose > 2) {
            printf("      Recover subface (%d, %d, %d).\n", pointmark(sorg(searchsh)),
                   pointmark(sdest(searchsh)), pointmark(sapex(searchsh)));
        }

        // The three edges of the face need to be existed first.
        for (i = 0; i < 3; i++) {
            sspivot(searchsh, bdsegs[i]);
            if (bdsegs[i].sh != NULL) {
                // The segment must exist.
                sstpivot1(bdsegs[i], searchtet);
                if (searchtet.tet == NULL) {
                    terminatetetgen(this, 2);
                }
            } else {
                // This edge is not a segment (due to a Steiner point).
                // Check whether it exists or not.
                success = 0;
                startpt = sorg(searchsh);
                endpt = sdest(searchsh);
                point2tetorg(startpt, searchtet);
                finddirection(&searchtet, endpt);
                if (dest(searchtet) == endpt) {
                    success = 1;
                } else {
                    // The edge is missing. Try to recover it.
                    if (recoveredgebyflips(startpt, endpt, &searchsh, &searchtet, 0)) {
                        success = 1;
                    } else {
                        if (recoveredgebyflips(endpt, startpt, &searchsh, &searchtet, 0)) {
                            success = 1;
                        }
                    }
                }
                if (success) {
                    // Insert a temporary segment to protect this edge.
                    makeshellface(subsegs, &(bdsegs[i]));
                    setshvertices(bdsegs[i], startpt, endpt, NULL);
                    smarktest2(bdsegs[i]); // It's a temporary segment.
                    // Insert this segment into surface mesh.
                    ssbond(searchsh, bdsegs[i]);
                    spivot(searchsh, neighsh);
                    if (neighsh.sh != NULL) {
                        ssbond(neighsh, bdsegs[i]);
                    }
                    // Insert this segment into tetrahedralization.
                    sstbond1(bdsegs[i], searchtet);
                    // Bond the segment to all tets containing it.
                    spintet = searchtet;
                    do {
                        tssbond1(spintet, bdsegs[i]);
                        fnextself(spintet);
                    } while (spintet.tet != searchtet.tet);
                } else {
                    // An edge of this subface is missing. Can't recover this subface.
                    // Delete any temporary segment that has been created.
                    for (j = (i - 1); j >= 0; j--) {
                        if (smarktest2ed(bdsegs[j])) {
                            spivot(bdsegs[j], neineish);
                            ssdissolve(neineish);
                            spivot(neineish, neighsh);
                            if (neighsh.sh != NULL) {
                                ssdissolve(neighsh);
                            }
                            sstpivot1(bdsegs[j], searchtet);
                            spintet = searchtet;
                            while (1) {
                                tssdissolve1(spintet);
                                fnextself(spintet);
                                if (spintet.tet == searchtet.tet) break;
                            }
                            shellfacedealloc(subsegs, bdsegs[j].sh);
                        }
                    } // j
                    if (steinerflag) {
                        // Add a Steiner point at the midpoint of this edge.
                        if (b->verbose > 2) {
                            printf("      Add a Steiner point in subedge (%d, %d).\n",
                                   pointmark(startpt), pointmark(endpt));
                        }
                        makepoint(&steinerpt, FREEFACETVERTEX);
                        for (j = 0; j < 3; j++) {
                            steinerpt[j] = 0.5 * (startpt[j] + endpt[j]);
                        }

                        point2tetorg(startpt, searchtet); // Start from 'searchtet'.
                        ivf.iloc = (int)OUTSIDE;          // Need point location.
                        ivf.bowywat = 1;
                        ivf.lawson = 0;
                        ivf.rejflag = 0;
                        ivf.chkencflag = 0;
                        ivf.sloc = (int)ONEDGE;
                        ivf.sbowywat = 1; // Allow flips in facet.
                        ivf.splitbdflag = 0;
                        ivf.validflag = 1;
                        ivf.respectbdflag = 1;
                        ivf.assignmeshsize = b->metric;
                        if (!insertpoint(steinerpt, &searchtet, &searchsh, NULL, &ivf)) {
                            terminatetetgen(this, 2);
                        }
                        // Save this Steiner point (for removal).
                        //   Re-use the array 'subvertstack'.
                        subvertstack->newindex((void**)&parypt);
                        *parypt = steinerpt;

                        st_facref_count++;
                        if (steinerleft > 0) steinerleft--;
                    } // if (steinerflag)
                    break;
                }
            }
            senextself(searchsh);
        } // i

        if (i == 3) {
            // Recover the subface.
            startpt = sorg(searchsh);
            endpt = sdest(searchsh);
            apexpt = sapex(searchsh);

            success = recoverfacebyflips(startpt, endpt, apexpt, &searchsh, &searchtet);

            // Delete any temporary segment that has been created.
            for (j = 0; j < 3; j++) {
                if (smarktest2ed(bdsegs[j])) {
                    spivot(bdsegs[j], neineish);
                    ssdissolve(neineish);
                    spivot(neineish, neighsh);
                    if (neighsh.sh != NULL) {
                        ssdissolve(neighsh);
                    }
                    sstpivot1(bdsegs[j], neightet);
                    spintet = neightet;
                    while (1) {
                        tssdissolve1(spintet);
                        fnextself(spintet);
                        if (spintet.tet == neightet.tet) break;
                    }
                    shellfacedealloc(subsegs, bdsegs[j].sh);
                }
            } // j

            if (success) {
                if (searchsh.sh != NULL) {
                    // Face is recovered. Insert it.
                    tsbond(searchtet, searchsh);
                    fsymself(searchtet);
                    sesymself(searchsh);
                    tsbond(searchtet, searchsh);
                }
            } else {
                if (steinerflag) {
                    // Add a Steiner point at the barycenter of this subface.
                    if (b->verbose > 2) {
                        printf("      Add a Steiner point in subface (%d, %d, %d).\n",
                               pointmark(startpt), pointmark(endpt), pointmark(apexpt));
                    }
                    makepoint(&steinerpt, FREEFACETVERTEX);
                    for (j = 0; j < 3; j++) {
                        steinerpt[j] = (startpt[j] + endpt[j] + apexpt[j]) / 3.0;
                    }

                    point2tetorg(startpt, searchtet); // Start from 'searchtet'.
                    ivf.iloc = (int)OUTSIDE;          // Need point location.
                    ivf.bowywat = 1;
                    ivf.lawson = 0;
                    ivf.rejflag = 0;
                    ivf.chkencflag = 0;
                    ivf.sloc = (int)ONFACE;
                    ivf.sbowywat = 1; // Allow flips in facet.
                    ivf.splitbdflag = 0;
                    ivf.validflag = 1;
                    ivf.respectbdflag = 1;
                    ivf.assignmeshsize = b->metric;
                    if (!insertpoint(steinerpt, &searchtet, &searchsh, NULL, &ivf)) {
                        terminatetetgen(this, 2);
                    }
                    // Save this Steiner point (for removal).
                    //   Re-use the array 'subvertstack'.
                    subvertstack->newindex((void**)&parypt);
                    *parypt = steinerpt;

                    st_facref_count++;
                    if (steinerleft > 0) steinerleft--;
                } // if (steinerflag)
            }
        } else {
            success = 0;
        }

        if (!success) {
            if (misshlist != NULL) {
                // Save this subface.
                misshlist->newindex((void**)&parysh);
                *parysh = searchsh;
            }
        }

    } // while (subfacstack->objects > 0l)

    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// getvertexstar()    Return the star of a vertex.                           //
//                                                                           //
// If the flag 'fullstar' is set, return the complete star of this vertex.   //
// Otherwise, only a part of the star which is bounded by facets is returned.//
//                                                                           //
// 'tetlist' returns the list of tets in the star of the vertex 'searchpt'.  //
// Every tet in 'tetlist' is at the face opposing to 'searchpt'.             //
//                                                                           //
// 'vertlist' returns the list of vertices in the star (exclude 'searchpt'). //
//                                                                           //
// 'shlist' returns the list of subfaces in the star. Each subface must face //
// to the interior of this star.                                             //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::getvertexstar(int fullstar, point searchpt, arraypool* tetlist, arraypool* vertlist,
                              arraypool* shlist) {
    triface searchtet, neightet, *parytet;
    face checksh, *parysh;
    point pt, *parypt;
    int collectflag;
    int t1ver;
    int i, j;

    point2tetorg(searchpt, searchtet);

    // Go to the opposite face (the link face) of the vertex.
    enextesymself(searchtet);
    // assert(oppo(searchtet) == searchpt);
    infect(searchtet); // Collect this tet (link face).
    tetlist->newindex((void**)&parytet);
    *parytet = searchtet;
    if (vertlist != NULL) {
        // Collect three (link) vertices.
        j = (searchtet.ver & 3); // The current vertex index.
        for (i = 1; i < 4; i++) {
            pt = (point)searchtet.tet[4 + ((j + i) % 4)];
            pinfect(pt);
            vertlist->newindex((void**)&parypt);
            *parypt = pt;
        }
    }

    collectflag = 1;
    esym(searchtet, neightet);
    if (issubface(neightet)) {
        if (shlist != NULL) {
            tspivot(neightet, checksh);
            if (!sinfected(checksh)) {
                // Collect this subface (link edge).
                sinfected(checksh);
                shlist->newindex((void**)&parysh);
                *parysh = checksh;
            }
        }
        if (!fullstar) {
            collectflag = 0;
        }
    }
    if (collectflag) {
        fsymself(neightet); // Goto the adj tet of this face.
        esymself(neightet); // Goto the oppo face of this vertex.
        // assert(oppo(neightet) == searchpt);
        infect(neightet); // Collect this tet (link face).
        tetlist->newindex((void**)&parytet);
        *parytet = neightet;
        if (vertlist != NULL) {
            // Collect its apex.
            pt = apex(neightet);
            pinfect(pt);
            vertlist->newindex((void**)&parypt);
            *parypt = pt;
        }
    } // if (collectflag)

    // Continue to collect all tets in the star.
    for (i = 0; i < tetlist->objects; i++) {
        searchtet = *(triface*)fastlookup(tetlist, i);
        // Note that 'searchtet' is a face opposite to 'searchpt', and the neighbor
        //   tet at the current edge is already collected.
        // Check the neighbors at the other two edges of this face.
        for (j = 0; j < 2; j++) {
            collectflag = 1;
            enextself(searchtet);
            esym(searchtet, neightet);
            if (issubface(neightet)) {
                if (shlist != NULL) {
                    tspivot(neightet, checksh);
                    if (!sinfected(checksh)) {
                        // Collect this subface (link edge).
                        sinfected(checksh);
                        shlist->newindex((void**)&parysh);
                        *parysh = checksh;
                    }
                }
                if (!fullstar) {
                    collectflag = 0;
                }
            }
            if (collectflag) {
                fsymself(neightet);
                if (!infected(neightet)) {
                    esymself(neightet); // Go to the face opposite to 'searchpt'.
                    infect(neightet);
                    tetlist->newindex((void**)&parytet);
                    *parytet = neightet;
                    if (vertlist != NULL) {
                        // Check if a vertex is collected.
                        pt = apex(neightet);
                        if (!pinfected(pt)) {
                            pinfect(pt);
                            vertlist->newindex((void**)&parypt);
                            *parypt = pt;
                        }
                    }
                } // if (!infected(neightet))
            }     // if (collectflag)
        }         // j
    }             // i

    // Uninfect the list of tets and vertices.
    for (i = 0; i < tetlist->objects; i++) {
        parytet = (triface*)fastlookup(tetlist, i);
        uninfect(*parytet);
    }

    if (vertlist != NULL) {
        for (i = 0; i < vertlist->objects; i++) {
            parypt = (point*)fastlookup(vertlist, i);
            puninfect(*parypt);
        }
    }

    if (shlist != NULL) {
        for (i = 0; i < shlist->objects; i++) {
            parysh = (face*)fastlookup(shlist, i);
            suninfect(*parysh);
        }
    }

    return (int)tetlist->objects;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// getedge()    Get a tetrahedron having the two endpoints.                  //
//                                                                           //
// The method here is to search the second vertex in the link faces of the   //
// first vertex. The global array 'cavetetlist' is re-used for searching.    //
//                                                                           //
// This function is used for the case when the mesh is non-convex. Otherwise,//
// the function finddirection() should be faster than this.                  //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::getedge(point e1, point e2, triface* tedge) {
    triface searchtet, neightet, *parytet;
    point pt;
    int done;
    int i, j;

    if (b->verbose > 2) {
        printf("      Get edge from %d to %d.\n", pointmark(e1), pointmark(e2));
    }

    // Quickly check if 'tedge' is just this edge.
    if (!isdeadtet(*tedge)) {
        if (org(*tedge) == e1) {
            if (dest(*tedge) == e2) {
                return 1;
            }
        } else if (org(*tedge) == e2) {
            if (dest(*tedge) == e1) {
                esymself(*tedge);
                return 1;
            }
        }
    }

    // Search for the edge [e1, e2].
    point2tetorg(e1, *tedge);
    finddirection(tedge, e2);
    if (dest(*tedge) == e2) {
        return 1;
    } else {
        // Search for the edge [e2, e1].
        point2tetorg(e2, *tedge);
        finddirection(tedge, e1);
        if (dest(*tedge) == e1) {
            esymself(*tedge);
            return 1;
        }
    }

    // Go to the link face of e1.
    point2tetorg(e1, searchtet);
    enextesymself(searchtet);
    arraypool* tetlist = cavebdrylist;

    // Search e2.
    for (i = 0; i < 3; i++) {
        pt = apex(searchtet);
        if (pt == e2) {
            // Found. 'searchtet' is [#,#,e2,e1].
            eorgoppo(searchtet, *tedge); // [e1,e2,#,#].
            return 1;
        }
        enextself(searchtet);
    }

    // Get the adjacent link face at 'searchtet'.
    fnext(searchtet, neightet);
    esymself(neightet);
    // assert(oppo(neightet) == e1);
    pt = apex(neightet);
    if (pt == e2) {
        // Found. 'neightet' is [#,#,e2,e1].
        eorgoppo(neightet, *tedge); // [e1,e2,#,#].
        return 1;
    }

    // Continue searching in the link face of e1.
    infect(searchtet);
    tetlist->newindex((void**)&parytet);
    *parytet = searchtet;
    infect(neightet);
    tetlist->newindex((void**)&parytet);
    *parytet = neightet;

    done = 0;

    for (i = 0; (i < tetlist->objects) && !done; i++) {
        parytet = (triface*)fastlookup(tetlist, i);
        searchtet = *parytet;
        for (j = 0; (j < 2) && !done; j++) {
            enextself(searchtet);
            fnext(searchtet, neightet);
            if (!infected(neightet)) {
                esymself(neightet);
                pt = apex(neightet);
                if (pt == e2) {
                    // Found. 'neightet' is [#,#,e2,e1].
                    eorgoppo(neightet, *tedge);
                    done = 1;
                } else {
                    infect(neightet);
                    tetlist->newindex((void**)&parytet);
                    *parytet = neightet;
                }
            }
        } // j
    }     // i

    // Uninfect the list of visited tets.
    for (i = 0; i < tetlist->objects; i++) {
        parytet = (triface*)fastlookup(tetlist, i);
        uninfect(*parytet);
    }
    tetlist->restart();

    return done;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// reduceedgesatvertex()    Reduce the number of edges at a given vertex.    //
//                                                                           //
// 'endptlist' contains the endpoints of edges connecting at the vertex.     //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::reduceedgesatvertex(point startpt, arraypool* endptlist) {
    triface searchtet;
    point *pendpt, *parypt;
    enum interresult dir;
    flipconstraints fc;
    int reduceflag;
    int count;
    int n, i, j;

    fc.remvert = startpt;
    fc.checkflipeligibility = 1;

    while (1) {

        count = 0;

        for (i = 0; i < endptlist->objects; i++) {
            pendpt = (point*)fastlookup(endptlist, i);
            if (*pendpt == dummypoint) {
                continue; // Do not reduce a virtual edge.
            }
            reduceflag = 0;
            // Find the edge.
            if (nonconvex) {
                if (getedge(startpt, *pendpt, &searchtet)) {
                    dir = ACROSSVERT;
                } else {
                    // The edge does not exist (was flipped).
                    dir = INTERSECT;
                }
            } else {
                point2tetorg(startpt, searchtet);
                dir = finddirection(&searchtet, *pendpt);
            }
            if (dir == ACROSSVERT) {
                if (dest(searchtet) == *pendpt) {
                    // Do not flip a segment.
                    if (!issubseg(searchtet)) {
                        n = removeedgebyflips(&searchtet, &fc);
                        if (n == 2) {
                            reduceflag = 1;
                        }
                    }
                }
            } else {
                // The edge has been flipped.
                reduceflag = 1;
            }
            if (reduceflag) {
                count++;
                // Move the last vertex into this slot.
                j = endptlist->objects - 1;
                parypt = (point*)fastlookup(endptlist, j);
                *pendpt = *parypt;
                endptlist->objects--;
                i--;
            }
        } // i

        if (count == 0) {
            // No edge is reduced.
            break;
        }

    } // while (1)

    return (int)endptlist->objects;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// removevertexbyflips()    Remove a vertex by flips.                        //
//                                                                           //
// This routine attempts to remove the given vertex 'rempt' (p) from the     //
// tetrahedralization (T) by a sequence of flips.                            //
//                                                                           //
// The algorithm used here is a simple edge reduce method. Suppose there are //
// n edges connected at p. We try to reduce the number of edges by flipping  //
// any edge (not a segment) that is connecting at p.                         //
//                                                                           //
// Unless T is a Delaunay tetrahedralization, there is no guarantee that 'p' //
// can be successfully removed.                                              //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::removevertexbyflips(point steinerpt) {
    triface *fliptets = NULL, wrktets[4];
    triface searchtet, spintet, neightet;
    face parentsh, spinsh, checksh;
    face leftseg, rightseg, checkseg;
    point lpt = NULL, rpt = NULL, apexpt; //, *parypt;
    flipconstraints fc;
    enum verttype vt;
    enum locateresult loc;
    int valence, removeflag;
    int slawson;
    int t1ver;
    int n, i;

    vt = pointtype(steinerpt);

    if (vt == FREESEGVERTEX) {
        sdecode(point2sh(steinerpt), leftseg);
        leftseg.shver = 0;
        if (sdest(leftseg) == steinerpt) {
            senext(leftseg, rightseg);
            spivotself(rightseg);
            rightseg.shver = 0;
        } else {
            rightseg = leftseg;
            senext2(rightseg, leftseg);
            spivotself(leftseg);
            leftseg.shver = 0;
        }
        lpt = sorg(leftseg);
        rpt = sdest(rightseg);
        if (b->verbose > 2) {
            printf("      Removing Steiner point %d in segment (%d, %d).\n", pointmark(steinerpt),
                   pointmark(lpt), pointmark(rpt));
        }
    } else if (vt == FREEFACETVERTEX) {
        if (b->verbose > 2) {
            printf("      Removing Steiner point %d in facet.\n", pointmark(steinerpt));
        }
    } else if (vt == FREEVOLVERTEX) {
        if (b->verbose > 2) {
            printf("      Removing Steiner point %d in volume.\n", pointmark(steinerpt));
        }
    } else if (vt == VOLVERTEX) {
        if (b->verbose > 2) {
            printf("      Removing a point %d in volume.\n", pointmark(steinerpt));
        }
    } else {
        // It is not a Steiner point.
        return 0;
    }

    // Try to reduce the number of edges at 'p' by flips.
    getvertexstar(1, steinerpt, cavetetlist, cavetetvertlist, NULL);
    cavetetlist->restart(); // This list may be re-used.
    if (cavetetvertlist->objects > 3l) {
        valence = reduceedgesatvertex(steinerpt, cavetetvertlist);
    } else {
        valence = cavetetvertlist->objects;
    }
    cavetetvertlist->restart();

    removeflag = 0;

    if (valence == 4) {
        // Only 4 vertices (4 tets) left! 'p' is inside the convex hull of the 4
        //   vertices. This case is due to that 'p' is not exactly on the segment.
        point2tetorg(steinerpt, searchtet);
        loc = INTETRAHEDRON;
        removeflag = 1;
    } else if (valence == 5) {
        // There are 5 edges.
        if (vt == FREESEGVERTEX) {
            sstpivot1(leftseg, searchtet);
            if (org(searchtet) != steinerpt) {
                esymself(searchtet);
            }
            i = 0;               // Count the numbe of tet at the edge [p,lpt].
            neightet.tet = NULL; // Init the face.
            spintet = searchtet;
            while (1) {
                i++;
                if (apex(spintet) == rpt) {
                    // Remember the face containing the edge [lpt, rpt].
                    neightet = spintet;
                }
                fnextself(spintet);
                if (spintet.tet == searchtet.tet) break;
            }
            if (i == 3) {
                // This case has been checked below.
            } else if (i == 4) {
                // There are 4 tets sharing at [p,lpt]. There must be 4 tets sharing
                //   at [p,rpt].  There must be a face [p, lpt, rpt].
                if (apex(neightet) == rpt) {
                    // The edge (segment) has been already recovered!
                    // Check if a 6-to-2 flip is possible (to remove 'p').
                    // Let 'searchtet' be [p,d,a,b]
                    esym(neightet, searchtet);
                    enextself(searchtet);
                    // Check if there are exactly three tets at edge [p,d].
                    wrktets[0] = searchtet; // [p,d,a,b]
                    for (i = 0; i < 2; i++) {
                        fnext(wrktets[i], wrktets[i + 1]); // [p,d,b,c], [p,d,c,a]
                    }
                    if (apex(wrktets[0]) == oppo(wrktets[2])) {
                        loc = ONFACE;
                        removeflag = 1;
                    }
                }
            }
        } else if (vt == FREEFACETVERTEX) {
            // It is possible to do a 6-to-2 flip to remove the vertex.
            point2tetorg(steinerpt, searchtet);
            // Get the three faces of 'searchtet' which share at p.
            //    All faces has p as origin.
            wrktets[0] = searchtet;
            wrktets[1] = searchtet;
            esymself(wrktets[1]);
            enextself(wrktets[1]);
            wrktets[2] = searchtet;
            eprevself(wrktets[2]);
            esymself(wrktets[2]);
            // All internal edges of the six tets have valance either 3 or 4.
            // Get one edge which has valance 3.
            searchtet.tet = NULL;
            for (i = 0; i < 3; i++) {
                spintet = wrktets[i];
                valence = 0;
                while (1) {
                    valence++;
                    fnextself(spintet);
                    if (spintet.tet == wrktets[i].tet) break;
                }
                if (valence == 3) {
                    // Found the edge.
                    searchtet = wrktets[i];
                    break;
                }
            }
            // Note, we do not detach the three subfaces at p.
            // They will be removed within a 4-to-1 flip.
            loc = ONFACE;
            removeflag = 1;
        }
        // removeflag = 1;
    }

    if (!removeflag) {
        if (vt == FREESEGVERTEX) {
            // Check is it possible to recover the edge [lpt,rpt].
            // The condition to check is:  Whether each tet containing 'leftseg' is
            //   adjacent to a tet containing 'rightseg'.
            sstpivot1(leftseg, searchtet);
            if (org(searchtet) != steinerpt) {
                esymself(searchtet);
            }
            spintet = searchtet;
            while (1) {
                // Go to the bottom face of this tet.
                eprev(spintet, neightet);
                esymself(neightet); // [steinerpt, p1, p2, lpt]
                // Get the adjacent tet.
                fsymself(neightet); // [p1, steinerpt, p2, rpt]
                if (oppo(neightet) != rpt) {
                    // Found a non-matching adjacent tet.
                    break;
                }
                {
                    // [2017-10-15] Check if the tet is inverted?
                    point chkp1 = org(neightet);
                    point chkp2 = apex(neightet);
                    REAL chkori = orient3d(rpt, lpt, chkp1, chkp2);
                    if (chkori >= 0.0) {
                        // Either inverted or degenerated.
                        break;
                    }
                }
                fnextself(spintet);
                if (spintet.tet == searchtet.tet) {
                    // 'searchtet' is [p,d,p1,p2].
                    loc = ONEDGE;
                    removeflag = 1;
                    break;
                }
            }
        } // if (vt == FREESEGVERTEX)
    }

    if (!removeflag) {
        if (vt == FREESEGVERTEX) {
            // Check if the edge [lpt, rpt] exists.
            if (getedge(lpt, rpt, &searchtet)) {
                // We have recovered this edge. Shift the vertex into the volume.
                // We can recover this edge if the subfaces are not recovered yet.
                if (!checksubfaceflag) {
                    // Remove the vertex from the surface mesh.
                    //   This will re-create the segment [lpt, rpt] and re-triangulate
                    //   all the facets at the segment.
                    // Detach the subsegments from their surrounding tets.
                    for (i = 0; i < 2; i++) {
                        checkseg = (i == 0) ? leftseg : rightseg;
                        sstpivot1(checkseg, neightet);
                        spintet = neightet;
                        while (1) {
                            tssdissolve1(spintet);
                            fnextself(spintet);
                            if (spintet.tet == neightet.tet) break;
                        }
                        sstdissolve1(checkseg);
                    }                           // i
                    slawson = 1;                // Do lawson flip after removal.
                    spivot(rightseg, parentsh); // 'rightseg' has p as its origin.
                    sremovevertex(steinerpt, &parentsh, &rightseg, slawson);
                    // Clear the list for new subfaces.
                    caveshbdlist->restart();
                    // Insert the new segment.
                    sstbond1(rightseg, searchtet);
                    spintet = searchtet;
                    while (1) {
                        tssbond1(spintet, rightseg);
                        fnextself(spintet);
                        if (spintet.tet == searchtet.tet) break;
                    }
                    // The Steiner point has been shifted into the volume.
                    setpointtype(steinerpt, FREEVOLVERTEX);
                    st_segref_count--;
                    st_volref_count++;
                    return 1;
                } // if (!checksubfaceflag)
            }     // if (getedge(...))
        }         // if (vt == FREESEGVERTEX)
    }             // if (!removeflag)

    if (!removeflag) {
        return 0;
    }

    if (vt == FREESEGVERTEX) {
        // Detach the subsegments from their surronding tets.
        for (i = 0; i < 2; i++) {
            checkseg = (i == 0) ? leftseg : rightseg;
            sstpivot1(checkseg, neightet);
            spintet = neightet;
            while (1) {
                tssdissolve1(spintet);
                fnextself(spintet);
                if (spintet.tet == neightet.tet) break;
            }
            sstdissolve1(checkseg);
        } // i
        if (checksubfaceflag) {
            // Detach the subfaces at the subsegments from their attached tets.
            for (i = 0; i < 2; i++) {
                checkseg = (i == 0) ? leftseg : rightseg;
                spivot(checkseg, parentsh);
                if (parentsh.sh != NULL) {
                    spinsh = parentsh;
                    while (1) {
                        stpivot(spinsh, neightet);
                        if (neightet.tet != NULL) {
                            tsdissolve(neightet);
                        }
                        sesymself(spinsh);
                        stpivot(spinsh, neightet);
                        if (neightet.tet != NULL) {
                            tsdissolve(neightet);
                        }
                        stdissolve(spinsh);
                        spivotself(spinsh); // Go to the next subface.
                        if (spinsh.sh == parentsh.sh) break;
                    }
                }
            } // i
        }     // if (checksubfaceflag)
    }

    if (loc == INTETRAHEDRON) {
        // Collect the four tets containing 'p'.
        fliptets = new triface[4];
        fliptets[0] = searchtet; // [p,d,a,b]
        for (i = 0; i < 2; i++) {
            fnext(fliptets[i], fliptets[i + 1]); // [p,d,b,c], [p,d,c,a]
        }
        eprev(fliptets[0], fliptets[3]);
        fnextself(fliptets[3]); // it is [a,p,b,c]
        eprevself(fliptets[3]);
        esymself(fliptets[3]); // [a,b,c,p].
        // Remove p by a 4-to-1 flip.
        // flip41(fliptets, 1, 0, 0);
        /*
        { // Do not flip if there are wrong number of subfaces inside.
          // Check if there are three subfaces at 'p'.
          triface newface; face flipshs[3];
          int spivot = 0, scount = 0;
          for (i = 0; i < 3; i++) {
            fnext(fliptets[3], newface); // [a,b,p,d],[b,c,p,d],[c,a,p,d].
            tspivot(newface, flipshs[i]);
            if (flipshs[i].sh != NULL) {
              spivot = i; // Remember this subface.
              scount++;
            }
            enextself(fliptets[3]);
          }
          if (scount > 0) {
            // There are three subfaces connecting at p.
            // Only do flip if a 3-to-1 flip is possible at p at the bottom face.
            if (scount != 3) {
              // Wrong number of subfaces. Do not flip.
              delete [] fliptets;
              return 0;
            }
            // [2018-03-07] an old fix, not 100% safe.
            // if (scount < 3) {
            //  // The new subface is one of {[a,b,d], [b,c,d], [c,a,d]}.
            //  // assert(scount == 1); // spivot >= 0
            //  if (scount != 1) {
            //    // Wrong number of subfaces. Do not flip.
            //    delete [] fliptets;
            //    return 0;
            //  }
            //}
          }
        }
        */
        if (vt == FREEFACETVERTEX) {
            // [2018-03-08] Check if the last 4-to-1 flip is valid.
            // fliptets[0],[1],[2] are [p,d,a,b],[p,d,b,c],[p,d,c,a]
            triface checktet, chkface;
            for (i = 0; i < 3; i++) {
                enext(fliptets[i], checktet);
                esymself(checktet); // [a,d,b,p],[b,d,c,p],[c,d,a,p]
                int scount = 0;
                int k;
                for (k = 0; k < 3; k++) {
                    esym(checktet, chkface);
                    if (issubface(chkface)) scount++;
                    enextself(checktet);
                }
                if (scount == 3) {
                    break; // Found a tet which support a 3-to-1 flip.
                } else if (scount == 2) {
                    // This is a strange configuration. Debug it.
                    // Do not do this flip.
                    delete[] fliptets;
                    return 0;
                }
            }
            if (i == 3) {
                // No tet in [p,d,a,b],[p,d,b,c],[p,d,c,a] support it.
                int scount = 0;
                for (i = 0; i < 3; i++) {
                    eprev(fliptets[i], checktet);
                    esymself(checktet); // [p,a,b,d],[p,b,c,d],[p,c,a,d]
                    if (issubface(chkface)) scount++;
                }
                if (scount != 3) {
                    // Do not do this flip.
                    delete[] fliptets;
                    return 0;
                }
            }
        } // if (vt == FREEFACETVERTEX)
        flip41(fliptets, 1, &fc);
        // recenttet = fliptets[0];
    } else if (loc == ONFACE) {
        // Let the original two tets be [a,b,c,d] and [b,a,c,e]. And p is in
        //   face [a,b,c].  Let 'searchtet' be the tet [p,d,a,b].
        // Collect the six tets containing 'p'.
        fliptets = new triface[6];
        fliptets[0] = searchtet; // [p,d,a,b]
        for (i = 0; i < 2; i++) {
            fnext(fliptets[i], fliptets[i + 1]); // [p,d,b,c], [p,d,c,a]
        }
        eprev(fliptets[0], fliptets[3]);
        fnextself(fliptets[3]); // [a,p,b,e]
        esymself(fliptets[3]);  // [p,a,e,b]
        eprevself(fliptets[3]); // [e,p,a,b]
        for (i = 3; i < 5; i++) {
            fnext(fliptets[i], fliptets[i + 1]); // [e,p,b,c], [e,p,c,a]
        }
        if (vt == FREEFACETVERTEX) {
            // We need to determine the location of three subfaces at p.
            valence = 0; // Re-use it.
            for (i = 3; i < 6; i++) {
                if (issubface(fliptets[i])) valence++;
            }
            if (valence > 0) {
                // We must do 3-to-2 flip in the upper part. We simply re-arrange
                //   the six tets.
                for (i = 0; i < 3; i++) {
                    esym(fliptets[i + 3], wrktets[i]);
                    esym(fliptets[i], fliptets[i + 3]);
                    fliptets[i] = wrktets[i];
                }
                // Swap the last two pairs, i.e., [1]<->[[2], and [4]<->[5]
                wrktets[1] = fliptets[1];
                fliptets[1] = fliptets[2];
                fliptets[2] = wrktets[1];
                wrktets[1] = fliptets[4];
                fliptets[4] = fliptets[5];
                fliptets[5] = wrktets[1];
            }
            // [2018-03-08] Check if the last 4-to-1 flip is valid.
            // fliptets[0],[1],[2] are [p,d,a,b],[p,d,b,c],[p,d,c,a]
            triface checktet, chkface;
            for (i = 0; i < 3; i++) {
                enext(fliptets[i], checktet);
                esymself(checktet); // [a,d,b,p],[b,d,c,p],[c,d,a,p]
                int scount = 0;
                int k;
                for (k = 0; k < 3; k++) {
                    esym(checktet, chkface);
                    if (issubface(chkface)) scount++;
                    enextself(checktet);
                }
                if (scount == 3) {
                    break; // Found a tet which support a 3-to-1 flip.
                } else if (scount == 2) {
                    // This is a strange configuration. Debug it.
                    // Do not do this flip.
                    delete[] fliptets;
                    return 0;
                }
            }
            if (i == 3) {
                // No tet in [p,d,a,b],[p,d,b,c],[p,d,c,a] support it.
                int scount = 0;
                for (i = 0; i < 3; i++) {
                    eprev(fliptets[i], checktet);
                    esymself(checktet); // [p,a,b,d],[p,b,c,d],[p,c,a,d]
                    if (issubface(chkface)) scount++;
                }
                if (scount != 3) {
                    // Do not do this flip.
                    delete[] fliptets;
                    return 0;
                }
            }
        } // vt == FREEFACETVERTEX
        // Remove p by a 6-to-2 flip, which is a combination of two flips:
        //   a 3-to-2 (deletes the edge [e,p]), and
        //   a 4-to-1 (deletes the vertex p).
        // First do a 3-to-2 flip on [e,p,a,b],[e,p,b,c],[e,p,c,a]. It creates
        //   two new tets: [a,b,c,p] and [b,a,c,e].  The new tet [a,b,c,p] is
        //   degenerate (has zero volume). It will be deleted in the followed
        //   4-to-1 flip.
        // flip32(&(fliptets[3]), 1, 0, 0);
        flip32(&(fliptets[3]), 1, &fc);
        // Second do a 4-to-1 flip on [p,d,a,b],[p,d,b,c],[p,d,c,a],[a,b,c,p].
        //   This creates a new tet [a,b,c,d].
        // flip41(fliptets, 1, 0, 0);
        flip41(fliptets, 1, &fc);
        // recenttet = fliptets[0];
    } else if (loc == ONEDGE) {
        // Let the original edge be [e,d] and p is in [e,d]. Assume there are n
        //   tets sharing at edge [e,d] originally.  We number the link vertices
        //   of [e,d]: p_0, p_1, ..., p_n-1. 'searchtet' is [p,d,p_0,p_1].
        // Count the number of tets at edge [e,p] and [p,d] (this is n).
        n = 0;
        spintet = searchtet;
        while (1) {
            n++;
            fnextself(spintet);
            if (spintet.tet == searchtet.tet) break;
        }
        // Collect the 2n tets containing 'p'.
        fliptets = new triface[2 * n];
        fliptets[0] = searchtet; // [p,b,p_0,p_1]
        for (i = 0; i < (n - 1); i++) {
            fnext(fliptets[i], fliptets[i + 1]); // [p,d,p_i,p_i+1].
        }
        eprev(fliptets[0], fliptets[n]);
        fnextself(fliptets[n]); // [p_0,p,p_1,e]
        esymself(fliptets[n]);  // [p,p_0,e,p_1]
        eprevself(fliptets[n]); // [e,p,p_0,p_1]
        for (i = n; i < (2 * n - 1); i++) {
            fnext(fliptets[i], fliptets[i + 1]); // [e,p,p_i,p_i+1].
        }
        // Remove p by a 2n-to-n flip, it is a sequence of n flips:
        // - Do a 2-to-3 flip on
        //     [p_0,p_1,p,d] and
        //     [p,p_1,p_0,e].
        //   This produces:
        //     [e,d,p_0,p_1],
        //     [e,d,p_1,p] (degenerated), and
        //     [e,d,p,p_0] (degenerated).
        wrktets[0] = fliptets[0]; // [p,d,p_0,p_1]
        eprevself(wrktets[0]);    // [p_0,p,d,p_1]
        esymself(wrktets[0]);     // [p,p_0,p_1,d]
        enextself(wrktets[0]);    // [p_0,p_1,p,d] [0]
        wrktets[1] = fliptets[n]; // [e,p,p_0,p_1]
        enextself(wrktets[1]);    // [p,p_0,e,p_1]
        esymself(wrktets[1]);     // [p_0,p,p_1,e]
        eprevself(wrktets[1]);    // [p_1,p_0,p,e] [1]
        // flip23(wrktets, 1, 0, 0);
        flip23(wrktets, 1, &fc);
        // Save the new tet [e,d,p,p_0] (degenerated).
        fliptets[n] = wrktets[2];
        // Save the new tet [e,d,p_0,p_1].
        fliptets[0] = wrktets[0];
        // - Repeat from i = 1 to n-2: (n - 2) flips
        //   - Do a 3-to-2 flip on
        //       [p,p_i,d,e],
        //       [p,p_i,e,p_i+1], and
        //       [p,p_i,p_i+1,d].
        //     This produces:
        //       [d,e,p_i+1,p_i], and
        //       [e,d,p_i+1,p] (degenerated).
        for (i = 1; i < (n - 1); i++) {
            wrktets[0] = wrktets[1];      // [e,d,p_i,p] (degenerated).
            enextself(wrktets[0]);        // [d,p_i,e,p] (...)
            esymself(wrktets[0]);         // [p_i,d,p,e] (...)
            eprevself(wrktets[0]);        // [p,p_i,d,e] (degenerated) [0].
            wrktets[1] = fliptets[n + i]; // [e,p,p_i,p_i+1]
            enextself(wrktets[1]);        // [p,p_i,e,p_i+1] [1]
            wrktets[2] = fliptets[i];     // [p,d,p_i,p_i+1]
            eprevself(wrktets[2]);        // [p_i,p,d,p_i+1]
            esymself(wrktets[2]);         // [p,p_i,p_i+1,d] [2]
            // flip32(wrktets, 1, 0, 0);
            flip32(wrktets, 1, &fc);
            // Save the new tet [e,d,p_i,p_i+1].         // FOR DEBUG ONLY
            fliptets[i] = wrktets[0]; // [d,e,p_i+1,p_i] // FOR DEBUG ONLY
            esymself(fliptets[i]);    // [e,d,p_i,p_i+1] // FOR DEBUG ONLY
        }
        // - Do a 4-to-1 flip on
        //     [p,p_0,e,d],     [d,e,p_0,p],
        //     [p,p_0,d,p_n-1], [e,p_n-1,p_0,p],
        //     [p,p_0,p_n-1,e], [p_0,p_n-1,d,p], and
        //     [e,d,p_n-1,p].
        //   This produces
        //     [e,d,p_n-1,p_0] and
        //     deletes p.
        wrktets[3] = wrktets[1];          // [e,d,p_n-1,p] (degenerated) [3]
        wrktets[0] = fliptets[n];         // [e,d,p,p_0] (degenerated)
        eprevself(wrktets[0]);            // [p,e,d,p_0] (...)
        esymself(wrktets[0]);             // [e,p,p_0,d] (...)
        enextself(wrktets[0]);            // [p,p_0,e,d] (degenerated) [0]
        wrktets[1] = fliptets[n - 1];     // [p,d,p_n-1,p_0]
        esymself(wrktets[1]);             // [d,p,p_0,p_n-1]
        enextself(wrktets[1]);            // [p,p_0,d,p_n-1] [1]
        wrktets[2] = fliptets[2 * n - 1]; // [e,p,p_n-1,p_0]
        enextself(wrktets[2]);            // [p_p_n-1,e,p_0]
        esymself(wrktets[2]);             // [p_n-1,p,p_0,e]
        enextself(wrktets[2]);            // [p,p_0,p_n-1,e] [2]
        // flip41(wrktets, 1, 0, 0);
        flip41(wrktets, 1, &fc);
        // Save the new tet [e,d,p_n-1,p_0]             // FOR DEBUG ONLY
        fliptets[n - 1] = wrktets[0]; // [e,d,p_n-1,p_0] // FOR DEBUG ONLY
                                      // recenttet = fliptets[0];
    }

    delete[] fliptets;

    if (vt == FREESEGVERTEX) {
        // Remove the vertex from the surface mesh.
        //   This will re-create the segment [lpt, rpt] and re-triangulate
        //   all the facets at the segment.
        // Only do lawson flip when subfaces are not recovery yet.
        slawson = (checksubfaceflag ? 0 : 1);
        spivot(rightseg, parentsh); // 'rightseg' has p as its origin.
        sremovevertex(steinerpt, &parentsh, &rightseg, slawson);

        // The original segment is returned in 'rightseg'.
        rightseg.shver = 0;
        // Insert the new segment.
        point2tetorg(lpt, searchtet);
        finddirection(&searchtet, rpt);
        sstbond1(rightseg, searchtet);
        spintet = searchtet;
        while (1) {
            tssbond1(spintet, rightseg);
            fnextself(spintet);
            if (spintet.tet == searchtet.tet) break;
        }

        if (checksubfaceflag) {
            // Insert subfaces at segment [lpt,rpt] into the tetrahedralization.
            spivot(rightseg, parentsh);
            if (parentsh.sh != NULL) {
                spinsh = parentsh;
                while (1) {
                    if (sorg(spinsh) != lpt) {
                        sesymself(spinsh);
                    }
                    apexpt = sapex(spinsh);
                    // Find the adjacent tet of [lpt,rpt,apexpt];
                    spintet = searchtet;
                    while (1) {
                        if (apex(spintet) == apexpt) {
                            tsbond(spintet, spinsh);
                            sesymself(spinsh); // Get to another side of this face.
                            fsym(spintet, neightet);
                            tsbond(neightet, spinsh);
                            sesymself(spinsh); // Get back to the original side.
                            break;
                        }
                        fnextself(spintet);
                    }
                    spivotself(spinsh);
                    if (spinsh.sh == parentsh.sh) break;
                }
            }
        } // if (checksubfaceflag)

        // Clear the set of new subfaces.
        caveshbdlist->restart();
    } // if (vt == FREESEGVERTEX)

    // The point has been removed.
    if (pointtype(steinerpt) != UNUSEDVERTEX) {
        setpointtype(steinerpt, UNUSEDVERTEX);
        unuverts++;
    }
    if (vt != VOLVERTEX) {
        // Update the correspinding counters.
        if (vt == FREESEGVERTEX) {
            st_segref_count--;
        } else if (vt == FREEFACETVERTEX) {
            st_facref_count--;
        } else if (vt == FREEVOLVERTEX) {
            st_volref_count--;
        }
        if (steinerleft > 0) steinerleft++;
    }

    return 1;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// suppressbdrysteinerpoint()    Suppress a boundary Steiner point           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::suppressbdrysteinerpoint(point steinerpt) {
    face parentsh, spinsh, *parysh;
    face leftseg, rightseg;
    point lpt = NULL, rpt = NULL;
    int i;

    verttype vt = pointtype(steinerpt);

    if (vt == FREESEGVERTEX) {
        sdecode(point2sh(steinerpt), leftseg);
        leftseg.shver = 0;
        if (sdest(leftseg) == steinerpt) {
            senext(leftseg, rightseg);
            spivotself(rightseg);
            rightseg.shver = 0;
        } else {
            rightseg = leftseg;
            senext2(rightseg, leftseg);
            spivotself(leftseg);
            leftseg.shver = 0;
        }
        lpt = sorg(leftseg);
        rpt = sdest(rightseg);
        if (b->verbose > 2) {
            printf("      Suppressing Steiner point %d in segment (%d, %d).\n",
                   pointmark(steinerpt), pointmark(lpt), pointmark(rpt));
        }
        // Get all subfaces at the left segment [lpt, steinerpt].
        spivot(leftseg, parentsh);
        if (parentsh.sh != NULL) {
            // It is not a dangling segment.
            spinsh = parentsh;
            while (1) {
                cavesegshlist->newindex((void**)&parysh);
                *parysh = spinsh;
                // Orient the face consistently.
                if (sorg(*parysh) != sorg(parentsh)) sesymself(*parysh);
                spivotself(spinsh);
                if (spinsh.sh == NULL) break;
                if (spinsh.sh == parentsh.sh) break;
            }
        }
        if (cavesegshlist->objects < 2) {
            // It is a single segment. Not handle it yet.
            cavesegshlist->restart();
            return 0;
        }
    } else if (vt == FREEFACETVERTEX) {
        if (b->verbose > 2) {
            printf("      Suppressing Steiner point %d from facet.\n", pointmark(steinerpt));
        }
        sdecode(point2sh(steinerpt), parentsh);
        // A facet Steiner point. There are exactly two sectors.
        for (i = 0; i < 2; i++) {
            cavesegshlist->newindex((void**)&parysh);
            *parysh = parentsh;
            sesymself(parentsh);
        }
    } else {
        return 0;
    }

    triface searchtet, neightet, *parytet;
    point pa, pb, pc, pd;
    REAL v1[3], v2[3], len, u;

    REAL startpt[3] =
        {
            0,
        },
         samplept[3] =
             {
                 0,
             },
         candpt[3] = {
             0,
         };
    REAL ori, minvol, smallvol;
    int samplesize;
    int it, j, k;

    int n = (int)cavesegshlist->objects;
    point* newsteiners = new point[n];
    for (i = 0; i < n; i++)
        newsteiners[i] = NULL;

    // Search for each sector an interior vertex.
    for (i = 0; i < cavesegshlist->objects; i++) {
        parysh = (face*)fastlookup(cavesegshlist, i);
        stpivot(*parysh, searchtet);
        // Skip it if it is outside.
        if (ishulltet(searchtet)) continue;
        // Get the "half-ball". Tets in 'cavetetlist' all contain 'steinerpt' as
        //   opposite.  Subfaces in 'caveshlist' all contain 'steinerpt' as apex.
        //   Moreover, subfaces are oriented towards the interior of the ball.
        setpoint2tet(steinerpt, encode(searchtet));
        getvertexstar(0, steinerpt, cavetetlist, NULL, caveshlist);
        // Calculate the searching vector.
        pa = sorg(*parysh);
        pb = sdest(*parysh);
        pc = sapex(*parysh);
        facenormal(pa, pb, pc, v1, 1, NULL);
        len = sqrt(dot(v1, v1));
        v1[0] /= len;
        v1[1] /= len;
        v1[2] /= len;
        if (vt == FREESEGVERTEX) {
            parysh = (face*)fastlookup(cavesegshlist, (i + 1) % n);
            pd = sapex(*parysh);
            facenormal(pb, pa, pd, v2, 1, NULL);
            len = sqrt(dot(v2, v2));
            v2[0] /= len;
            v2[1] /= len;
            v2[2] /= len;
            // Average the two vectors.
            v1[0] = 0.5 * (v1[0] + v2[0]);
            v1[1] = 0.5 * (v1[1] + v2[1]);
            v1[2] = 0.5 * (v1[2] + v2[2]);
        }
        // Search the intersection of the ray starting from 'steinerpt' to
        //   the search direction 'v1' and the shell of the half-ball.
        // - Construct an endpoint.
        len = distance(pa, pb);
        v2[0] = steinerpt[0] + len * v1[0];
        v2[1] = steinerpt[1] + len * v1[1];
        v2[2] = steinerpt[2] + len * v1[2];
        for (j = 0; j < cavetetlist->objects; j++) {
            parytet = (triface*)fastlookup(cavetetlist, j);
            pa = org(*parytet);
            pb = dest(*parytet);
            pc = apex(*parytet);
            // Test if the ray startpt->v2 lies in the cone: where 'steinerpt'
            //   is the apex, and three sides are defined by the triangle
            //   [pa, pb, pc].
            ori = orient3d(steinerpt, pa, pb, v2);
            if (ori >= 0) {
                ori = orient3d(steinerpt, pb, pc, v2);
                if (ori >= 0) {
                    ori = orient3d(steinerpt, pc, pa, v2);
                    if (ori >= 0) {
                        // Found! Calculate the intersection.
                        planelineint(pa, pb, pc, steinerpt, v2, startpt, &u);
                        break;
                    }
                }
            }
        } // j
        if (j == cavetetlist->objects) {
            break; // There is no intersection!! Debug is needed.
        }
        // Close the ball by adding the subfaces.
        for (j = 0; j < caveshlist->objects; j++) {
            parysh = (face*)fastlookup(caveshlist, j);
            stpivot(*parysh, neightet);
            cavetetlist->newindex((void**)&parytet);
            *parytet = neightet;
        }
        // Search a best point inside the segment [startpt, steinerpt].
        it = 0;
        samplesize = 100;
        v1[0] = steinerpt[0] - startpt[0];
        v1[1] = steinerpt[1] - startpt[1];
        v1[2] = steinerpt[2] - startpt[2];
        minvol = -1.0;
        while (it < 3) {
            for (j = 1; j < samplesize - 1; j++) {
                samplept[0] = startpt[0] + ((REAL)j / (REAL)samplesize) * v1[0];
                samplept[1] = startpt[1] + ((REAL)j / (REAL)samplesize) * v1[1];
                samplept[2] = startpt[2] + ((REAL)j / (REAL)samplesize) * v1[2];
                // Find the minimum volume for 'samplept'.
                smallvol = -1;
                for (k = 0; k < cavetetlist->objects; k++) {
                    parytet = (triface*)fastlookup(cavetetlist, k);
                    pa = org(*parytet);
                    pb = dest(*parytet);
                    pc = apex(*parytet);
                    ori = orient3d(pb, pa, pc, samplept);
                    {
                        // [2017-10-15] Rounding
                        REAL lab = distance(pa, pb);
                        REAL lbc = distance(pb, pc);
                        REAL lca = distance(pc, pa);
                        REAL lv = (lab + lbc + lca) / 3.0;
                        REAL l3 = lv * lv * lv;
                        if (fabs(ori) / l3 < 1e-8) ori = 0.0;
                    }
                    if (ori <= 0) {
                        break; // An invalid tet.
                    }
                    if (smallvol == -1) {
                        smallvol = ori;
                    } else {
                        if (ori < smallvol) smallvol = ori;
                    }
                } // k
                if (k == cavetetlist->objects) {
                    // Found a valid point. Remember it.
                    if (minvol == -1.0) {
                        candpt[0] = samplept[0];
                        candpt[1] = samplept[1];
                        candpt[2] = samplept[2];
                        minvol = smallvol;
                    } else {
                        if (minvol < smallvol) {
                            // It is a better location. Remember it.
                            candpt[0] = samplept[0];
                            candpt[1] = samplept[1];
                            candpt[2] = samplept[2];
                            minvol = smallvol;
                        } else {
                            // No improvement of smallest volume.
                            // Since we are searching along the line [startpt, steinerpy],
                            // The smallest volume can only be decreased later.
                            break;
                        }
                    }
                }
            } // j
            if (minvol > 0) break;
            samplesize *= 10;
            it++;
        } // while (it < 3)
        if (minvol == -1.0) {
            // Failed to find a valid point.
            cavetetlist->restart();
            caveshlist->restart();
            break;
        }
        // Create a new Steiner point inside this section.
        makepoint(&(newsteiners[i]), FREEVOLVERTEX);
        newsteiners[i][0] = candpt[0];
        newsteiners[i][1] = candpt[1];
        newsteiners[i][2] = candpt[2];
        cavetetlist->restart();
        caveshlist->restart();
    } // i

    if (i < cavesegshlist->objects) {
        // Failed to suppress the vertex.
        for (; i > 0; i--) {
            if (newsteiners[i - 1] != NULL) {
                pointdealloc(newsteiners[i - 1]);
            }
        }
        delete[] newsteiners;
        cavesegshlist->restart();
        return 0;
    }

    // Remove p from the segment or the facet.
    triface newtet, newface, spintet;
    face newsh, neighsh;
    face *splitseg, checkseg;
    int slawson = 0; // Do not do flip afterword.
    int t1ver;

    if (vt == FREESEGVERTEX) {
        // Detach 'leftseg' and 'rightseg' from their adjacent tets.
        //   These two subsegments will be deleted.
        sstpivot1(leftseg, neightet);
        spintet = neightet;
        while (1) {
            tssdissolve1(spintet);
            fnextself(spintet);
            if (spintet.tet == neightet.tet) break;
        }
        sstpivot1(rightseg, neightet);
        spintet = neightet;
        while (1) {
            tssdissolve1(spintet);
            fnextself(spintet);
            if (spintet.tet == neightet.tet) break;
        }
    }

    // Loop through all sectors bounded by facets at this segment.
    //   Within each sector, create a new Steiner point 'np', and replace 'p'
    //   by 'np' for all tets in this sector.
    for (i = 0; i < cavesegshlist->objects; i++) {
        parysh = (face*)fastlookup(cavesegshlist, i);
        // 'parysh' is the face [lpt, steinerpt, #].
        stpivot(*parysh, neightet);
        // Get all tets in this sector.
        setpoint2tet(steinerpt, encode(neightet));
        getvertexstar(0, steinerpt, cavetetlist, NULL, caveshlist);
        if (!ishulltet(neightet)) {
            // Within each tet in the ball, replace 'p' by 'np'.
            for (j = 0; j < cavetetlist->objects; j++) {
                parytet = (triface*)fastlookup(cavetetlist, j);
                setoppo(*parytet, newsteiners[i]);
            } // j
            // Point to a parent tet.
            parytet = (triface*)fastlookup(cavetetlist, 0);
            setpoint2tet(newsteiners[i], (tetrahedron)(parytet->tet));
            st_volref_count++;
            if (steinerleft > 0) steinerleft--;
        }
        // Disconnect the set of boundary faces. They're temporarily open faces.
        //   They will be connected to the new tets after 'p' is removed.
        for (j = 0; j < caveshlist->objects; j++) {
            // Get a boundary face.
            parysh = (face*)fastlookup(caveshlist, j);
            stpivot(*parysh, neightet);
            // assert(apex(neightet) == newpt);
            // Clear the connection at this face.
            dissolve(neightet);
            tsdissolve(neightet);
        }
        // Clear the working lists.
        cavetetlist->restart();
        caveshlist->restart();
    } // i
    cavesegshlist->restart();

    if (vt == FREESEGVERTEX) {
        spivot(rightseg, parentsh); // 'rightseg' has p as its origin.
        splitseg = &rightseg;
    } else {
        if (sdest(parentsh) == steinerpt) {
            senextself(parentsh);
        } else if (sapex(parentsh) == steinerpt) {
            senext2self(parentsh);
        }
        splitseg = NULL;
    }
    sremovevertex(steinerpt, &parentsh, splitseg, slawson);

    if (vt == FREESEGVERTEX) {
        // The original segment is returned in 'rightseg'.
        rightseg.shver = 0;
    }

    // For each new subface, create two new tets at each side of it.
    //   Both of the two new tets have its opposite be dummypoint.
    for (i = 0; i < caveshbdlist->objects; i++) {
        parysh = (face*)fastlookup(caveshbdlist, i);
        sinfect(*parysh); // Mark it for connecting new tets.
        newsh = *parysh;
        pa = sorg(newsh);
        pb = sdest(newsh);
        pc = sapex(newsh);
        maketetrahedron(&newtet);
        maketetrahedron(&neightet);
        setvertices(newtet, pa, pb, pc, dummypoint);
        setvertices(neightet, pb, pa, pc, dummypoint);
        bond(newtet, neightet);
        tsbond(newtet, newsh);
        sesymself(newsh);
        tsbond(neightet, newsh);
    }
    // Temporarily increase the hullsize.
    hullsize += (caveshbdlist->objects * 2l);

    if (vt == FREESEGVERTEX) {
        // Connecting new tets at the recovered segment.
        spivot(rightseg, parentsh);
        spinsh = parentsh;
        while (1) {
            if (sorg(spinsh) != lpt) sesymself(spinsh);
            // Get the new tet at this subface.
            stpivot(spinsh, newtet);
            tssbond1(newtet, rightseg);
            // Go to the other face at this segment.
            spivot(spinsh, neighsh);
            if (sorg(neighsh) != lpt) sesymself(neighsh);
            sesymself(neighsh);
            stpivot(neighsh, neightet);
            tssbond1(neightet, rightseg);
            sstbond1(rightseg, neightet);
            // Connecting two adjacent tets at this segment.
            esymself(newtet);
            esymself(neightet);
            // Connect the two tets (at rightseg) together.
            bond(newtet, neightet);
            // Go to the next subface.
            spivotself(spinsh);
            if (spinsh.sh == parentsh.sh) break;
        }
    }

    // Connecting new tets at new subfaces together.
    for (i = 0; i < caveshbdlist->objects; i++) {
        parysh = (face*)fastlookup(caveshbdlist, i);
        newsh = *parysh;
        // assert(sinfected(newsh));
        // Each new subface contains two new tets.
        for (k = 0; k < 2; k++) {
            stpivot(newsh, newtet);
            for (j = 0; j < 3; j++) {
                // Check if this side is open.
                esym(newtet, newface);
                if (newface.tet[newface.ver & 3] == NULL) {
                    // An open face. Connect it to its adjacent tet.
                    sspivot(newsh, checkseg);
                    if (checkseg.sh != NULL) {
                        // A segment. It must not be the recovered segment.
                        tssbond1(newtet, checkseg);
                        sstbond1(checkseg, newtet);
                    }
                    spivot(newsh, neighsh);
                    if (neighsh.sh != NULL) {
                        // The adjacent subface exists. It's not a dangling segment.
                        if (sorg(neighsh) != sdest(newsh)) sesymself(neighsh);
                        stpivot(neighsh, neightet);
                        if (sinfected(neighsh)) {
                            esymself(neightet);
                        } else {
                            // Search for an open face at this edge.
                            spintet = neightet;
                            while (1) {
                                esym(spintet, searchtet);
                                fsym(searchtet, spintet);
                                if (spintet.tet == NULL) break;
                            }
                            // Found an open face at 'searchtet'.
                            neightet = searchtet;
                        }
                    } else {
                        // The edge (at 'newsh') is a dangling segment.
                        // Get an adjacent tet at this segment.
                        sstpivot1(checkseg, neightet);
                        if (org(neightet) != sdest(newsh)) esymself(neightet);
                        // Search for an open face at this edge.
                        spintet = neightet;
                        while (1) {
                            esym(spintet, searchtet);
                            fsym(searchtet, spintet);
                            if (spintet.tet == NULL) break;
                        }
                        // Found an open face at 'searchtet'.
                        neightet = searchtet;
                    }
                    pc = apex(newface);
                    if (apex(neightet) == steinerpt) {
                        // Exterior case. The 'neightet' is a hull tet which contain
                        //   'steinerpt'. It will be deleted after 'steinerpt' is removed.
                        caveoldtetlist->newindex((void**)&parytet);
                        *parytet = neightet;
                        // Connect newface to the adjacent hull tet of 'neightet', which
                        //   has the same edge as 'newface', and does not has 'steinerpt'.
                        fnextself(neightet);
                    } else {
                        if (pc == dummypoint) {
                            if (apex(neightet) != dummypoint) {
                                setapex(newface, apex(neightet));
                                // A hull tet has turned into an interior tet.
                                hullsize--; // Must update the hullsize.
                            }
                        }
                    }
                    bond(newface, neightet);
                } // if (newface.tet[newface.ver & 3] == NULL)
                enextself(newtet);
                senextself(newsh);
            } // j
            sesymself(newsh);
        } // k
    }     // i

    // Unmark all new subfaces.
    for (i = 0; i < caveshbdlist->objects; i++) {
        parysh = (face*)fastlookup(caveshbdlist, i);
        suninfect(*parysh);
    }
    caveshbdlist->restart();

    if (caveoldtetlist->objects > 0l) {
        // Delete hull tets which contain 'steinerpt'.
        for (i = 0; i < caveoldtetlist->objects; i++) {
            parytet = (triface*)fastlookup(caveoldtetlist, i);
            tetrahedrondealloc(parytet->tet);
        }
        // Must update the hullsize.
        hullsize -= caveoldtetlist->objects;
        caveoldtetlist->restart();
    }

    setpointtype(steinerpt, UNUSEDVERTEX);
    unuverts++;
    if (vt == FREESEGVERTEX) {
        st_segref_count--;
    } else { // vt == FREEFACETVERTEX
        st_facref_count--;
    }
    if (steinerleft > 0) steinerleft++; // We've removed a Steiner points.

    point* parypt;
    int steinercount = 0;

    int bak_fliplinklevel = b->fliplinklevel;
    b->fliplinklevel = 100000; // Unlimited flip level.

    // Try to remove newly added Steiner points.
    for (i = 0; i < n; i++) {
        if (newsteiners[i] != NULL) {
            if (!removevertexbyflips(newsteiners[i])) {
                if (b->supsteiner_level > 0) { // Not -Y/0
                    // Save it in subvertstack for removal.
                    subvertstack->newindex((void**)&parypt);
                    *parypt = newsteiners[i];
                }
                steinercount++;
            }
        }
    }

    b->fliplinklevel = bak_fliplinklevel;

    if (steinercount > 0) {
        if (b->verbose > 2) {
            printf("      Added %d interior Steiner points.\n", steinercount);
        }
    }

    delete[] newsteiners;

    return 1;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// suppresssteinerpoints()    Suppress Steiner points.                       //
//                                                                           //
// All Steiner points have been saved in 'subvertstack' in the routines      //
// carveholes() and suppresssteinerpoint().                                  //
// Each Steiner point is either removed or shifted into the interior.        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::suppresssteinerpoints() {

    if (!b->quiet) {
        printf("Suppressing Steiner points ...\n");
    }

    point rempt, *parypt;

    int bak_fliplinklevel = b->fliplinklevel;
    b->fliplinklevel = 100000; // Unlimited flip level.
    int suppcount = 0, remcount = 0;
    int i;

    // Try to suppress boundary Steiner points.
    for (i = 0; i < subvertstack->objects; i++) {
        parypt = (point*)fastlookup(subvertstack, i);
        rempt = *parypt;
        if (pointtype(rempt) != UNUSEDVERTEX) {
            if ((pointtype(rempt) == FREESEGVERTEX) || (pointtype(rempt) == FREEFACETVERTEX)) {
                if (suppressbdrysteinerpoint(rempt)) {
                    suppcount++;
                }
            }
        }
    } // i

    if (suppcount > 0) {
        if (b->verbose) {
            printf("  Suppressed %d boundary Steiner points.\n", suppcount);
        }
    }

    if (b->supsteiner_level > 0) { // -Y/1
        for (i = 0; i < subvertstack->objects; i++) {
            parypt = (point*)fastlookup(subvertstack, i);
            rempt = *parypt;
            if (pointtype(rempt) != UNUSEDVERTEX) {
                if (pointtype(rempt) == FREEVOLVERTEX) {
                    if (removevertexbyflips(rempt)) {
                        remcount++;
                    }
                }
            }
        }
    }

    if (remcount > 0) {
        if (b->verbose) {
            printf("  Removed %d interior Steiner points.\n", remcount);
        }
    }

    b->fliplinklevel = bak_fliplinklevel;

    if (b->supsteiner_level > 1) { // -Y/2
        // Smooth interior Steiner points.
        optparameters opm;
        triface* parytet;
        point* ppt;
        REAL ori;
        int smtcount, count, ivcount;
        int nt, j;

        // Point smooth options.
        opm.max_min_volume = 1;
        opm.numofsearchdirs = 20;
        opm.searchstep = 0.001;
        opm.maxiter = 30; // Limit the maximum iterations.

        smtcount = 0;

        do {

            nt = 0;

            while (1) {
                count = 0;
                ivcount = 0; // Clear the inverted count.

                for (i = 0; i < subvertstack->objects; i++) {
                    parypt = (point*)fastlookup(subvertstack, i);
                    rempt = *parypt;
                    if (pointtype(rempt) == FREEVOLVERTEX) {
                        getvertexstar(1, rempt, cavetetlist, NULL, NULL);
                        // Calculate the initial smallest volume (maybe zero or negative).
                        for (j = 0; j < cavetetlist->objects; j++) {
                            parytet = (triface*)fastlookup(cavetetlist, j);
                            ppt = (point*)&(parytet->tet[4]);
                            ori = orient3dfast(ppt[1], ppt[0], ppt[2], ppt[3]);
                            if (j == 0) {
                                opm.initval = ori;
                            } else {
                                if (opm.initval > ori) opm.initval = ori;
                            }
                        }
                        if (smoothpoint(rempt, cavetetlist, 1, &opm)) {
                            count++;
                        }
                        if (opm.imprval <= 0.0) {
                            ivcount++; // The mesh contains inverted elements.
                        }
                        cavetetlist->restart();
                    }
                } // i

                smtcount += count;

                if (count == 0) {
                    // No point has been smoothed.
                    break;
                }

                nt++;
                if (nt > 2) {
                    break; // Already three iterations.
                }
            } // while

            if (ivcount > 0) {
                // There are inverted elements!
                if (opm.maxiter > 0) {
                    // Set unlimited smoothing steps. Try again.
                    opm.numofsearchdirs = 30;
                    opm.searchstep = 0.0001;
                    opm.maxiter = -1;
                    continue;
                }
            }

            break;
        } while (1); // Additional loop for (ivcount > 0)

        if (ivcount > 0) {
            printf("BUG Report!  The mesh contain inverted elements.\n");
        }

        if (b->verbose) {
            if (smtcount > 0) {
                printf("  Smoothed %d Steiner points.\n", smtcount);
            }
        }
    } // -Y2

    subvertstack->restart();

    return 1;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// recoverboundary()    Recover segments and facets.                         //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::recoverboundary(clock_t& tv) {
    arraypool *misseglist, *misshlist;
    arraypool* bdrysteinerptlist;
    face searchsh, *parysh;
    face searchseg, *paryseg;
    point rempt, *parypt;
    long ms; // The number of missing segments/subfaces.
    int nit; // The number of iterations.
    int s, i;

    // Counters.
    long bak_segref_count, bak_facref_count, bak_volref_count;

    if (!b->quiet) {
        printf("Recovering boundaries...\n");
    }

    if (b->verbose) {
        printf("  Recovering segments.\n");
    }

    // Segments will be introduced.
    checksubsegflag = 1;

    misseglist = new arraypool(sizeof(face), 8);
    bdrysteinerptlist = new arraypool(sizeof(point), 8);

    // In random order.
    subsegs->traversalinit();
    for (i = 0; i < subsegs->items; i++) {
        s = randomnation(i + 1);
        // Move the s-th seg to the i-th.
        subsegstack->newindex((void**)&paryseg);
        *paryseg = *(face*)fastlookup(subsegstack, s);
        // Put i-th seg to be the s-th.
        searchseg.sh = shellfacetraverse(subsegs);
        paryseg = (face*)fastlookup(subsegstack, s);
        *paryseg = searchseg;
    }

    // The init number of missing segments.
    ms = subsegs->items;
    nit = 0;
    if (b->fliplinklevel < 0) {
        autofliplinklevel = 1; // Init value.
    }

    // First, trying to recover segments by only doing flips.
    while (1) {
        recoversegments(misseglist, 0, 0);

        if (misseglist->objects > 0) {
            if (b->fliplinklevel >= 0) {
                break;
            } else {
                if (misseglist->objects >= ms) {
                    nit++;
                    if (nit >= 3) {
                        // break;
                        // Do the last round with unbounded flip link level.
                        b->fliplinklevel = 100000;
                    }
                } else {
                    ms = misseglist->objects;
                    if (nit > 0) {
                        nit--;
                    }
                }
                for (i = 0; i < misseglist->objects; i++) {
                    subsegstack->newindex((void**)&paryseg);
                    *paryseg = *(face*)fastlookup(misseglist, i);
                }
                misseglist->restart();
                autofliplinklevel += b->fliplinklevelinc;
            }
        } else {
            // All segments are recovered.
            break;
        }
    } // while (1)

    if (b->verbose) {
        printf("  %ld (%ld) segments are recovered (missing).\n",
               subsegs->items - misseglist->objects, misseglist->objects);
    }

    if (misseglist->objects > 0) {
        // Second, trying to recover segments by doing more flips (fullsearch).
        while (misseglist->objects > 0) {
            ms = misseglist->objects;
            for (i = 0; i < misseglist->objects; i++) {
                subsegstack->newindex((void**)&paryseg);
                *paryseg = *(face*)fastlookup(misseglist, i);
            }
            misseglist->restart();

            recoversegments(misseglist, 1, 0);

            if (misseglist->objects < ms) {
                // The number of missing segments is reduced.
                continue;
            } else {
                break;
            }
        }
        if (b->verbose) {
            printf("  %ld (%ld) segments are recovered (missing).\n",
                   subsegs->items - misseglist->objects, misseglist->objects);
        }
    }

    if (misseglist->objects > 0) {
        // Third, trying to recover segments by doing more flips (fullsearch)
        //   and adding Steiner points in the volume.
        while (misseglist->objects > 0) {
            ms = misseglist->objects;
            for (i = 0; i < misseglist->objects; i++) {
                subsegstack->newindex((void**)&paryseg);
                *paryseg = *(face*)fastlookup(misseglist, i);
            }
            misseglist->restart();

            recoversegments(misseglist, 1, 1);

            if (misseglist->objects < ms) {
                // The number of missing segments is reduced.
                continue;
            } else {
                break;
            }
        }
        if (b->verbose) {
            printf("  Added %ld Steiner points in volume.\n", st_volref_count);
        }
    }

    if (misseglist->objects > 0) {
        // Last, trying to recover segments by doing more flips (fullsearch),
        //   and adding Steiner points in the volume, and splitting segments.
        long bak_inpoly_count = st_volref_count; // st_inpoly_count;
        for (i = 0; i < misseglist->objects; i++) {
            subsegstack->newindex((void**)&paryseg);
            *paryseg = *(face*)fastlookup(misseglist, i);
        }
        misseglist->restart();

        recoversegments(misseglist, 1, 2);

        if (b->verbose) {
            printf("  Added %ld Steiner points in segments.\n", st_segref_count);
            if (st_volref_count > bak_inpoly_count) {
                printf("  Added another %ld Steiner points in volume.\n",
                       st_volref_count - bak_inpoly_count);
            }
        }
    }

    if (st_segref_count > 0) {
        // Try to remove the Steiner points added in segments.
        bak_segref_count = st_segref_count;
        bak_volref_count = st_volref_count;
        for (i = 0; i < subvertstack->objects; i++) {
            // Get the Steiner point.
            parypt = (point*)fastlookup(subvertstack, i);
            rempt = *parypt;
            if (!removevertexbyflips(rempt)) {
                // Save it in list.
                bdrysteinerptlist->newindex((void**)&parypt);
                *parypt = rempt;
            }
        }
        if (b->verbose) {
            if (st_segref_count < bak_segref_count) {
                if (bak_volref_count < st_volref_count) {
                    printf("  Suppressed %ld Steiner points in segments.\n",
                           st_volref_count - bak_volref_count);
                }
                if ((st_segref_count + (st_volref_count - bak_volref_count)) < bak_segref_count) {
                    printf("  Removed %ld Steiner points in segments.\n",
                           bak_segref_count -
                               (st_segref_count + (st_volref_count - bak_volref_count)));
                }
            }
        }
        subvertstack->restart();
    }

    tv = clock();

    if (b->verbose) {
        printf("  Recovering facets.\n");
    }

    // Subfaces will be introduced.
    checksubfaceflag = 1;

    misshlist = new arraypool(sizeof(face), 8);

    // Randomly order the subfaces.
    subfaces->traversalinit();
    for (i = 0; i < subfaces->items; i++) {
        s = randomnation(i + 1);
        // Move the s-th subface to the i-th.
        subfacstack->newindex((void**)&parysh);
        *parysh = *(face*)fastlookup(subfacstack, s);
        // Put i-th subface to be the s-th.
        searchsh.sh = shellfacetraverse(subfaces);
        parysh = (face*)fastlookup(subfacstack, s);
        *parysh = searchsh;
    }

    ms = subfaces->items;
    nit = 0;
    b->fliplinklevel = -1; // Init.
    if (b->fliplinklevel < 0) {
        autofliplinklevel = 1; // Init value.
    }

    while (1) {
        recoversubfaces(misshlist, 0);

        if (misshlist->objects > 0) {
            if (b->fliplinklevel >= 0) {
                break;
            } else {
                if (misshlist->objects >= ms) {
                    nit++;
                    if (nit >= 3) {
                        // break;
                        // Do the last round with unbounded flip link level.
                        b->fliplinklevel = 100000;
                    }
                } else {
                    ms = misshlist->objects;
                    if (nit > 0) {
                        nit--;
                    }
                }
                for (i = 0; i < misshlist->objects; i++) {
                    subfacstack->newindex((void**)&parysh);
                    *parysh = *(face*)fastlookup(misshlist, i);
                }
                misshlist->restart();
                autofliplinklevel += b->fliplinklevelinc;
            }
        } else {
            // All subfaces are recovered.
            break;
        }
    } // while (1)

    if (b->verbose) {
        printf("  %ld (%ld) subfaces are recovered (missing).\n",
               subfaces->items - misshlist->objects, misshlist->objects);
    }

    if (misshlist->objects > 0) {
        // There are missing subfaces. Add Steiner points.
        for (i = 0; i < misshlist->objects; i++) {
            subfacstack->newindex((void**)&parysh);
            *parysh = *(face*)fastlookup(misshlist, i);
        }
        misshlist->restart();

        recoversubfaces(NULL, 1);

        if (b->verbose) {
            printf("  Added %ld Steiner points in facets.\n", st_facref_count);
        }
    }

    if (st_facref_count > 0) {
        // Try to remove the Steiner points added in facets.
        bak_facref_count = st_facref_count;
        for (i = 0; i < subvertstack->objects; i++) {
            // Get the Steiner point.
            parypt = (point*)fastlookup(subvertstack, i);
            rempt = *parypt;
            if (!removevertexbyflips(*parypt)) {
                // Save it in list.
                bdrysteinerptlist->newindex((void**)&parypt);
                *parypt = rempt;
            }
        }
        if (b->verbose) {
            if (st_facref_count < bak_facref_count) {
                printf("  Removed %ld Steiner points in facets.\n",
                       bak_facref_count - st_facref_count);
            }
        }
        subvertstack->restart();
    }

    if (bdrysteinerptlist->objects > 0) {
        if (b->verbose) {
            printf("  %ld Steiner points remained in boundary.\n", bdrysteinerptlist->objects);
        }
    } // if

    // Accumulate the dynamic memory.
    totalworkmemory +=
        (misseglist->totalmemory + misshlist->totalmemory + bdrysteinerptlist->totalmemory);

    delete bdrysteinerptlist;
    delete misseglist;
    delete misshlist;
}

////                                                                       ////
////                                                                       ////
//// steiner_cxx //////////////////////////////////////////////////////////////

//// reconstruct_cxx //////////////////////////////////////////////////////////
////                                                                       ////
////                                                                       ////

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// carveholes()    Remove tetrahedra not in the mesh domain.                 //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::carveholes() {
    arraypool *tetarray, *hullarray;
    triface tetloop, neightet, *parytet, *parytet1;
    triface* regiontets = NULL;
    face checksh, *parysh;
    face checkseg;
    point ptloop, *parypt;
    int t1ver;
    int i, j, k;

    if (!b->quiet) {
        if (b->convex) {
            printf("Marking exterior tetrahedra ...\n");
        } else {
            printf("Removing exterior tetrahedra ...\n");
        }
    }

    // Initialize the pool of exterior tets.
    tetarray = new arraypool(sizeof(triface), 10);
    hullarray = new arraypool(sizeof(triface), 10);

    // Collect unprotected tets and hull tets.
    tetrahedrons->traversalinit();
    tetloop.ver = 11; // The face opposite to dummypoint.
    tetloop.tet = alltetrahedrontraverse();
    while (tetloop.tet != (tetrahedron*)NULL) {
        if (ishulltet(tetloop)) {
            // Is this side protected by a subface?
            if (!issubface(tetloop)) {
                // Collect an unprotected hull tet and tet.
                infect(tetloop);
                hullarray->newindex((void**)&parytet);
                *parytet = tetloop;
                // tetloop's face number is 11 & 3 = 3.
                decode(tetloop.tet[3], neightet);
                if (!infected(neightet)) {
                    infect(neightet);
                    tetarray->newindex((void**)&parytet);
                    *parytet = neightet;
                }
            }
        }
        tetloop.tet = alltetrahedrontraverse();
    }

    if (in->numberofholes > 0) {
        // Mark as infected any tets inside volume holes.
        for (i = 0; i < 3 * in->numberofholes; i += 3) {
            // Search a tet containing the i-th hole point.
            neightet.tet = NULL;
            randomsample(&(in->holelist[i]), &neightet);
            if (locate(&(in->holelist[i]), &neightet) != OUTSIDE) {
                // The tet 'neightet' contain this point.
                if (!infected(neightet)) {
                    infect(neightet);
                    tetarray->newindex((void**)&parytet);
                    *parytet = neightet;
                    // Add its adjacent tet if it is not protected.
                    if (!issubface(neightet)) {
                        decode(neightet.tet[neightet.ver & 3], tetloop);
                        if (!infected(tetloop)) {
                            infect(tetloop);
                            if (ishulltet(tetloop)) {
                                hullarray->newindex((void**)&parytet);
                            } else {
                                tetarray->newindex((void**)&parytet);
                            }
                            *parytet = tetloop;
                        }
                    } else {
                        // It is protected. Check if its adjacent tet is a hull tet.
                        decode(neightet.tet[neightet.ver & 3], tetloop);
                        if (ishulltet(tetloop)) {
                            // It is hull tet, add it into the list. Moreover, the subface
                            //   is dead, i.e., both sides are in exterior.
                            if (!infected(tetloop)) {
                                infect(tetloop);
                                hullarray->newindex((void**)&parytet);
                                *parytet = tetloop;
                            }
                        }
                        if (infected(tetloop)) {
                            // Both sides of this subface are in exterior.
                            tspivot(neightet, checksh);
                            sinfect(checksh); // Only queue it once.
                            subfacstack->newindex((void**)&parysh);
                            *parysh = checksh;
                        }
                    }
                } // if (!infected(neightet))
            } else {
                // A hole point locates outside of the convex hull.
                if (!b->quiet) {
                    printf("Warning:  The %d-th hole point ", i / 3 + 1);
                    printf("lies outside the convex hull.\n");
                }
            }
        } // i
    }     // if (in->numberofholes > 0)

    if (b->hole_mesh && (b->hole_mesh_filename[0] != 0)) {
        // A hole mesh (***.ele) is given.
        // enum tetgenbehavior::objecttype object;
        char filebasename[256];
        strcpy(filebasename, b->hole_mesh_filename);
        // object = tetgenbehavior::MESH;
        if (!strcmp(&filebasename[strlen(filebasename) - 4], ".ele")) {
            filebasename[strlen(filebasename) - 4] = '\0';
            // object = tetgenbehavior::MESH;
        }
        bool hole_mesh_loaded = false;
        tetgenio io;
        if (io.load_node(filebasename)) {
            if (io.load_tet(filebasename)) {
                hole_mesh_loaded = true;
            }
        }
        if (hole_mesh_loaded) {
            if (b->verbose) {
                printf("  Adding hole tets from the mesh %s\n", b->hole_mesh_filename);
            }
            int count = 0, hcount = 0, scount = 0;
            int shift = io.firstnumber > 0 ? -1 : 0;
            double *p1, *p2, *p3, *p4;
            double searchpt[3];
            for (i = 0; i < io.numberoftetrahedra; i++) {
                int* idx = &(io.tetrahedronlist[i * 4]);
                p1 = &(io.pointlist[(idx[0] + shift) * 3]);
                p2 = &(io.pointlist[(idx[1] + shift) * 3]);
                p3 = &(io.pointlist[(idx[2] + shift) * 3]);
                p4 = &(io.pointlist[(idx[3] + shift) * 3]);
                for (j = 0; j < 3; j++) {
                    searchpt[j] = (p1[j] + p2[j] + p3[j] + p4[j]) / 4.;
                }
                // Search the point.
                neightet.tet = NULL;
                if (locate(searchpt, &neightet) != OUTSIDE) {
                    // The tet 'neightet' contain this point.
                    if (!infected(neightet)) {
                        infect(neightet);
                        tetarray->newindex((void**)&parytet);
                        *parytet = neightet;
                        count++;
                        // Add its adjacent tet if it is not protected.
                        if (!issubface(neightet)) {
                            decode(neightet.tet[neightet.ver & 3], tetloop);
                            if (!infected(tetloop)) {
                                infect(tetloop);
                                if (ishulltet(tetloop)) {
                                    hullarray->newindex((void**)&parytet);
                                    hcount++;
                                } else {
                                    tetarray->newindex((void**)&parytet);
                                    count++;
                                }
                                *parytet = tetloop;
                            }
                        } else {
                            // It is protected. Check if its adjacent tet is a hull tet.
                            decode(neightet.tet[neightet.ver & 3], tetloop);
                            if (ishulltet(tetloop)) {
                                // It is hull tet, add it into the list. Moreover, the subface
                                //   is dead, i.e., both sides are in exterior.
                                if (!infected(tetloop)) {
                                    infect(tetloop);
                                    hullarray->newindex((void**)&parytet);
                                    *parytet = tetloop;
                                    hcount++;
                                }
                            }
                            if (infected(tetloop)) {
                                // Both sides of this subface are in exterior.
                                tspivot(neightet, checksh);
                                sinfect(checksh); // Only queue it once.
                                subfacstack->newindex((void**)&parysh);
                                *parysh = checksh;
                                scount++;
                            }
                        }
                    }
                }
            } // i
            if (b->verbose) {
                printf("    Added %d hole tets, %d hull tet, %d hole subfaces\n", count, hcount,
                       scount);
            }
        } // if (hole_mesh_loaded)
    }

    if (b->regionattrib && (in->numberofregions > 0)) { // -A option.
        // Record the tetrahedra that contains the region points for assigning
        //   region attributes after the holes have been carved.
        regiontets = new triface[in->numberofregions];
        // Mark as marktested any tetrahedra inside volume regions.
        for (i = 0; i < 5 * in->numberofregions; i += 5) {
            // Search a tet containing the i-th region point.
            neightet.tet = NULL;
            randomsample(&(in->regionlist[i]), &neightet);
            if (locate(&(in->regionlist[i]), &neightet) != OUTSIDE) {
                regiontets[i / 5] = neightet;
            } else {
                if (!b->quiet) {
                    printf("Warning:  The %d-th region point ", i / 5 + 1);
                    printf("lies outside the convex hull.\n");
                }
                regiontets[i / 5].tet = NULL;
            }
        }
    }

    // Collect all exterior tets (in concave place and in holes).
    for (i = 0; i < tetarray->objects; i++) {
        parytet = (triface*)fastlookup(tetarray, i);
        j = (parytet->ver & 3); // j is the current face number.
        // Check the other three adjacent tets.
        for (k = 1; k < 4; k++) {
            decode(parytet->tet[(j + k) % 4], neightet);
            // neightet may be a hull tet.
            if (!infected(neightet)) {
                // Is neightet protected by a subface.
                if (!issubface(neightet)) {
                    // Not proected. Collect it. (It must not be a hull tet).
                    infect(neightet);
                    tetarray->newindex((void**)&parytet1);
                    *parytet1 = neightet;
                } else {
                    // Protected. Check if it is a hull tet.
                    if (ishulltet(neightet)) {
                        // A hull tet. Collect it.
                        infect(neightet);
                        hullarray->newindex((void**)&parytet1);
                        *parytet1 = neightet;
                        // Both sides of this subface are exterior.
                        tspivot(neightet, checksh);
                        // Queue this subface (to be deleted later).
                        sinfect(checksh); // Only queue it once.
                        subfacstack->newindex((void**)&parysh);
                        *parysh = checksh;
                    }
                }
            } else {
                // Both sides of this face are in exterior.
                // If there is a subface. It should be collected.
                if (issubface(neightet)) {
                    tspivot(neightet, checksh);
                    if (!sinfected(checksh)) {
                        sinfect(checksh);
                        subfacstack->newindex((void**)&parysh);
                        *parysh = checksh;
                    }
                }
            }
        } // j, k
    }     // i

    if (b->regionattrib && (in->numberofregions > 0)) {
        // Re-check saved region tets to see if they lie outside.
        for (i = 0; i < in->numberofregions; i++) {
            if (infected(regiontets[i])) {
                if (b->verbose) {
                    printf("Warning:  The %d-th region point ", i + 1);
                    printf("lies in the exterior of the domain.\n");
                }
                regiontets[i].tet = NULL;
            }
        }
    }

    // Collect vertices which point to infected tets. These vertices
    //   may get deleted after the removal of exterior tets.
    //   If -Y1 option is used, collect all Steiner points for removal.
    //   The lists 'cavetetvertlist' and 'subvertstack' are re-used.
    points->traversalinit();
    ptloop = pointtraverse();
    while (ptloop != NULL) {
        if ((pointtype(ptloop) != UNUSEDVERTEX) && (pointtype(ptloop) != DUPLICATEDVERTEX)) {
            decode(point2tet(ptloop), neightet);
            if (infected(neightet)) {
                cavetetvertlist->newindex((void**)&parypt);
                *parypt = ptloop;
            }
            if (b->nobisect && (b->supsteiner_level > 0)) { // -Y/1
                // Queue it if it is a Steiner point.
                if (pointmark(ptloop) > (in->numberofpoints - (in->firstnumber ? 0 : 1))) {
                    subvertstack->newindex((void**)&parypt);
                    *parypt = ptloop;
                }
            }
        }
        ptloop = pointtraverse();
    }

    if (!b->convex && (tetarray->objects > 0l)) { // No -c option.
        // Remove exterior tets. Hull tets are updated.
        arraypool* newhullfacearray;
        triface hulltet, casface;
        face segloop, *paryseg;
        point pa, pb, pc;
        long delsegcount = 0l;

        // Collect segments which point to infected tets. Some segments
        //   may get deleted after the removal of exterior tets.
        subsegs->traversalinit();
        segloop.sh = shellfacetraverse(subsegs);
        while (segloop.sh != NULL) {
            sstpivot1(segloop, neightet);
            if (infected(neightet)) {
                subsegstack->newindex((void**)&paryseg);
                *paryseg = segloop;
            }
            segloop.sh = shellfacetraverse(subsegs);
        }

        newhullfacearray = new arraypool(sizeof(triface), 10);

        // Create and save new hull tets.
        for (i = 0; i < tetarray->objects; i++) {
            parytet = (triface*)fastlookup(tetarray, i);
            for (j = 0; j < 4; j++) {
                decode(parytet->tet[j], tetloop);
                if (!infected(tetloop)) {
                    // Found a new hull face (must be a subface).
                    tspivot(tetloop, checksh);
                    maketetrahedron(&hulltet);
                    pa = org(tetloop);
                    pb = dest(tetloop);
                    pc = apex(tetloop);
                    setvertices(hulltet, pb, pa, pc, dummypoint);
                    bond(tetloop, hulltet);
                    // Update the subface-to-tet map.
                    sesymself(checksh);
                    tsbond(hulltet, checksh);
                    // Update the segment-to-tet map.
                    for (k = 0; k < 3; k++) {
                        if (issubseg(tetloop)) {
                            tsspivot1(tetloop, checkseg);
                            tssbond1(hulltet, checkseg);
                            sstbond1(checkseg, hulltet);
                        }
                        enextself(tetloop);
                        eprevself(hulltet);
                    }
                    // Update the point-to-tet map.
                    setpoint2tet(pa, (tetrahedron)tetloop.tet);
                    setpoint2tet(pb, (tetrahedron)tetloop.tet);
                    setpoint2tet(pc, (tetrahedron)tetloop.tet);
                    // Save the exterior tet at this hull face. It still holds pointer
                    //   to the adjacent interior tet. Use it to connect new hull tets.
                    newhullfacearray->newindex((void**)&parytet1);
                    parytet1->tet = parytet->tet;
                    parytet1->ver = j;
                } // if (!infected(tetloop))
            }     // j
        }         // i

        // Connect new hull tets.
        for (i = 0; i < newhullfacearray->objects; i++) {
            parytet = (triface*)fastlookup(newhullfacearray, i);
            fsym(*parytet, neightet);
            // Get the new hull tet.
            fsym(neightet, hulltet);
            for (j = 0; j < 3; j++) {
                esym(hulltet, casface);
                if (casface.tet[casface.ver & 3] == NULL) {
                    // Since the boundary of the domain may not be a manifold, we
                    //   find the adjacent hull face by traversing the tets in the
                    //   exterior (which are all infected tets).
                    neightet = *parytet;
                    while (1) {
                        fnextself(neightet);
                        if (!infected(neightet)) break;
                    }
                    if (!ishulltet(neightet)) {
                        // An interior tet. Get the new hull tet.
                        fsymself(neightet);
                        esymself(neightet);
                    }
                    // Bond them together.
                    bond(casface, neightet);
                }
                enextself(hulltet);
                enextself(*parytet);
            } // j
        }     // i

        if (subfacstack->objects > 0l) {
            // Remove all subfaces which do not attach to any tetrahedron.
            //   Segments which are not attached to any subfaces and tets
            //   are deleted too.
            face casingout, casingin;

            for (i = 0; i < subfacstack->objects; i++) {
                parysh = (face*)fastlookup(subfacstack, i);
                if (i == 0) {
                    if (b->verbose) {
                        printf("Warning:  Removed an exterior face (%d, %d, %d) #%d\n",
                               pointmark(sorg(*parysh)), pointmark(sdest(*parysh)),
                               pointmark(sapex(*parysh)), shellmark(*parysh));
                    }
                }
                // Dissolve this subface from face links.
                for (j = 0; j < 3; j++) {
                    spivot(*parysh, casingout);
                    sspivot(*parysh, checkseg);
                    if (casingout.sh != NULL) {
                        casingin = casingout;
                        while (1) {
                            spivot(casingin, checksh);
                            if (checksh.sh == parysh->sh) break;
                            casingin = checksh;
                        }
                        if (casingin.sh != casingout.sh) {
                            // Update the link: ... -> casingin -> casingout ->...
                            sbond1(casingin, casingout);
                        } else {
                            // Only one subface at this edge is left.
                            sdissolve(casingout);
                        }
                        if (checkseg.sh != NULL) {
                            // Make sure the segment does not connect to a dead one.
                            ssbond(casingout, checkseg);
                        }
                    } else {
                        if (checkseg.sh != NULL) {
                            // if (checkseg.sh[3] != NULL) {
                            if (delsegcount == 0) {
                                if (b->verbose) {
                                    printf("Warning:  Removed an exterior segment (%d, %d) #%d\n",
                                           pointmark(sorg(checkseg)), pointmark(sdest(checkseg)),
                                           shellmark(checkseg));
                                }
                            }
                            shellfacedealloc(subsegs, checkseg.sh);
                            delsegcount++;
                        }
                    }
                    senextself(*parysh);
                } // j
                // Delete this subface.
                shellfacedealloc(subfaces, parysh->sh);
            } // i
            if (b->verbose) {
                printf("  Deleted %ld subfaces.\n", subfacstack->objects);
            }
            subfacstack->restart();
        } // if (subfacstack->objects > 0l)

        if (subsegstack->objects > 0l) {
            for (i = 0; i < subsegstack->objects; i++) {
                paryseg = (face*)fastlookup(subsegstack, i);
                if (paryseg->sh && (paryseg->sh[3] != NULL)) {
                    sstpivot1(*paryseg, neightet);
                    if (infected(neightet)) {
                        if (b->verbose) {
                            printf("Warning:  Removed an exterior segment (%d, %d) #%d\n",
                                   pointmark(sorg(*paryseg)), pointmark(sdest(*paryseg)),
                                   shellmark(*paryseg));
                        }
                        shellfacedealloc(subsegs, paryseg->sh);
                        delsegcount++;
                    }
                }
            }
            subsegstack->restart();
        } // if (subsegstack->objects > 0l)

        if (delsegcount > 0) {
            if (b->verbose) {
                printf("  Deleted %ld segments.\n", delsegcount);
            }
        }

        if (cavetetvertlist->objects > 0l) {
            // Some vertices may lie in exterior. Marke them as UNUSEDVERTEX.
            long delvertcount = unuverts;
            long delsteinercount = 0l;

            for (i = 0; i < cavetetvertlist->objects; i++) {
                parypt = (point*)fastlookup(cavetetvertlist, i);
                decode(point2tet(*parypt), neightet);
                if (infected(neightet)) {
                    // Found an exterior vertex.
                    if (pointmark(*parypt) > (in->numberofpoints - (in->firstnumber ? 0 : 1))) {
                        // A Steiner point.
                        if (pointtype(*parypt) == FREESEGVERTEX) {
                            st_segref_count--;
                        } else if (pointtype(*parypt) == FREEFACETVERTEX) {
                            st_facref_count--;
                        } else {
                            st_volref_count--;
                        }
                        delsteinercount++;
                        if (steinerleft > 0) steinerleft++;
                    }
                    setpointtype(*parypt, UNUSEDVERTEX);
                    unuverts++;
                }
            }

            if (b->verbose) {
                if (unuverts > delvertcount) {
                    if (delsteinercount > 0l) {
                        if (unuverts > (delvertcount + delsteinercount)) {
                            printf("  Removed %ld exterior input vertices.\n",
                                   unuverts - delvertcount - delsteinercount);
                        }
                        printf("  Removed %ld exterior Steiner vertices.\n", delsteinercount);
                    } else {
                        printf("  Removed %ld exterior input vertices.\n", unuverts - delvertcount);
                    }
                }
            }
            cavetetvertlist->restart();
            // Comment: 'subvertstack' will be cleaned in routine
            //   suppresssteinerpoints().
        } // if (cavetetvertlist->objects > 0l)

        // Update the hull size.
        hullsize += (newhullfacearray->objects - hullarray->objects);

        // Delete all exterior tets and old hull tets.
        for (i = 0; i < tetarray->objects; i++) {
            parytet = (triface*)fastlookup(tetarray, i);
            tetrahedrondealloc(parytet->tet);
        }
        tetarray->restart();

        for (i = 0; i < hullarray->objects; i++) {
            parytet = (triface*)fastlookup(hullarray, i);
            tetrahedrondealloc(parytet->tet);
        }
        hullarray->restart();

        delete newhullfacearray;
    } // if (!b->convex && (tetarray->objects > 0l))

    if (b->convex && (tetarray->objects > 0l)) { // With -c option
        // In this case, all exterior tets get a region marker '-1'.
        int attrnum = numelemattrib - 1;

        for (i = 0; i < tetarray->objects; i++) {
            parytet = (triface*)fastlookup(tetarray, i);
            setelemattribute(parytet->tet, attrnum, -1);
        }
        tetarray->restart();

        for (i = 0; i < hullarray->objects; i++) {
            parytet = (triface*)fastlookup(hullarray, i);
            uninfect(*parytet);
        }
        hullarray->restart();

        if (subfacstack->objects > 0l) {
            for (i = 0; i < subfacstack->objects; i++) {
                parysh = (face*)fastlookup(subfacstack, i);
                suninfect(*parysh);
            }
            subfacstack->restart();
        }

        if (cavetetvertlist->objects > 0l) {
            cavetetvertlist->restart();
        }
    } // if (b->convex && (tetarray->objects > 0l))

    if (b->regionattrib) { // With -A option.
        if (!b->quiet) {
            printf("Spreading region attributes.\n");
        }
        REAL volume;
        int attr, maxattr = 0; // Choose a small number here.
        int attrnum = numelemattrib - 1;
        // Comment: The element region marker is at the end of the list of
        //   the element attributes.
        int regioncount = 0;

        // If has user-defined region attributes.
        if (in->numberofregions > 0) {
            // Spread region attributes.
            for (i = 0; i < 5 * in->numberofregions; i += 5) {
                if (regiontets[i / 5].tet != NULL) {
                    attr = (int)in->regionlist[i + 3];
                    if (attr > maxattr) {
                        maxattr = attr;
                    }
                    volume = in->regionlist[i + 4];
                    tetarray->restart(); // Re-use this array.
                    infect(regiontets[i / 5]);
                    tetarray->newindex((void**)&parytet);
                    *parytet = regiontets[i / 5];
                    // Collect and set attrs for all tets of this region.
                    for (j = 0; j < tetarray->objects; j++) {
                        parytet = (triface*)fastlookup(tetarray, j);
                        tetloop = *parytet;
                        setelemattribute(tetloop.tet, attrnum, attr);
                        if (b->varvolume) { // If has -a option.
                            setvolumebound(tetloop.tet, volume);
                        }
                        for (k = 0; k < 4; k++) {
                            decode(tetloop.tet[k], neightet);
                            // Is the adjacent already checked?
                            if (!infected(neightet)) {
                                // Is this side protected by a subface?
                                if (!issubface(neightet)) {
                                    infect(neightet);
                                    tetarray->newindex((void**)&parytet);
                                    *parytet = neightet;
                                }
                            }
                        } // k
                    }     // j
                    regioncount++;
                } // if (regiontets[i/5].tet != NULL)
            }     // i
        }

        // Set attributes for all tetrahedra.
        attr = maxattr + 1;
        tetrahedrons->traversalinit();
        tetloop.tet = tetrahedrontraverse();
        while (tetloop.tet != (tetrahedron*)NULL) {
            if (!infected(tetloop)) {
                // An unmarked region.
                tetarray->restart(); // Re-use this array.
                infect(tetloop);
                tetarray->newindex((void**)&parytet);
                *parytet = tetloop;
                // Find and mark all tets.
                for (j = 0; j < tetarray->objects; j++) {
                    parytet = (triface*)fastlookup(tetarray, j);
                    tetloop = *parytet;
                    setelemattribute(tetloop.tet, attrnum, attr);
                    for (k = 0; k < 4; k++) {
                        decode(tetloop.tet[k], neightet);
                        // Is the adjacent tet already checked?
                        if (!infected(neightet)) {
                            // Is this side protected by a subface?
                            if (!issubface(neightet)) {
                                infect(neightet);
                                tetarray->newindex((void**)&parytet);
                                *parytet = neightet;
                            }
                        }
                    }   // k
                }       // j
                attr++; // Increase the attribute.
                regioncount++;
            }
            tetloop.tet = tetrahedrontraverse();
        }
        // Until here, every tet has a region attribute.

        // Uninfect processed tets.
        tetrahedrons->traversalinit();
        tetloop.tet = tetrahedrontraverse();
        while (tetloop.tet != (tetrahedron*)NULL) {
            uninfect(tetloop);
            tetloop.tet = tetrahedrontraverse();
        }

        if (b->verbose) {
            // assert(regioncount > 0);
            if (regioncount > 1) {
                printf("  Found %d subdomains.\n", regioncount);
            } else {
                printf("  Found %d domain.\n", regioncount);
            }
        }
    } // if (b->regionattrib)

    if (regiontets != NULL) {
        delete[] regiontets;
    }
    delete tetarray;
    delete hullarray;

    if (!b->convex) { // No -c option
        // The mesh is non-convex now.
        nonconvex = 1;

        // Push all hull tets into 'flipstack'.
        tetrahedrons->traversalinit();
        tetloop.ver = 11; // The face opposite to dummypoint.
        tetloop.tet = alltetrahedrontraverse();
        while (tetloop.tet != (tetrahedron*)NULL) {
            if ((point)tetloop.tet[7] == dummypoint) {
                fsym(tetloop, neightet);
                flippush(flipstack, &neightet);
            }
            tetloop.tet = alltetrahedrontraverse();
        }

        flipconstraints fc;
        fc.enqflag = 2;
        long sliver_peel_count = lawsonflip3d(&fc);

        if (sliver_peel_count > 0l) {
            if (b->verbose) {
                printf("  Removed %ld hull slivers.\n", sliver_peel_count);
            }
        }
        unflipqueue->restart();
    } // if (!b->convex)
}

// [2018-07-30]
// Search a face with given indices (i,j,k).
// This function is only called when the default fast search fails.
// It is possible when there are non-manifold edges on the hull.
// On finish, tetloop return this face if it exists, otherwise, return 0.
int tetgenmesh::search_face(point pi, point pj, point pk, triface& tetloop) {
    pinfect(pi);
    pinfect(pj);
    pinfect(pk);

    int t1ver;
    triface t, t1;
    point *pts, toppo;
    int pcount = 0;

    t.ver = t1.ver = 0;
    tetrahedrons->traversalinit();
    t.tet = tetrahedrontraverse();
    while (t.tet != NULL) {
        pts = (point*)t.tet;
        pcount = 0;
        if (pinfected(pts[4])) pcount++;
        if (pinfected(pts[5])) pcount++;
        if (pinfected(pts[6])) pcount++;
        if (pinfected(pts[7])) pcount++;

        if (pcount == 3) {
            // Found a tet containing this face.
            for (t.ver = 0; t.ver < 4; t.ver++) {
                toppo = oppo(t);
                if (!pinfected(toppo)) break;
            }
            int ii;
            for (ii = 0; ii < 3; ii++) {
                if (org(t) == pi) break;
                enextself(t);
            }
            if (dest(t) == pj) {
            } else {
                eprevself(t);
                fsymself(t);
            }
            break;
        }
        t.tet = tetrahedrontraverse();
    }

    puninfect(pi);
    puninfect(pj);
    puninfect(pk);

    if (t.tet != NULL) {
        tetloop = t;
        return 1;
    } else {
        return 0;
    }
}

int tetgenmesh::search_edge(point p0, point p1, triface& tetloop) {
    triface t;
    int ii;

    tetrahedrons->traversalinit();
    t.tet = tetrahedrontraverse();
    while (t.tet != NULL) {
        for (ii = 0; ii < 6; ii++) {
            t.ver = edge2ver[ii];
            if (((org(t) == p0) && (dest(t) == p1)) || ((org(t) == p1) && (dest(t) == p0))) {
                // Found the tet.
                tetloop = t;
                return 1;
            }
        }
        t.tet = tetrahedrontraverse();
    }

    tetloop.tet = NULL;
    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// reconstructmesh()    Reconstruct a tetrahedral mesh.                      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::reconstructmesh() {
    tetrahedron* ver2tetarray;
    point* idx2verlist;
    triface tetloop, checktet, prevchktet;
    triface hulltet, face1, face2;
    tetrahedron tptr;
    face subloop, neighsh, nextsh;
    face segloop;
    shellface sptr;
    point p[4], q[3];
    REAL ori, attrib, volume;
    REAL cosang_tol, cosang;
    REAL n1[3], n2[3];
    int eextras, marker = 0;
    int bondflag;
    int t1ver;
    int idx, i, j, k;

    if (!b->quiet) {
        printf("Reconstructing mesh ...\n");
    }

    if (b->convex) { // -c option.
        // Assume the mesh is convex. Exterior tets have region attribute -1.
        if (!(in->numberoftetrahedronattributes > 0)) {
            terminatetetgen(this, 2);
        }
    } else {
        // Assume the mesh is non-convex.
        nonconvex = 1;
    }

    // Create a map from indices to vertices.
    makeindex2pointmap(idx2verlist);
    // 'idx2verlist' has length 'in->numberofpoints + 1'.
    if (in->firstnumber == 1) {
        idx2verlist[0] = dummypoint; // Let 0th-entry be dummypoint.
    }

    // Allocate an array that maps each vertex to its adjacent tets.
    ver2tetarray = new tetrahedron[in->numberofpoints + 1];
    unuverts = in->numberofpoints; // All vertices are unused yet.
    // for (i = 0; i < in->numberofpoints + 1; i++) {
    for (i = in->firstnumber; i < in->numberofpoints + in->firstnumber; i++) {
        ver2tetarray[i] = NULL;
    }

    // Create the tetrahedra and connect those that share a common face.
    for (i = 0; i < in->numberoftetrahedra; i++) {
        // Get the four vertices.
        idx = i * in->numberofcorners;
        for (j = 0; j < 4; j++) {
            p[j] = idx2verlist[in->tetrahedronlist[idx++]];
            if (pointtype(p[j]) == UNUSEDVERTEX) {
                setpointtype(p[j], VOLVERTEX); // initial type.
                unuverts--;
            }
        }
        // Check the orientation.
        ori = orient3d(p[0], p[1], p[2], p[3]);
        if (ori > 0.0) {
            // Swap the first two vertices.
            q[0] = p[0];
            p[0] = p[1];
            p[1] = q[0];
        } else if (ori == 0.0) {
            if (!b->quiet) {
                printf("Warning:  Tet #%d is degenerate.\n", i + in->firstnumber);
            }
        }
        // Create a new tetrahedron.
        maketetrahedron(&tetloop); // tetloop.ver = 11.
        setvertices(tetloop, p[0], p[1], p[2], p[3]);
        // Set element attributes if they exist.
        for (j = 0; j < in->numberoftetrahedronattributes; j++) {
            idx = i * in->numberoftetrahedronattributes;
            attrib = in->tetrahedronattributelist[idx + j];
            setelemattribute(tetloop.tet, j, attrib);
        }
        // If -a switch is used (with no number follows) Set a volume
        //   constraint if it exists.
        if (b->varvolume) {
            if (in->tetrahedronvolumelist != (REAL*)NULL) {
                volume = in->tetrahedronvolumelist[i];
            } else {
                volume = -1.0;
            }
            setvolumebound(tetloop.tet, volume);
        }
        // Try connecting this tet to others that share the common faces.
        for (tetloop.ver = 0; tetloop.ver < 4; tetloop.ver++) {
            p[3] = oppo(tetloop);
            // Look for other tets having this vertex.
            idx = pointmark(p[3]);
            tptr = ver2tetarray[idx];
            // Link the current tet to the next one in the stack.
            tetloop.tet[8 + tetloop.ver] = tptr;
            // Push the current tet onto the stack.
            ver2tetarray[idx] = encode(tetloop);
            decode(tptr, checktet);
            if (checktet.tet != NULL) {
                p[0] = org(tetloop);  // a
                p[1] = dest(tetloop); // b
                p[2] = apex(tetloop); // c
                prevchktet = tetloop;
                do {
                    q[0] = org(checktet);  // a'
                    q[1] = dest(checktet); // b'
                    q[2] = apex(checktet); // c'
                    // Check the three faces at 'd' in 'checktet'.
                    bondflag = 0;
                    for (j = 0; j < 3; j++) {
                        // Go to the face [b',a',d], or [c',b',d], or [a',c',d].
                        esym(checktet, face2);
                        if (face2.tet[face2.ver & 3] == NULL) {
                            k = ((j + 1) % 3);
                            if (q[k] == p[0]) {     // b', c', a' = a
                                if (q[j] == p[1]) { // a', b', c' = b
                                    // [#,#,d] is matched to [b,a,d].
                                    esym(tetloop, face1);
                                    bond(face1, face2);
                                    bondflag++;
                                }
                            }
                            if (q[k] == p[1]) {     // b',c',a' = b
                                if (q[j] == p[2]) { // a',b',c' = c
                                    // [#,#,d] is matched to [c,b,d].
                                    enext(tetloop, face1);
                                    esymself(face1);
                                    bond(face1, face2);
                                    bondflag++;
                                }
                            }
                            if (q[k] == p[2]) {     // b',c',a' = c
                                if (q[j] == p[0]) { // a',b',c' = a
                                    // [#,#,d] is matched to [a,c,d].
                                    eprev(tetloop, face1);
                                    esymself(face1);
                                    bond(face1, face2);
                                    bondflag++;
                                }
                            }
                        } else {
                            bondflag++;
                        }
                        enextself(checktet);
                    } // j
                    // Go to the next tet in the link.
                    tptr = checktet.tet[8 + checktet.ver];
                    if (bondflag == 3) {
                        // All three faces at d in 'checktet' have been connected.
                        // It can be removed from the link.
                        prevchktet.tet[8 + prevchktet.ver] = tptr;
                    } else {
                        // Bakup the previous tet in the link.
                        prevchktet = checktet;
                    }
                    decode(tptr, checktet);
                } while (checktet.tet != NULL);
            } // if (checktet.tet != NULL)
        }     // for (tetloop.ver = 0; ...
    }         // i

    // Remember a tet of the mesh.
    recenttet = tetloop;

    // Create hull tets, create the point-to-tet map, and clean up the
    //   temporary spaces used in each tet.
    hullsize = tetrahedrons->items;

    tetrahedrons->traversalinit();
    tetloop.tet = tetrahedrontraverse();
    while (tetloop.tet != (tetrahedron*)NULL) {
        tptr = encode(tetloop);
        for (tetloop.ver = 0; tetloop.ver < 4; tetloop.ver++) {
            if (tetloop.tet[tetloop.ver] == NULL) {
                // Create a hull tet.
                maketetrahedron(&hulltet);
                p[0] = org(tetloop);
                p[1] = dest(tetloop);
                p[2] = apex(tetloop);
                setvertices(hulltet, p[1], p[0], p[2], dummypoint);
                bond(tetloop, hulltet);
                // Try connecting this to others that share common hull edges.
                for (j = 0; j < 3; j++) {
                    fsym(hulltet, face2);
                    while (1) {
                        if (face2.tet == NULL) break;
                        esymself(face2);
                        if (apex(face2) == dummypoint) break;
                        fsymself(face2);
                    }
                    if (face2.tet != NULL) {
                        // Found an adjacent hull tet.
                        esym(hulltet, face1);
                        bond(face1, face2);
                    }
                    enextself(hulltet);
                }
            }
            // Create the point-to-tet map.
            setpoint2tet((point)(tetloop.tet[4 + tetloop.ver]), tptr);
            // Clean the temporary used space.
            tetloop.tet[8 + tetloop.ver] = NULL;
        }
        tetloop.tet = tetrahedrontraverse();
    }

    hullsize = tetrahedrons->items - hullsize;

    // Subfaces will be inserted into the mesh.
    if (in->trifacelist != NULL) {
        // A .face file is given. It may contain boundary faces. Insert them.
        for (i = 0; i < in->numberoftrifaces; i++) {
            // Is it a subface?
            if (in->trifacemarkerlist != NULL) {
                marker = in->trifacemarkerlist[i];
            } else {
                // Face markers are not available. Assume all of them are subfaces.
                marker = -1; // The default marker.
            }
            if (marker != 0) {
                idx = i * 3;
                for (j = 0; j < 3; j++) {
                    p[j] = idx2verlist[in->trifacelist[idx++]];
                }
                // Search the subface.
                bondflag = 0;
                neighsh.sh = NULL;
                // Make sure all vertices are in the mesh. Avoid crash.
                for (j = 0; j < 3; j++) {
                    decode(point2tet(p[j]), checktet);
                    if (checktet.tet == NULL) break;
                }
                if ((j == 3) && getedge(p[0], p[1], &checktet)) {
                    tetloop = checktet;
                    q[2] = apex(checktet);
                    while (1) {
                        if (apex(tetloop) == p[2]) {
                            // Found the face.
                            // Check if there exist a subface already?
                            tspivot(tetloop, neighsh);
                            if (neighsh.sh != NULL) {
                                // Found a duplicated subface.
                                // This happens when the mesh was generated by other mesher.
                                bondflag = 0;
                            } else {
                                bondflag = 1;
                            }
                            break;
                        }
                        fnextself(tetloop);
                        if (apex(tetloop) == q[2]) break;
                    }
                }
                if (!bondflag) {
                    if (neighsh.sh == NULL) {
                        if (b->verbose > 1) {
                            printf("Warning:  Searching subface #%d [%d,%d,%d] mark=%d.\n",
                                   i + in->firstnumber, pointmark(p[0]), pointmark(p[1]),
                                   pointmark(p[2]), marker);
                        }
                        // Search it globally.
                        if (search_face(p[0], p[1], p[2], tetloop)) {
                            bondflag = 1;
                        }
                    }
                }
                if (bondflag) {
                    // Create a new subface.
                    makeshellface(subfaces, &subloop);
                    setshvertices(subloop, p[0], p[1], p[2]);
                    // Create the point-to-subface map.
                    sptr = sencode(subloop);
                    for (j = 0; j < 3; j++) {
                        setpointtype(p[j], FACETVERTEX); // initial type.
                        setpoint2sh(p[j], sptr);
                    }
                    setshellmark(subloop, marker);
                    // Insert the subface into the mesh.
                    tsbond(tetloop, subloop);
                    fsymself(tetloop);
                    sesymself(subloop);
                    tsbond(tetloop, subloop);
                } else {
                    if (neighsh.sh != NULL) {
                        // The subface already exists. Only set its mark.
                        setshellmark(neighsh, marker);
                    } else {
                        if (!b->quiet) {
                            printf("Warning:  Subface #%d [%d,%d,%d] mark=%d is not found.\n",
                                   i + in->firstnumber, pointmark(p[0]), pointmark(p[1]),
                                   pointmark(p[2]), marker);
                        }
                    }
                } // if (bondflag)
            }     // if (marker != 0)
        }         // i
    }             // if (in->trifacelist)

    // Indentify subfaces from the mesh.
    // Create subfaces for hull faces (if they're not subface yet) and
    //   interior faces which separate two different materials.
    eextras = in->numberoftetrahedronattributes;
    tetrahedrons->traversalinit();
    tetloop.tet = tetrahedrontraverse();
    while (tetloop.tet != (tetrahedron*)NULL) {
        for (tetloop.ver = 0; tetloop.ver < 4; tetloop.ver++) {
            tspivot(tetloop, neighsh);
            if (neighsh.sh == NULL) {
                bondflag = 0;
                fsym(tetloop, checktet);
                if (ishulltet(checktet)) {
                    // A hull face.
                    if (!b->convex) {
                        bondflag = 1; // Insert a hull subface.
                    }
                } else {
                    if (eextras > 0) {
                        if (elemattribute(tetloop.tet, eextras - 1) !=
                            elemattribute(checktet.tet, eextras - 1)) {
                            bondflag = 1; // Insert an interior interface.
                        }
                    }
                }
                if (bondflag) {
                    // Create a new subface.
                    makeshellface(subfaces, &subloop);
                    p[0] = org(tetloop);
                    p[1] = dest(tetloop);
                    p[2] = apex(tetloop);
                    setshvertices(subloop, p[0], p[1], p[2]);
                    // Create the point-to-subface map.
                    sptr = sencode(subloop);
                    for (j = 0; j < 3; j++) {
                        setpointtype(p[j], FACETVERTEX); // initial type.
                        setpoint2sh(p[j], sptr);
                    }
                    setshellmark(subloop, -1); // Default marker.
                    // Insert the subface into the mesh.
                    tsbond(tetloop, subloop);
                    sesymself(subloop);
                    tsbond(checktet, subloop);
                } // if (bondflag)
            }     // if (neighsh.sh == NULL)
        }
        tetloop.tet = tetrahedrontraverse();
    }

    // Connect subfaces together.
    subfaces->traversalinit();
    subloop.shver = 0;
    subloop.sh = shellfacetraverse(subfaces);
    while (subloop.sh != (shellface*)NULL) {
        for (i = 0; i < 3; i++) {
            spivot(subloop, neighsh);
            if (neighsh.sh == NULL) {
                // Form a subface ring by linking all subfaces at this edge.
                // Traversing all faces of the tets at this edge.
                stpivot(subloop, tetloop);
                q[2] = apex(tetloop);
                neighsh = subloop;
                while (1) {
                    fnextself(tetloop);
                    tspivot(tetloop, nextsh);
                    if (nextsh.sh != NULL) {
                        // Do not connect itself.
                        if (nextsh.sh != neighsh.sh) {
                            // Link neighsh <= nextsh.
                            sbond1(neighsh, nextsh);
                            neighsh = nextsh;
                        }
                    }
                    if (apex(tetloop) == q[2]) {
                        break;
                    }
                } // while (1)
            }     // if (neighsh.sh == NULL)
            senextself(subloop);
        }
        subloop.sh = shellfacetraverse(subfaces);
    }

    // Segments will be introduced.
    if (in->edgelist != NULL) {
        // A .edge file is given. It may contain boundary edges. Insert them.
        for (i = 0; i < in->numberofedges; i++) {
            // Is it a segment?
            if (in->edgemarkerlist != NULL) {
                marker = in->edgemarkerlist[i];
            } else {
                // Edge markers are not available. Assume all of them are segments.
                marker = -1; // Default marker.
            }
            if (marker != 0) {
                // Insert a segment.
                idx = i * 2;
                for (j = 0; j < 2; j++) {
                    p[j] = idx2verlist[in->edgelist[idx++]];
                }
                // Make sure all vertices are in the mesh. Avoid crash.
                for (j = 0; j < 2; j++) {
                    decode(point2tet(p[j]), checktet);
                    if (checktet.tet == NULL) break;
                }
                // Search the segment.
                bondflag = 0;
                if (j == 2) {
                    if (getedge(p[0], p[1], &checktet)) {
                        bondflag = 1;
                    } else {
                        if (b->verbose > 1) {
                            printf("Warning:  Searching segment #%d [%d,%d] mark=%d.\n",
                                   i + in->firstnumber, pointmark(p[0]), pointmark(p[1]), marker);
                        }
                        // Search it globally.
                        if (search_edge(p[0], p[1], checktet)) {
                            bondflag = 1;
                        }
                    }
                }
                if (bondflag > 0) {
                    // Create a new segment.
                    makeshellface(subsegs, &segloop);
                    setshvertices(segloop, p[0], p[1], NULL);
                    // Create the point-to-segment map.
                    sptr = sencode(segloop);
                    for (j = 0; j < 2; j++) {
                        setpointtype(p[j], RIDGEVERTEX); // initial type.
                        setpoint2sh(p[j], sptr);
                    }
                    setshellmark(segloop, marker);
                    // Insert the segment into the mesh.
                    tetloop = checktet;
                    q[2] = apex(checktet);
                    subloop.sh = NULL;
                    while (1) {
                        tssbond1(tetloop, segloop);
                        tspivot(tetloop, subloop);
                        if (subloop.sh != NULL) {
                            ssbond1(subloop, segloop);
                            sbond1(segloop, subloop);
                        }
                        fnextself(tetloop);
                        if (apex(tetloop) == q[2]) break;
                    } // while (1)
                    // Remember an adjacent tet for this segment.
                    sstbond1(segloop, tetloop);
                } else {
                    if (!b->quiet) {
                        printf("Warning:  Segment #%d [%d,%d] is missing.\n", i + in->firstnumber,
                               pointmark(p[0]), pointmark(p[1]));
                    }
                }
            } // if (marker != 0)
        }     // i
    }         // if (in->edgelist)

    // Identify segments from the mesh.
    // Create segments for non-manifold edges (which are shared by more
    //   than two subfaces), and for non-coplanar edges, i.e., two subfaces
    //   form an dihedral angle > 'b->facet_separate_ang_tol' (degree).
    cosang_tol = cos(b->facet_separate_ang_tol / 180.0 * PI);
    subfaces->traversalinit();
    subloop.shver = 0;
    subloop.sh = shellfacetraverse(subfaces);
    while (subloop.sh != (shellface*)NULL) {
        for (i = 0; i < 3; i++) {
            sspivot(subloop, segloop);
            if (segloop.sh == NULL) {
                // Check if this edge is a segment.
                bondflag = 0;
                // Counter the number of subfaces at this edge.
                idx = 0;
                nextsh = subloop;
                while (1) {
                    idx++;
                    spivotself(nextsh);
                    if (nextsh.sh == subloop.sh) break;
                }
                if (idx != 2) {
                    // It's a non-manifold edge. Insert a segment.
                    p[0] = sorg(subloop);
                    p[1] = sdest(subloop);
                    bondflag = 1;
                } else {
                    spivot(subloop, neighsh);
                    if (shellmark(subloop) != shellmark(neighsh)) {
                        // It's an interior interface. Insert a segment.
                        p[0] = sorg(subloop);
                        p[1] = sdest(subloop);
                        bondflag = 1;
                    } else {
                        if (!b->convex) {
                            // Check the dihedral angle formed by the two subfaces.
                            p[0] = sorg(subloop);
                            p[1] = sdest(subloop);
                            p[2] = sapex(subloop);
                            p[3] = sapex(neighsh);
                            facenormal(p[0], p[1], p[2], n1, 1, NULL);
                            facenormal(p[0], p[1], p[3], n2, 1, NULL);
                            cosang = dot(n1, n2) / (sqrt(dot(n1, n1)) * sqrt(dot(n2, n2)));
                            // Rounding.
                            if (cosang > 1.0)
                                cosang = 1.0;
                            else if (cosang < -1.0)
                                cosang = -1.0;
                            if (cosang > cosang_tol) {
                                bondflag = 1;
                            }
                        }
                    }
                }
                if (bondflag) {
                    // Create a new segment.
                    makeshellface(subsegs, &segloop);
                    setshvertices(segloop, p[0], p[1], NULL);
                    // Create the point-to-segment map.
                    sptr = sencode(segloop);
                    for (j = 0; j < 2; j++) {
                        setpointtype(p[j], RIDGEVERTEX); // initial type.
                        setpoint2sh(p[j], sptr);
                    }
                    setshellmark(segloop, -1); // Default marker.
                    // Insert the subface into the mesh.
                    stpivot(subloop, tetloop);
                    q[2] = apex(tetloop);
                    while (1) {
                        tssbond1(tetloop, segloop);
                        tspivot(tetloop, neighsh);
                        if (neighsh.sh != NULL) {
                            ssbond1(neighsh, segloop);
                        }
                        fnextself(tetloop);
                        if (apex(tetloop) == q[2]) break;
                    } // while (1)
                    // Remember an adjacent tet for this segment.
                    sstbond1(segloop, tetloop);
                    sbond1(segloop, subloop);
                } // if (bondflag)
            }     // if (neighsh.sh == NULL)
            senextself(subloop);
        } // i
        subloop.sh = shellfacetraverse(subfaces);
    }

    // Remember the number of input segments.
    insegments = subsegs->items;

    if (!b->nobisect || checkconstraints) {
        // Mark Steiner points on segments and facets.
        //   - all vertices which remaining type FEACTVERTEX become
        //     Steiner points in facets (= FREEFACERVERTEX).
        //   - vertices on segment need to be checked.
        face* segperverlist;
        int* idx2seglist;
        face parentseg, nextseg;
        verttype vt;
        REAL area, len, l1, l2;
        int fmarker;

        makepoint2submap(subsegs, idx2seglist, segperverlist);

        points->traversalinit();
        point ptloop = pointtraverse();
        while (ptloop != NULL) {
            vt = pointtype(ptloop);
            if (vt == VOLVERTEX) {
                setpointtype(ptloop, FREEVOLVERTEX);
                st_volref_count++;
            } else if (vt == FACETVERTEX) {
                setpointtype(ptloop, FREEFACETVERTEX);
                st_facref_count++;
            } else if (vt == RIDGEVERTEX) {
                idx = pointmark(ptloop) - in->firstnumber;
                if ((idx2seglist[idx + 1] - idx2seglist[idx]) == 2) {
                    i = idx2seglist[idx];
                    parentseg = segperverlist[i];
                    nextseg = segperverlist[i + 1];
                    sesymself(nextseg);
                    p[0] = sorg(nextseg);
                    p[1] = sdest(parentseg);
                    // Check if three points p[0], ptloop, p[2] are (nearly) collinear.
                    len = distance(p[0], p[1]);
                    l1 = distance(p[0], ptloop);
                    l2 = distance(ptloop, p[1]);
                    if (((l1 + l2 - len) / len) < b->epsilon) {
                        // They are (nearly) collinear.
                        setpointtype(ptloop, FREESEGVERTEX);
                        // Connect nextseg and parentseg together at ptloop.
                        senextself(nextseg);
                        senext2self(parentseg);
                        sbond(nextseg, parentseg);
                        st_segref_count++;
                    }
                }
            }
            ptloop = pointtraverse();
        }

        // Are there area constraints?
        if (b->quality && (in->facetconstraintlist != (REAL*)NULL)) {
            // Set maximum area constraints on facets.
            for (i = 0; i < in->numberoffacetconstraints; i++) {
                fmarker = (int)in->facetconstraintlist[i * 2];
                area = in->facetconstraintlist[i * 2 + 1];
                subfaces->traversalinit();
                subloop.sh = shellfacetraverse(subfaces);
                while (subloop.sh != NULL) {
                    if (shellmark(subloop) == fmarker) {
                        setareabound(subloop, area);
                    }
                    subloop.sh = shellfacetraverse(subfaces);
                }
            }
        }

        // Are there length constraints?
        if (b->quality && (in->segmentconstraintlist != (REAL*)NULL)) {
            // Set maximum length constraints on segments.
            int e1, e2;
            for (i = 0; i < in->numberofsegmentconstraints; i++) {
                e1 = (int)in->segmentconstraintlist[i * 3];
                e2 = (int)in->segmentconstraintlist[i * 3 + 1];
                len = in->segmentconstraintlist[i * 3 + 2];
                // Search for edge [e1, e2].
                idx = e1 - in->firstnumber;
                for (j = idx2seglist[idx]; j < idx2seglist[idx + 1]; j++) {
                    parentseg = segperverlist[j];
                    if (pointmark(sdest(parentseg)) == e2) {
                        setareabound(parentseg, len);
                        break;
                    }
                }
            }
        }

        delete[] idx2seglist;
        delete[] segperverlist;
    }

    // Set global flags.
    checksubsegflag = 1;
    checksubfaceflag = 1;

    delete[] idx2verlist;
    delete[] ver2tetarray;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// scoutpoint()    Search a point in mesh.                                   //
//                                                                           //
// This function searches the point in a mesh whose domain may be not convex.//
// In case of a convex domain, the locate() function is sufficient.          //
//                                                                           //
// If 'randflag' is used, randomly select a start searching tet.  Otherwise, //
// start searching directly from 'searchtet'.                                //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::scoutpoint(point searchpt, triface* searchtet, int randflag) {
    point pa, pb, pc, pd;
    enum locateresult loc = OUTSIDE;
    REAL vol, ori1, ori2 = 0, ori3 = 0, ori4 = 0;
    int t1ver;

    // Randomly select a good starting tet.
    if (randflag) {
        randomsample(searchpt, searchtet);
    } else {
        if (searchtet->tet == NULL) {
            *searchtet = recenttet;
        }
    }
    loc = locate(searchpt, searchtet);

    if (loc == OUTSIDE) {
        if (b->convex) { // -c option
            // The point lies outside of the convex hull.
            return (int)loc;
        }
        // Test if it lies nearly on the hull face.
        // Reuse vol, ori1.
        pa = org(*searchtet);
        pb = dest(*searchtet);
        pc = apex(*searchtet);
        vol = triarea(pa, pb, pc);
        ori1 = orient3dfast(pa, pb, pc, searchpt);
        if (fabs(ori1 / vol) < b->epsilon) {
            loc = ONFACE; // On face (or on edge, or on vertex).
            fsymself(*searchtet);
        }
    }

    if (loc != OUTSIDE) {
        // Round the result of location.
        pa = org(*searchtet);
        pb = dest(*searchtet);
        pc = apex(*searchtet);
        pd = oppo(*searchtet);
        vol = orient3dfast(pa, pb, pc, pd);
        ori1 = orient3dfast(pa, pb, pc, searchpt);
        ori2 = orient3dfast(pb, pa, pd, searchpt);
        ori3 = orient3dfast(pc, pb, pd, searchpt);
        ori4 = orient3dfast(pa, pc, pd, searchpt);
        if (fabs(ori1 / vol) < b->epsilon) ori1 = 0;
        if (fabs(ori2 / vol) < b->epsilon) ori2 = 0;
        if (fabs(ori3 / vol) < b->epsilon) ori3 = 0;
        if (fabs(ori4 / vol) < b->epsilon) ori4 = 0;
    } else { // if (loc == OUTSIDE) {
        // Do a brute force search for the point (with rounding).
        tetrahedrons->traversalinit();
        searchtet->tet = tetrahedrontraverse();
        while (searchtet->tet != NULL) {
            pa = org(*searchtet);
            pb = dest(*searchtet);
            pc = apex(*searchtet);
            pd = oppo(*searchtet);

            vol = orient3dfast(pa, pb, pc, pd);
            if (vol < 0) {
                ori1 = orient3dfast(pa, pb, pc, searchpt);
                if (fabs(ori1 / vol) < b->epsilon) ori1 = 0; // Rounding.
                if (ori1 <= 0) {
                    ori2 = orient3dfast(pb, pa, pd, searchpt);
                    if (fabs(ori2 / vol) < b->epsilon) ori2 = 0;
                    if (ori2 <= 0) {
                        ori3 = orient3dfast(pc, pb, pd, searchpt);
                        if (fabs(ori3 / vol) < b->epsilon) ori3 = 0;
                        if (ori3 <= 0) {
                            ori4 = orient3dfast(pa, pc, pd, searchpt);
                            if (fabs(ori4 / vol) < b->epsilon) ori4 = 0;
                            if (ori4 <= 0) {
                                // Found the tet. Return its location.
                                break;
                            } // ori4
                        }     // ori3
                    }         // ori2
                }             // ori1
            }

            searchtet->tet = tetrahedrontraverse();
        }                  // while (searchtet->tet != NULL)
        nonregularcount++; // Re-use this counter.
    }

    if (searchtet->tet != NULL) {
        // Return the point location.
        if (ori1 == 0) {                   // on face [a,b,c]
            if (ori2 == 0) {               // on edge [a,b].
                if (ori3 == 0) {           // on vertex [b].
                    enextself(*searchtet); // [b,c,a,d]
                    loc = ONVERTEX;
                } else {
                    if (ori4 == 0) {    // on vertex [a]
                        loc = ONVERTEX; // [a,b,c,d]
                    } else {
                        loc = ONEDGE; // [a,b,c,d]
                    }
                }
            } else {                           // ori2 != 0
                if (ori3 == 0) {               // on edge [b,c]
                    if (ori4 == 0) {           // on vertex [c]
                        eprevself(*searchtet); // [c,a,b,d]
                        loc = ONVERTEX;
                    } else {
                        enextself(*searchtet); // [b,c,a,d]
                        loc = ONEDGE;
                    }
                } else {                       // ori3 != 0
                    if (ori4 == 0) {           // on edge [c,a]
                        eprevself(*searchtet); // [c,a,b,d]
                        loc = ONEDGE;
                    } else {
                        loc = ONFACE;
                    }
                }
            }
        } else {                           // ori1 != 0
            if (ori2 == 0) {               // on face [b,a,d]
                esymself(*searchtet);      // [b,a,d,c]
                if (ori3 == 0) {           // on edge [b,d]
                    eprevself(*searchtet); // [d,b,a,c]
                    if (ori4 == 0) {       // on vertex [d]
                        loc = ONVERTEX;
                    } else {
                        loc = ONEDGE;
                    }
                } else {                       // ori3 != 0
                    if (ori4 == 0) {           // on edge [a,d]
                        enextself(*searchtet); // [a,d,b,c]
                        loc = ONEDGE;
                    } else {
                        loc = ONFACE;
                    }
                }
            } else {             // ori2 != 0
                if (ori3 == 0) { // on face [c,b,d]
                    enextself(*searchtet);
                    esymself(*searchtet);
                    if (ori4 == 0) { // on edge [c,d]
                        eprevself(*searchtet);
                        loc = ONEDGE;
                    } else {
                        loc = ONFACE;
                    }
                } else {
                    if (ori4 == 0) { // on face [a,c,d]
                        eprevself(*searchtet);
                        esymself(*searchtet);
                        loc = ONFACE;
                    } else { // inside tet [a,b,c,d]
                        loc = INTETRAHEDRON;
                    } // ori4
                }     // ori3
            }         // ori2
        }             // ori1
    } else {
        loc = OUTSIDE;
    }

    return (int)loc;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// getpointmeshsize()    Interpolate the mesh size at given point.           //
//                                                                           //
// 'iloc' indicates the location of the point w.r.t. 'searchtet'.  The size  //
// is obtained by linear interpolation on the vertices of the tet.           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

REAL tetgenmesh::getpointmeshsize(point searchpt, triface* searchtet, int iloc) {
    point *pts, pa, pb, pc;
    REAL volume, vol[4], wei[4];
    REAL size;
    int i;

    size = 0;

    if (iloc == (int)INTETRAHEDRON) {
        pts = (point*)&(searchtet->tet[4]);
        // Only do interpolation if all vertices have non-zero sizes.
        if ((pts[0][pointmtrindex] > 0) && (pts[1][pointmtrindex] > 0) &&
            (pts[2][pointmtrindex] > 0) && (pts[3][pointmtrindex] > 0)) {
            // P1 interpolation.
            volume = orient3dfast(pts[0], pts[1], pts[2], pts[3]);
            vol[0] = orient3dfast(searchpt, pts[1], pts[2], pts[3]);
            vol[1] = orient3dfast(pts[0], searchpt, pts[2], pts[3]);
            vol[2] = orient3dfast(pts[0], pts[1], searchpt, pts[3]);
            vol[3] = orient3dfast(pts[0], pts[1], pts[2], searchpt);
            for (i = 0; i < 4; i++) {
                wei[i] = fabs(vol[i] / volume);
                size += (wei[i] * pts[i][pointmtrindex]);
            }
        }
    } else if (iloc == (int)ONFACE) {
        pa = org(*searchtet);
        pb = dest(*searchtet);
        pc = apex(*searchtet);
        if ((pa[pointmtrindex] > 0) && (pb[pointmtrindex] > 0) && (pc[pointmtrindex] > 0)) {
            volume = triarea(pa, pb, pc);
            vol[0] = triarea(searchpt, pb, pc);
            vol[1] = triarea(pa, searchpt, pc);
            vol[2] = triarea(pa, pb, searchpt);
            size = (vol[0] / volume) * pa[pointmtrindex] + (vol[1] / volume) * pb[pointmtrindex] +
                   (vol[2] / volume) * pc[pointmtrindex];
        }
    } else if (iloc == (int)ONEDGE) {
        pa = org(*searchtet);
        pb = dest(*searchtet);
        if ((pa[pointmtrindex] > 0) && (pb[pointmtrindex] > 0)) {
            volume = distance(pa, pb);
            vol[0] = distance(searchpt, pb);
            vol[1] = distance(pa, searchpt);
            size = (vol[0] / volume) * pa[pointmtrindex] + (vol[1] / volume) * pb[pointmtrindex];
        }
    } else if (iloc == (int)ONVERTEX) {
        pa = org(*searchtet);
        if (pa[pointmtrindex] > 0) {
            size = pa[pointmtrindex];
        }
    }

    return size;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// interpolatemeshsize()    Interpolate the mesh size from a background mesh //
//                          (source) to the current mesh (destination).      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::interpolatemeshsize() {
    triface searchtet;
    point ploop;
    REAL minval = 0.0, maxval = 0.0;
    int iloc;
    int count;

    if (!b->quiet) {
        printf("Interpolating mesh size ...\n");
    }

    long bak_nonregularcount = nonregularcount;
    nonregularcount = 0l; // Count the number of (slow) global searches.
    long baksmaples = bgm->samples;
    bgm->samples = 3l;
    count = 0; // Count the number of interpolated points.

    // Interpolate sizes for all points in the current mesh.
    points->traversalinit();
    ploop = pointtraverse();
    while (ploop != NULL) {
        // Search a tet in bgm which containing this point.
        searchtet.tet = NULL;
        iloc = bgm->scoutpoint(ploop, &searchtet, 1); // randflag = 1
        if (iloc != (int)OUTSIDE) {
            // Interpolate the mesh size.
            ploop[pointmtrindex] = bgm->getpointmeshsize(ploop, &searchtet, iloc);
            setpoint2bgmtet(ploop, bgm->encode(searchtet));
            if (count == 0) {
                // This is the first interpolated point.
                minval = maxval = ploop[pointmtrindex];
            } else {
                if (ploop[pointmtrindex] < minval) {
                    minval = ploop[pointmtrindex];
                }
                if (ploop[pointmtrindex] > maxval) {
                    maxval = ploop[pointmtrindex];
                }
            }
            count++;
        } else {
            if (!b->quiet) {
                printf("Warnning:  Failed to locate point %d in source mesh.\n", pointmark(ploop));
            }
        }
        ploop = pointtraverse();
    }

    if (b->verbose) {
        printf("  Interoplated %d points.\n", count);
        if (nonregularcount > 0l) {
            printf("  Performed %ld brute-force searches.\n", nonregularcount);
        }
        printf("  Size rangle [%.17g, %.17g].\n", minval, maxval);
    }

    bgm->samples = baksmaples;
    nonregularcount = bak_nonregularcount;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// insertconstrainedpoints()    Insert a list of points into the mesh.       //
//                                                                           //
// Assumption:  The bounding box of the insert point set should be no larger //
// than the bounding box of the mesh.  (Required by point sorting).          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::insertconstrainedpoints(point* insertarray, int arylen, int rejflag) {
    triface searchtet, spintet;
    face splitsh;
    face splitseg;
    insertvertexflags ivf;
    flipconstraints fc;
    int randflag = 0;
    int t1ver;
    int i;

    if (b->verbose) {
        printf("  Inserting %d constrained points\n", arylen);
    }

    if (b->no_sort) { // -b/1 option.
        if (b->verbose) {
            printf("  Using the input order.\n");
        }
    } else {
        if (b->verbose) {
            printf("  Permuting vertices.\n");
        }
        point swappoint;
        int randindex;
        srand(arylen);
        for (i = 0; i < arylen; i++) {
            randindex = rand() % (i + 1);
            swappoint = insertarray[i];
            insertarray[i] = insertarray[randindex];
            insertarray[randindex] = swappoint;
        }
        if (b->brio_hilbert) { // -b1 option
            if (b->verbose) {
                printf("  Sorting vertices.\n");
            }
            hilbert_init(in->mesh_dim);
            int ngroup = 0;
            brio_multiscale_sort(insertarray, arylen, b->brio_threshold, b->brio_ratio, &ngroup);
        } else { // -b0 option.
            randflag = 1;
        } // if (!b->brio_hilbert)
    }     // if (!b->no_sort)

    long bak_nonregularcount = nonregularcount;
    nonregularcount = 0l;
    long baksmaples = samples;
    samples = 3l; // Use at least 3 samples. Updated in randomsample().

    long bak_seg_count = st_segref_count;
    long bak_fac_count = st_facref_count;
    long bak_vol_count = st_volref_count;

    // Initialize the insertion parameters.
    if (b->incrflip) { // -l option
        // Use incremental flip algorithm.
        ivf.bowywat = 0;
        ivf.lawson = 1;
        ivf.validflag = 0; // No need to validate the cavity.
        fc.enqflag = 2;
    } else {
        // Use Bowyer-Watson algorithm.
        ivf.bowywat = 1;
        ivf.lawson = 0;
        ivf.validflag = 1; // Validate the B-W cavity.
    }
    ivf.rejflag = rejflag;
    ivf.chkencflag = 0;
    ivf.sloc = (int)INSTAR;
    ivf.sbowywat = 3;
    ivf.splitbdflag = 1;
    ivf.respectbdflag = 1;
    ivf.assignmeshsize = b->metric;

    encseglist = new arraypool(sizeof(face), 8);
    encshlist = new arraypool(sizeof(badface), 8);

    // Insert the points.
    for (i = 0; i < arylen; i++) {
        // Find the location of the inserted point.
        // Do not use 'recenttet', since the mesh may be non-convex.
        searchtet.tet = NULL;
        ivf.iloc = scoutpoint(insertarray[i], &searchtet, randflag);

        // Decide the right type for this point.
        setpointtype(insertarray[i], FREEVOLVERTEX); // Default.
        splitsh.sh = NULL;
        splitseg.sh = NULL;
        if (ivf.iloc == (int)ONEDGE) {
            if (issubseg(searchtet)) {
                tsspivot1(searchtet, splitseg);
                setpointtype(insertarray[i], FREESEGVERTEX);
                // ivf.rejflag = 0;
            } else {
                // Check if it is a subface edge.
                spintet = searchtet;
                while (1) {
                    if (issubface(spintet)) {
                        tspivot(spintet, splitsh);
                        setpointtype(insertarray[i], FREEFACETVERTEX);
                        // ivf.rejflag |= 1;
                        break;
                    }
                    fnextself(spintet);
                    if (spintet.tet == searchtet.tet) break;
                }
            }
        } else if (ivf.iloc == (int)ONFACE) {
            if (issubface(searchtet)) {
                tspivot(searchtet, splitsh);
                setpointtype(insertarray[i], FREEFACETVERTEX);
                // ivf.rejflag |= 1;
            }
        }

        // Now insert the point.
        if (insertpoint(insertarray[i], &searchtet, &splitsh, &splitseg, &ivf)) {
            if (flipstack != NULL) {
                // There are queued faces. Use flips to recover Delaunayness.
                lawsonflip3d(&fc);
                // There may be unflippable edges. Ignore them.
                unflipqueue->restart();
            }
            // Update the Steiner counters.
            if (pointtype(insertarray[i]) == FREESEGVERTEX) {
                st_segref_count++;
            } else if (pointtype(insertarray[i]) == FREEFACETVERTEX) {
                st_facref_count++;
            } else {
                st_volref_count++;
            }
        } else {
            // Point is not inserted.
            // pointdealloc(insertarray[i]);
            setpointtype(insertarray[i], UNUSEDVERTEX);
            unuverts++;
            encseglist->restart();
            encshlist->restart();
        }
    } // i

    delete encseglist;
    delete encshlist;

    if (b->verbose) {
        printf("  Inserted %ld (%ld, %ld, %ld) vertices.\n",
               st_segref_count + st_facref_count + st_volref_count -
                   (bak_seg_count + bak_fac_count + bak_vol_count),
               st_segref_count - bak_seg_count, st_facref_count - bak_fac_count,
               st_volref_count - bak_vol_count);
        if (nonregularcount > 0l) {
            printf("  Performed %ld brute-force searches.\n", nonregularcount);
        }
    }

    nonregularcount = bak_nonregularcount;
    samples = baksmaples;
}

void tetgenmesh::insertconstrainedpoints(tetgenio* addio) {
    point *insertarray, newpt;
    REAL x, y, z, w;
    int index, attribindex, mtrindex;
    int arylen, i, j;

    if (!b->quiet) {
        printf("Inserting constrained points ...\n");
    }

    insertarray = new point[addio->numberofpoints];
    arylen = 0;
    index = 0;
    attribindex = 0;
    mtrindex = 0;

    for (i = 0; i < addio->numberofpoints; i++) {
        x = addio->pointlist[index++];
        y = addio->pointlist[index++];
        z = addio->pointlist[index++];
        // Test if this point lies inside the bounding box.
        if ((x < xmin) || (x > xmax) || (y < ymin) || (y > ymax) || (z < zmin) || (z > zmax)) {
            if (b->verbose) {
                printf("Warning:  Point #%d lies outside the bounding box. Ignored\n",
                       i + in->firstnumber);
            }
            continue;
        }
        makepoint(&newpt, UNUSEDVERTEX);
        newpt[0] = x;
        newpt[1] = y;
        newpt[2] = z;
        // Read the point attributes. (Including point weights.)
        for (j = 0; j < addio->numberofpointattributes; j++) {
            newpt[3 + j] = addio->pointattributelist[attribindex++];
        }
        // Read the point metric tensor.
        for (j = 0; j < addio->numberofpointmtrs; j++) {
            newpt[pointmtrindex + j] = addio->pointmtrlist[mtrindex++];
        }
        if (b->weighted) { // -w option
            if (addio->numberofpointattributes > 0) {
                // The first point attribute is its weight.
                w = newpt[3];
            } else {
                // No given weight available. Default choose the maximum
                //   absolute value among its coordinates.
                w = fabs(x);
                if (w < fabs(y)) w = fabs(y);
                if (w < fabs(z)) w = fabs(z);
            }
            if (b->weighted_param == 0) {
                newpt[3] = x * x + y * y + z * z - w; // Weighted DT.
            } else {                                  // -w1 option
                newpt[3] = w;                         // Regular tetrahedralization.
            }
        }
        insertarray[arylen] = newpt;
        arylen++;
    } // i

    // Insert the points.
    int rejflag = 0;  // Do not check encroachment.
    if (b->metric) {  // -m option.
        rejflag |= 4; // Reject it if it lies in some protecting balls.
    }

    insertconstrainedpoints(insertarray, arylen, rejflag);

    delete[] insertarray;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// meshcoarsening()    Deleting (selected) vertices.                         //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::collectremovepoints(arraypool* remptlist) {
    point ptloop, *parypt;
    verttype vt;

    // If a mesh sizing function is given. Collect vertices whose mesh size
    //   is greater than its smallest edge length.
    if (b->metric) { // -m option
        REAL len, smlen;
        int i;
        points->traversalinit();
        ptloop = pointtraverse();
        while (ptloop != NULL) {
            // Do not remove a boundary vertex
            vt = pointtype(ptloop);
            if ((vt == RIDGEVERTEX) || (vt == ACUTEVERTEX) || (vt == FACETVERTEX) ||
                (vt == FREEFACETVERTEX) || (vt == FREESEGVERTEX) || (vt == UNUSEDVERTEX)) {
                ptloop = pointtraverse();
                continue;
            }
            if (ptloop[pointmtrindex] > 0) {
                // Get the smallest edge length at this vertex.
                getvertexstar(1, ptloop, cavetetlist, cavetetvertlist, NULL);
                parypt = (point*)fastlookup(cavetetvertlist, 0);
                smlen = distance(ptloop, *parypt);
                for (i = 1; i < cavetetvertlist->objects; i++) {
                    parypt = (point*)fastlookup(cavetetvertlist, i);
                    len = distance(ptloop, *parypt);
                    if (len < smlen) {
                        smlen = len;
                    }
                }
                cavetetvertlist->restart();
                cavetetlist->restart();
                if (smlen < ptloop[pointmtrindex]) {
                    pinfect(ptloop);
                    remptlist->newindex((void**)&parypt);
                    *parypt = ptloop;
                }
            }
            ptloop = pointtraverse();
        }
        if (b->verbose > 1) {
            printf("    Coarsen %ld oversized points.\n", remptlist->objects);
        }
    }

    // If 'in->pointmarkerlist' exists, Collect vertices with markers '-1'.
    if (in->pointmarkerlist != NULL) {
        long bak_count = remptlist->objects;
        points->traversalinit();
        ptloop = pointtraverse();
        int index = 0;
        while (ptloop != NULL) {
            if (index < in->numberofpoints) {
                if (in->pointmarkerlist[index] == -1) {
                    pinfect(ptloop);
                    remptlist->newindex((void**)&parypt);
                    *parypt = ptloop;
                }
            } else {
                // Remaining are not input points. Stop here.
                break;
            }
            index++;
            ptloop = pointtraverse();
        }
        if (b->verbose > 1) {
            printf("    Coarsen %ld marked points.\n", remptlist->objects - bak_count);
        }
    } // if (in->pointmarkerlist != NULL)

    if (b->coarsen_param > 0) { // -R1/#
        // Remove a coarsen_percent number of interior points.
        if (b->verbose > 1) {
            printf("    Coarsen %g percent of interior points.\n", b->coarsen_percent * 100.0);
        }
        arraypool* intptlist = new arraypool(sizeof(point*), 10);
        // Count the total number of interior points.
        points->traversalinit();
        ptloop = pointtraverse();
        while (ptloop != NULL) {
            vt = pointtype(ptloop);
            if ((vt == VOLVERTEX) || (vt == FREEVOLVERTEX) || (vt == FREEFACETVERTEX) ||
                (vt == FREESEGVERTEX)) {
                intptlist->newindex((void**)&parypt);
                *parypt = ptloop;
            }
            ptloop = pointtraverse();
        }
        if (intptlist->objects > 0l) {
            // Sort the list of points randomly.
            point *parypt_i, swappt;
            int randindex, i;
            srand(intptlist->objects);
            for (i = 0; i < intptlist->objects; i++) {
                randindex = rand() % (i + 1); // randomnation(i + 1);
                parypt_i = (point*)fastlookup(intptlist, i);
                parypt = (point*)fastlookup(intptlist, randindex);
                // Swap this two points.
                swappt = *parypt_i;
                *parypt_i = *parypt;
                *parypt = swappt;
            }
            int remcount = (int)((REAL)intptlist->objects * b->coarsen_percent);
            // Return the first remcount points.
            for (i = 0; i < remcount; i++) {
                parypt_i = (point*)fastlookup(intptlist, i);
                if (!pinfected(*parypt_i)) {
                    pinfected(*parypt_i);
                    remptlist->newindex((void**)&parypt);
                    *parypt = *parypt_i;
                }
            }
        }
        delete intptlist;
    }

    // Unmark all collected vertices.
    for (int i = 0; i < remptlist->objects; i++) {
        parypt = (point*)fastlookup(remptlist, i);
        puninfect(*parypt);
    }
}

void tetgenmesh::meshcoarsening() {
    arraypool* remptlist;

    if (!b->quiet) {
        printf("Mesh coarsening ...\n");
    }

    // Collect the set of points to be removed
    remptlist = new arraypool(sizeof(point*), 10);
    collectremovepoints(remptlist);

    if (remptlist->objects == 0l) {
        delete remptlist;
        return;
    }

    if (b->verbose) {
        if (remptlist->objects > 0l) {
            printf("  Removing %ld points...\n", remptlist->objects);
        }
    }

    point *parypt, *plastpt;
    long ms = remptlist->objects;
    int nit = 0;
    int bak_fliplinklevel = b->fliplinklevel;
    b->fliplinklevel = -1;
    autofliplinklevel = 1; // Init value.
    int i;

    while (1) {

        if (b->verbose > 1) {
            printf("    Removing points [%s level = %2d] #:  %ld.\n",
                   (b->fliplinklevel > 0) ? "fixed" : "auto",
                   (b->fliplinklevel > 0) ? b->fliplinklevel : autofliplinklevel,
                   remptlist->objects);
        }

        // Remove the list of points.
        for (i = 0; i < remptlist->objects; i++) {
            parypt = (point*)fastlookup(remptlist, i);
            if (removevertexbyflips(*parypt)) {
                // Move the last entry to the current place.
                plastpt = (point*)fastlookup(remptlist, remptlist->objects - 1);
                *parypt = *plastpt;
                remptlist->objects--;
                i--;
            }
        }

        if (remptlist->objects > 0l) {
            if (b->fliplinklevel >= 0) {
                break; // We have tried all levels.
            }
            if (remptlist->objects == ms) {
                nit++;
                if (nit >= 3) {
                    // Do the last round with unbounded flip link level.
                    b->fliplinklevel = 100000;
                }
            } else {
                ms = remptlist->objects;
                if (nit > 0) {
                    nit--;
                }
            }
            autofliplinklevel += b->fliplinklevelinc;
        } else {
            // All points are removed.
            break;
        }
    } // while (1)

    if (remptlist->objects > 0l) {
        if (b->verbose) {
            printf("  %ld points are not removed !\n", remptlist->objects);
        }
    }

    b->fliplinklevel = bak_fliplinklevel;
    delete remptlist;
}

////                                                                       ////
////                                                                       ////
//// reconstruct_cxx //////////////////////////////////////////////////////////

//// refine_cxx ///////////////////////////////////////////////////////////////
////                                                                       ////
////                                                                       ////

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// makefacetverticesmap()    Create a map from facet to its vertices.        //
//                                                                           //
// All facets will be indexed (starting from 0).  The map is saved in two    //
// global arrays: 'idx2facetlist' and 'facetverticeslist'.                   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::makefacetverticesmap() {
    arraypool *facetvertexlist, *vertlist, **paryvertlist;
    face subloop, neighsh, *parysh, *parysh1;
    point pa, *ppt, *parypt;
    verttype vt;
    int facetindex, totalvertices;
    int i, j, k;

    if (b->verbose) {
        printf("  Creating the facet vertices map.\n");
    }

    facetvertexlist = new arraypool(sizeof(arraypool*), 10);
    facetindex = totalvertices = 0;

    subfaces->traversalinit();
    subloop.sh = shellfacetraverse(subfaces);
    while (subloop.sh != NULL) {
        if (!sinfected(subloop)) {
            // A new facet. Create its vertices list.
            vertlist = new arraypool(sizeof(point*), 8);
            ppt = (point*)&(subloop.sh[3]);
            for (k = 0; k < 3; k++) {
                vt = pointtype(ppt[k]);
                if ((vt != FREESEGVERTEX) && (vt != FREEFACETVERTEX)) {
                    pinfect(ppt[k]);
                    vertlist->newindex((void**)&parypt);
                    *parypt = ppt[k];
                }
            }
            sinfect(subloop);
            caveshlist->newindex((void**)&parysh);
            *parysh = subloop;
            for (i = 0; i < caveshlist->objects; i++) {
                parysh = (face*)fastlookup(caveshlist, i);
                setfacetindex(*parysh, facetindex);
                for (j = 0; j < 3; j++) {
                    if (!isshsubseg(*parysh)) {
                        spivot(*parysh, neighsh);
                        if (!sinfected(neighsh)) {
                            pa = sapex(neighsh);
                            if (!pinfected(pa)) {
                                vt = pointtype(pa);
                                if ((vt != FREESEGVERTEX) && (vt != FREEFACETVERTEX)) {
                                    pinfect(pa);
                                    vertlist->newindex((void**)&parypt);
                                    *parypt = pa;
                                }
                            }
                            sinfect(neighsh);
                            caveshlist->newindex((void**)&parysh1);
                            *parysh1 = neighsh;
                        }
                    }
                    senextself(*parysh);
                }
            } // i
            totalvertices += (int)vertlist->objects;
            // Uninfect facet vertices.
            for (k = 0; k < vertlist->objects; k++) {
                parypt = (point*)fastlookup(vertlist, k);
                puninfect(*parypt);
            }
            caveshlist->restart();
            // Save this vertex list.
            facetvertexlist->newindex((void**)&paryvertlist);
            *paryvertlist = vertlist;
            facetindex++;
        }
        subloop.sh = shellfacetraverse(subfaces);
    }

    // All subfaces are infected. Uninfect them.
    subfaces->traversalinit();
    subloop.sh = shellfacetraverse(subfaces);
    while (subloop.sh != NULL) {
        suninfect(subloop);
        subloop.sh = shellfacetraverse(subfaces);
    }

    if (b->verbose) {
        printf("  Found %ld facets.\n", facetvertexlist->objects);
    }

    idx2facetlist = new int[facetindex + 1];
    facetverticeslist = new point[totalvertices];

    totalworkmemory += ((facetindex + 1) * sizeof(int) + totalvertices * sizeof(point*));

    idx2facetlist[0] = 0;
    for (i = 0, k = 0; i < facetindex; i++) {
        paryvertlist = (arraypool**)fastlookup(facetvertexlist, i);
        vertlist = *paryvertlist;
        idx2facetlist[i + 1] = (idx2facetlist[i] + (int)vertlist->objects);
        for (j = 0; j < vertlist->objects; j++) {
            parypt = (point*)fastlookup(vertlist, j);
            facetverticeslist[k] = *parypt;
            k++;
        }
    }

    // Free the lists.
    for (i = 0; i < facetvertexlist->objects; i++) {
        paryvertlist = (arraypool**)fastlookup(facetvertexlist, i);
        vertlist = *paryvertlist;
        delete vertlist;
    }
    delete facetvertexlist;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Check whether two segments, or a segment and a facet, or two facets are   //
// adjacent to each other.                                                   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::segsegadjacent(face* seg1, face* seg2) {
    int segidx1 = getfacetindex(*seg1);
    int segidx2 = getfacetindex(*seg2);

    if (segidx1 == segidx2) return 0;

    point pa1 = segmentendpointslist[segidx1 * 2];
    point pb1 = segmentendpointslist[segidx1 * 2 + 1];
    point pa2 = segmentendpointslist[segidx2 * 2];
    point pb2 = segmentendpointslist[segidx2 * 2 + 1];

    if ((pa1 == pa2) || (pa1 == pb2) || (pb1 == pa2) || (pb1 == pb2)) {
        return 1;
    }
    return 0;
}

int tetgenmesh::segfacetadjacent(face* subseg, face* subsh) {
    int segidx = getfacetindex(*subseg);
    point pa = segmentendpointslist[segidx * 2];
    point pb = segmentendpointslist[segidx * 2 + 1];

    pinfect(pa);
    pinfect(pb);

    int fidx = getfacetindex(*subsh);
    int count = 0, i;

    for (i = idx2facetlist[fidx]; i < idx2facetlist[fidx + 1]; i++) {
        if (pinfected(facetverticeslist[i])) count++;
    }

    puninfect(pa);
    puninfect(pb);

    return count == 1;
}

int tetgenmesh::facetfacetadjacent(face* subsh1, face* subsh2) {
    int count = 0, i;

    int fidx1 = getfacetindex(*subsh1);
    int fidx2 = getfacetindex(*subsh2);

    if (fidx1 == fidx2) return 0;

    for (i = idx2facetlist[fidx1]; i < idx2facetlist[fidx1 + 1]; i++) {
        pinfect(facetverticeslist[i]);
    }

    for (i = idx2facetlist[fidx2]; i < idx2facetlist[fidx2 + 1]; i++) {
        if (pinfected(facetverticeslist[i])) count++;
    }

    // Uninfect the vertices.
    for (i = idx2facetlist[fidx1]; i < idx2facetlist[fidx1 + 1]; i++) {
        puninfect(facetverticeslist[i]);
    }

    return count > 0;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// save_segmentpoint_insradius(), save_facetpoint_insradius()                //
//                                                                           //
// Determine and save the relaxed insertion radius of a Steiner point on a   //
// segment or a facet.  By default, it is the closet distance to the parent  //
// point of this Steiner point. But may be larger than it.                   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::save_segmentpoint_insradius(point segpt, point parentpt, REAL r) {
    REAL rv = r, rp;
    if (pointtype(parentpt) == FREESEGVERTEX) {
        face parentseg1, parentseg2;
        sdecode(point2sh(segpt), parentseg1);
        sdecode(point2sh(parentpt), parentseg2);
        if (segsegadjacent(&parentseg1, &parentseg2)) {
            rp = getpointinsradius(parentpt);
            if (rv < rp) {
                // The relaxed insertion radius of 'newpt'.
                rv = rp;
            }
        }
    } else if (pointtype(parentpt) == FREEFACETVERTEX) {
        face parentseg, parentsh;
        sdecode(point2sh(segpt), parentseg);
        sdecode(point2sh(parentpt), parentsh);
        if (segfacetadjacent(&parentseg, &parentsh)) {
            rp = getpointinsradius(parentpt);
            if ((sqrt(2.0) * rv) < rp) { // if (rv < rp) {
                // The relaxed insertion radius of 'newpt'.
                rv = rp / sqrt(2.0); // rv = rp;
            }
        }
    }
    setpointinsradius(segpt, rv);
}

void tetgenmesh::save_facetpoint_insradius(point facpt, point parentpt, REAL r) {
    REAL rv = r, rp;
    if (pointtype(parentpt) == FREESEGVERTEX) {
        face parentseg, parentsh;
        sdecode(point2sh(parentpt), parentseg);
        sdecode(point2sh(facpt), parentsh);
        if (segfacetadjacent(&parentseg, &parentsh)) {
            rp = getpointinsradius(parentpt);
            if (rv < (sqrt(2.0) * rp)) {
                rv = sqrt(2.0) * rp; // The relaxed insertion radius of 'newpt'.
            }
        }
    } else if (pointtype(parentpt) == FREEFACETVERTEX) {
        face parentsh1, parentsh2;
        sdecode(point2sh(parentpt), parentsh1);
        sdecode(point2sh(facpt), parentsh2);
        if (facetfacetadjacent(&parentsh1, &parentsh2)) {
            rp = getpointinsradius(parentpt);
            if (rv < rp) {
                rv = rp; // The relaxed insertion radius of 'newpt'.
            }
        }
    }
    setpointinsradius(facpt, rv);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// enqueuesubface()    Queue a subface or a subsegment for encroachment chk. //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::enqueuesubface(memorypool* pool, face* chkface) {
    if (!smarktest2ed(*chkface)) {
        smarktest2(*chkface); // Only queue it once.
        face* queface = (face*)pool->alloc();
        *queface = *chkface;
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// enqueuetetrahedron()    Queue a tetrahedron for quality check.            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::enqueuetetrahedron(triface* chktet) {
    if (!marktest2ed(*chktet)) {
        marktest2(*chktet); // Only queue it once.
        triface* quetet = (triface*)badtetrahedrons->alloc();
        *quetet = *chktet;
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// checkseg4encroach()    Check if an edge is encroached upon by a point.    //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::checkseg4encroach(point pa, point pb, point checkpt) {
    // Check if the point lies inside the diametrical sphere of this seg.
    REAL v1[3], v2[3];

    v1[0] = pa[0] - checkpt[0];
    v1[1] = pa[1] - checkpt[1];
    v1[2] = pa[2] - checkpt[2];
    v2[0] = pb[0] - checkpt[0];
    v2[1] = pb[1] - checkpt[1];
    v2[2] = pb[2] - checkpt[2];

    if (dot(v1, v2) < 0) {
        // Inside.
        if (b->metric) { // -m option.
            if ((pa[pointmtrindex] > 0) && (pb[pointmtrindex] > 0)) {
                // The projection of 'checkpt' lies inside the segment [a,b].
                REAL prjpt[3], u, v, t;
                projpt2edge(checkpt, pa, pb, prjpt);
                // Interoplate the mesh size at the location 'prjpt'.
                u = distance(pa, pb);
                v = distance(pa, prjpt);
                t = v / u;
                // 'u' is the mesh size at 'prjpt'
                u = pa[pointmtrindex] + t * (pb[pointmtrindex] - pa[pointmtrindex]);
                v = distance(checkpt, prjpt);
                if (v < u) {
                    return 1; // Encroached prot-ball!
                }
            } else {
                return 1; // NO protecting ball. Encroached.
            }
        } else {
            return 1; // Inside! Encroached.
        }
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// checkseg4split()    Check if we need to split a segment.                  //
//                                                                           //
// A segment needs to be split if it is in the following case:               //
//  (1) It is encroached by an existing vertex.                              //
//  (2) It has bad quality (too long).                                       //
//  (3) Its length is larger than the mesh sizes at its endpoints.           //
//                                                                           //
// Return 1 if it needs to be split, otherwise, return 0.  'pencpt' returns  //
// an encroaching point if there exists. 'qflag' returns '1' if the segment  //
// has a length larger than the desired edge length.                         //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::checkseg4split(face* chkseg, point& encpt, int& qflag) {
    REAL ccent[3], len, r;
    int i;

    point forg = sorg(*chkseg);
    point fdest = sdest(*chkseg);

    // Initialize the return values.
    encpt = NULL;
    qflag = 0;

    len = distance(forg, fdest);
    r = 0.5 * len;
    for (i = 0; i < 3; i++) {
        ccent[i] = 0.5 * (forg[i] + fdest[i]);
    }

    // First check its quality.
    if (checkconstraints && (areabound(*chkseg) > 0.0)) {
        if (len > areabound(*chkseg)) {
            qflag = 1;
            return 1;
        }
    }

    if (b->fixedvolume) {
        if ((len * len * len) > b->maxvolume) {
            qflag = 1;
            return 1;
        }
    }

    if (b->metric) { // -m option. Check mesh size.
        // Check if the ccent lies outside one of the prot.balls at vertices.
        if (((forg[pointmtrindex] > 0) && (r > forg[pointmtrindex])) ||
            ((fdest[pointmtrindex]) > 0 && (r > fdest[pointmtrindex]))) {
            qflag = 1; // Enforce mesh size.
            return 1;
        }
    }

    // Second check if it is encroached.
    // Comment: There may exist more than one encroaching points of this segment.
    //   The 'encpt' returns the one which is closet to it.
    triface searchtet, spintet;
    point eapex;
    REAL d, diff, smdist = 0;
    int t1ver;

    sstpivot1(*chkseg, searchtet);
    spintet = searchtet;
    while (1) {
        eapex = apex(spintet);
        if (eapex != dummypoint) {
            d = distance(ccent, eapex);
            diff = d - r;
            if (fabs(diff) / r < b->epsilon) diff = 0.0; // Rounding.
            if (diff < 0) {
                // This segment is encroached by eapex.
                if (useinsertradius) {
                    if (encpt == NULL) {
                        encpt = eapex;
                        smdist = d;
                    } else {
                        // Choose the closet encroaching point.
                        if (d < smdist) {
                            encpt = eapex;
                            smdist = d;
                        }
                    }
                } else {
                    encpt = eapex;
                    break;
                }
            }
        }
        fnextself(spintet);
        if (spintet.tet == searchtet.tet) break;
    } // while (1)

    if (encpt != NULL) {
        return 1;
    }

    return 0; // No need to split it.
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// splitsegment()    Split a segment.                                        //
//                                                                           //
// The segment 'splitseg' is intended to be split. It will be split if it    //
// is in one of the following cases:                                         //
//   (1) It is encroached by an existing vertex 'encpt != NULL'; or          //
//   (2) It is in bad quality 'qflag == 1'; or                               //
//   (3) Its length is larger than the mesh sizes at its endpoints.          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::splitsegment(face* splitseg, point encpt, REAL rrp, point encpt1, point encpt2,
                             int qflag, int chkencflag) {

    if (!qflag && smarktest3ed(*splitseg)) {
        // Do not try to re-split a marked segment.
        return 0;
    }

    if (b->nobisect) { // With -Y option.
        // Only split this segment if it is allowed to be split.
        if (checkconstraints) {
            // Check if it has a non-zero length bound.
            if (areabound(*splitseg) == 0) {
                // It is not allowed.  However, if all of facets containing this seg
                //   is allowed to be split, we still split it.
                face parentsh, spinsh;
                // splitseg.shver = 0;
                spivot(*splitseg, parentsh);
                if (parentsh.sh == NULL) {
                    return 0; // A dangling segment. Do not split it.
                }
                spinsh = parentsh;
                while (1) {
                    if (areabound(spinsh) == 0) break;
                    spivotself(spinsh);
                    if (spinsh.sh == parentsh.sh) break;
                    if (spinsh.sh == NULL) break; // It belongs to only one facet.
                }
                if ((!spinsh.sh) || (areabound(spinsh) == 0)) {
                    // All facets at this seg are not allowed to be split.
                    return 0; // Do not split it.
                }
            }
        } else {
            return 0; // Do not split this segment.
        }
    } // if (b->nobisect)

    triface searchtet;
    face searchsh;
    point newpt;
    insertvertexflags ivf;

    makepoint(&newpt, FREESEGVERTEX);
    getsteinerptonsegment(splitseg, encpt, newpt);

    if (!qflag && !b->cdtrefine) {
        // Do not insert the point if it encroaches upon an adjacent segment.
        face parentsh;
        spivot(*splitseg, parentsh);
        if (parentsh.sh != NULL) {
            face spinsh, neighsh;
            face neighseg;
            spinsh = parentsh;
            while (1) {
                for (int i = 0; i < 2; i++) {
                    if (i == 0) {
                        senext(spinsh, neighsh);
                    } else {
                        senext2(spinsh, neighsh);
                    }
                    if (isshsubseg(neighsh)) {
                        sspivot(neighsh, neighseg);
                        if (checkseg4encroach(sorg(neighseg), sdest(neighseg), newpt)) {
                            pointdealloc(newpt);
                            return 0; // Do not split this segment.
                        }
                    }
                } // i
                spivotself(spinsh);
                if (spinsh.sh == NULL) break;
                if (spinsh.sh == parentsh.sh) break;
            } // while (1)
        }
    }

    // Split the segment by the Bowyer-Watson algorithm.
    sstpivot1(*splitseg, searchtet);
    ivf.iloc = (int)ONEDGE;
    ivf.bowywat = 3;   // Use Bowyer-Watson, preserve subsegments and subfaces;
    ivf.validflag = 1; // Validate the B-W cavity.
    ivf.lawson = 2;    // Do flips to recover Delaunayness.
    ivf.rejflag = 0;   // Do not check encroachment of new segments/facets.
    if (b->metric) {
        ivf.rejflag |= 4; // Do check encroachment of protecting balls.
    }
    ivf.chkencflag = chkencflag;
    ivf.sloc = (int)INSTAR; // ivf.iloc;
    ivf.sbowywat = 3;       // ivf.bowywat;  // Surface mesh options.
    ivf.splitbdflag = 1;
    ivf.respectbdflag = 1;
    ivf.assignmeshsize = b->metric;
    ivf.smlenflag = useinsertradius; // Return the closet mesh vertex.

    if (insertpoint(newpt, &searchtet, &searchsh, splitseg, &ivf)) {
        st_segref_count++;
        if (steinerleft > 0) steinerleft--;
        if (useinsertradius) {
            save_segmentpoint_insradius(newpt, ivf.parentpt, ivf.smlen);
        }
        if (flipstack != NULL) {
            flipconstraints fc;
            fc.chkencflag = chkencflag;
            fc.enqflag = 2;
            lawsonflip3d(&fc);
            unflipqueue->restart();
        }
        return 1;
    } else {
        // Point is not inserted.
        if (ivf.iloc == (int)NEARVERTEX) {
            terminatetetgen(this, 2);
        }
        pointdealloc(newpt);
        // Mark this segment to avoid splitting in the future.
        smarktest3(*splitseg);
        return 0;
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// repairencsegs()    Repair encroached (sub) segments.                      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::repairencsegs(int chkencflag) {
    face* bface;
    point encpt = NULL;
    int qflag = 0;

    // Loop until the pool 'badsubsegs' is empty. Note that steinerleft == -1
    //   if an unlimited number of Steiner points is allowed.
    while ((badsubsegs->items > 0) && (steinerleft != 0)) {
        badsubsegs->traversalinit();
        bface = (face*)badsubsegs->traverse();
        while ((bface != NULL) && (steinerleft != 0)) {
            // Skip a deleleted element.
            if (bface->shver >= 0) {
                // A queued segment may have been deleted (split).
                if ((bface->sh != NULL) && (bface->sh[3] != NULL)) {
                    // A queued segment may have been processed.
                    if (smarktest2ed(*bface)) {
                        sunmarktest2(*bface);
                        if (checkseg4split(bface, encpt, qflag)) {
                            splitsegment(bface, encpt, 0, NULL, NULL, qflag, chkencflag);
                        }
                    }
                }
                // Remove this entry from list.
                bface->shver = -1; // Signal it as a deleted element.
                badsubsegs->dealloc((void*)bface);
            }
            bface = (face*)badsubsegs->traverse();
        }
    }

    if (badsubsegs->items > 0) {
        if (b->verbose) {
            printf("The desired number of Steiner points is reached.\n");
        }
        badsubsegs->traversalinit();
        bface = (face*)badsubsegs->traverse();
        while (bface != NULL) {
            // Skip a deleleted element.
            if (bface->shver >= 0) {
                if ((bface->sh != NULL) && (bface->sh[3] != NULL)) {
                    if (smarktest2ed(*bface)) {
                        sunmarktest2(*bface);
                    }
                }
            }
            bface = (face*)badsubsegs->traverse();
        }
        badsubsegs->restart();
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// checkfac4encroach()    Check if a subface is encroached by a point.       //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::checkfac4encroach(point pa, point pb, point pc, point checkpt, REAL* cent,
                                  REAL* r) {
    REAL rd, len;
    int encroached = 0;

    circumsphere(pa, pb, pc, NULL, cent, &rd);
    if (rd == 0) {
        terminatetetgen(this, 2);
    }

    if (b->use_equatorial_lens) {
        REAL normal[3], fcenter[3];
        REAL xta, yta, zta;
        REAL multiplier;

        fcenter[0] = cent[0] - pc[0];
        fcenter[1] = cent[1] - pc[1];
        fcenter[2] = cent[2] - pc[2];

        // Get the normal of the oriented face [a->b->c], without normalized.
        facenormal(pa, pb, pc, normal, 1, NULL);
        multiplier =
            0.985 *
            sqrt((fcenter[0] * fcenter[0] + fcenter[1] * fcenter[1] + fcenter[2] * fcenter[2]) /
                 (3.0 * (normal[0] * normal[0] + normal[1] * normal[1] + normal[2] * normal[2])));
        xta = checkpt[0] - pc[0];
        yta = checkpt[1] - pc[1];
        zta = checkpt[2] - pc[2];
        // Make sure that the normal is pointing to "checkpt".
        if ((xta * normal[0] + yta * normal[1] + zta * normal[2]) < 0) {
            // Reverse the normal direction.
            normal[0] = -normal[0];
            normal[1] = -normal[1];
            normal[2] = -normal[2];
        }

        if (xta * xta + yta * yta + zta * zta <=
            2.0 * (xta * (fcenter[0] - multiplier * normal[0]) +
                   yta * (fcenter[1] - multiplier * normal[1]) +
                   zta * (fcenter[2] - multiplier * normal[2]))) {
            encroached = 1;
        }
    } else {
        len = distance(cent, checkpt);
        if ((fabs(len - rd) / rd) < b->epsilon) len = rd; // Rounding.
        if (len < rd) {
            encroached = 1;
        }
    }

    if (encroached) {
        // The point lies inside the circumsphere of this face.
        if (b->metric) { // -m option.
            if ((pa[pointmtrindex] > 0) && (pb[pointmtrindex] > 0) && (pc[pointmtrindex] > 0)) {
                // Get the projection of 'checkpt' in the plane of pa, pb, and pc.
                REAL prjpt[3], n[3];
                REAL a, a1, a2, a3;
                projpt2face(checkpt, pa, pb, pc, prjpt);
                // Get the face area of [a,b,c].
                facenormal(pa, pb, pc, n, 1, NULL);
                a = sqrt(dot(n, n));
                // Get the face areas of [a,b,p], [b,c,p], and [c,a,p].
                facenormal(pa, pb, prjpt, n, 1, NULL);
                a1 = sqrt(dot(n, n));
                facenormal(pb, pc, prjpt, n, 1, NULL);
                a2 = sqrt(dot(n, n));
                facenormal(pc, pa, prjpt, n, 1, NULL);
                a3 = sqrt(dot(n, n));
                if ((fabs(a1 + a2 + a3 - a) / a) < b->epsilon) {
                    // This face contains the projection.
                    // Get the mesh size at the location of the projection point.
                    rd = a1 / a * pc[pointmtrindex] + a2 / a * pa[pointmtrindex] +
                         a3 / a * pb[pointmtrindex];
                    len = distance(prjpt, checkpt);
                    if (len < rd) {
                        return 1; // Encroached.
                    }
                }
            } else {
                return 1; // No protecting ball. Encroached.
            }
        } else {
            *r = rd;
            return 1; // Encroached.
        }
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// checkfac4split()    Check if a subface needs to be split.                 //
//                                                                           //
// A subface needs to be split if it is in the following case:               //
//  (1) It is encroached by an existing vertex.                              //
//  (2) It has bad quality (has a small angle, -q).                          //
//  (3) It's area is larger than a prescribed value (.var).                  //
//                                                                           //
// Return 1 if it needs to be split, otherwise, return 0.                    //
// 'chkfac' represents its longest edge.                                     //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::checkfac4split(face* chkfac, point& encpt, int& qflag, REAL* cent) {
    point pa, pb, pc;
    REAL area, rd, len;
    REAL A[4][4], rhs[4], D;
    int indx[4];
    int i;

    encpt = NULL;
    qflag = 0;

    pa = sorg(*chkfac);
    pb = sdest(*chkfac);
    pc = sapex(*chkfac);

    // Compute the coefficient matrix A (3x3).
    A[0][0] = pb[0] - pa[0];
    A[0][1] = pb[1] - pa[1];
    A[0][2] = pb[2] - pa[2]; // vector V1 (pa->pb)
    A[1][0] = pc[0] - pa[0];
    A[1][1] = pc[1] - pa[1];
    A[1][2] = pc[2] - pa[2]; // vector V2 (pa->pc)
    cross(A[0], A[1], A[2]); // vector V3 (V1 X V2)

    area = 0.5 * sqrt(dot(A[2], A[2])); // The area of [a,b,c].

    // Compute the right hand side vector b (3x1).
    rhs[0] = 0.5 * dot(A[0], A[0]); // edge [a,b]
    rhs[1] = 0.5 * dot(A[1], A[1]); // edge [a,c]
    rhs[2] = 0.0;

    // Solve the 3 by 3 equations use LU decomposition with partial
    //   pivoting and backward and forward substitute.
    if (!lu_decmp(A, 3, indx, &D, 0)) {
        // A degenerate triangle.
        terminatetetgen(this, 2);
    }

    lu_solve(A, 3, indx, rhs, 0);
    cent[0] = pa[0] + rhs[0];
    cent[1] = pa[1] + rhs[1];
    cent[2] = pa[2] + rhs[2];
    rd = sqrt(rhs[0] * rhs[0] + rhs[1] * rhs[1] + rhs[2] * rhs[2]);

    if (checkconstraints && (areabound(*chkfac) > 0.0)) {
        // Check if the subface has too big area.
        if (area > areabound(*chkfac)) {
            qflag = 1;
            return 1;
        }
    }

    if (b->fixedvolume) {
        if ((area * sqrt(area)) > b->maxvolume) {
            qflag = 1;
            return 1;
        }
    }

    if (b->varvolume) {
        triface adjtet;
        REAL volbnd;
        int t1ver;

        stpivot(*chkfac, adjtet);
        if (!ishulltet(adjtet)) {
            volbnd = volumebound(adjtet.tet);
            if ((volbnd > 0) && (area * sqrt(area)) > volbnd) {
                qflag = 1;
                return 1;
            }
        }
        fsymself(adjtet);
        if (!ishulltet(adjtet)) {
            volbnd = volumebound(adjtet.tet);
            if ((volbnd > 0) && (area * sqrt(area)) > volbnd) {
                qflag = 1;
                return 1;
            }
        }
    }

    if (b->metric) { // -m option. Check mesh size.
        // Check if the ccent lies outside one of the prot.balls at vertices.
        if (((pa[pointmtrindex] > 0) && (rd > pa[pointmtrindex])) ||
            ((pb[pointmtrindex] > 0) && (rd > pb[pointmtrindex])) ||
            ((pc[pointmtrindex] > 0) && (rd > pc[pointmtrindex]))) {
            qflag = 1; // Enforce mesh size.
            return 1;
        }
    }

    triface searchtet;
    REAL smlen = 0;

    // Check if this subface is locally encroached.
    for (i = 0; i < 2; i++) {
        stpivot(*chkfac, searchtet);
        if (!ishulltet(searchtet)) {
            int encroached = 0;

            len = distance(oppo(searchtet), cent);
            if ((fabs(len - rd) / rd) < b->epsilon) len = rd; // Rounding.

            if (b->use_equatorial_lens) {
                point tettapex = oppo(searchtet);
                REAL normal[3], fcenter[3];
                REAL xta, yta, zta;
                REAL multiplier;
                // Get the normal of the oriented face [a->b->c], without normalized.
                point fa = org(searchtet);
                point fb = dest(searchtet);
                point fc = apex(searchtet);

                fcenter[0] = cent[0] - fc[0];
                fcenter[1] = cent[1] - fc[1];
                fcenter[2] = cent[2] - fc[2];

                facenormal(fa, fb, fc, normal, 1, NULL);
                multiplier = 0.985 * sqrt((fcenter[0] * fcenter[0] + fcenter[1] * fcenter[1] +
                                           fcenter[2] * fcenter[2]) /
                                          (3.0 * (normal[0] * normal[0] + normal[1] * normal[1] +
                                                  normal[2] * normal[2])));
                xta = tettapex[0] - fc[0];
                yta = tettapex[1] - fc[1];
                zta = tettapex[2] - fc[2];
                if (xta * xta + yta * yta + zta * zta <=
                    2.0 * (xta * (fcenter[0] - multiplier * normal[0]) +
                           yta * (fcenter[1] - multiplier * normal[1]) +
                           zta * (fcenter[2] - multiplier * normal[2]))) {
                    encroached = 1;
                }
            } else {
                if (len < rd) {
                    encroached = 1;
                }
            }

            if (encroached) {
                if (smlen == 0) {
                    smlen = len;
                    encpt = oppo(searchtet);
                } else {
                    if (len < smlen) {
                        smlen = len;
                        encpt = oppo(searchtet);
                    }
                }
                // return 1;
            }
        }
        sesymself(*chkfac);
    }

    return encpt != NULL; // return 0;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// splitsubface()    Split a subface.                                        //
//                                                                           //
// The subface may be encroached, or in bad-quality. It is split at its cir- //
// cumcenter ('ccent'). Do not split it if 'ccent' encroaches upon any seg-  //
// ment. Instead, one of the encroached segments is split.  It is possible   //
// that none of the encroached segments can be split.                        //
//                                                                           //
// The return value indicates whether a new point is inserted (> 0) or not   //
// (= 0).  Furthermore, it is inserted on an encroached segment (= 1) or     //
// in-side the facet (= 2).                                                  //
//                                                                           //
// 'encpt' is a vertex encroaching upon this subface, i.e., it causes the    //
// split of this subface. If 'encpt' is NULL, then the cause of the split    //
// this subface is a rejected tet circumcenter 'p', and 'encpt1' is the      //
// parent of 'p'.                                                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::splitsubface(face* splitfac, point encpt, point encpt1, int qflag, REAL* ccent,
                             int chkencflag) {

    if (!qflag && smarktest3ed(*splitfac)) {
        // Do not try to re-split a marked subface.
        return 0;
    }

    if (b->nobisect) { // With -Y option.
        if (checkconstraints) {
            // Only split if it is allowed to be split.
            // Check if this facet has a non-zero constraint.
            if (areabound(*splitfac) == 0) {
                return 0; // Do not split it.
            }
        } else {
            return 0;
        }
    } // if (b->nobisect)

    if (useinsertradius) {
        if (encpt != NULL) {
            REAL rp; // Insertion radius of newpt.
            REAL rv = distance(encpt, ccent);
            if (pointtype(encpt) == FREESEGVERTEX) {
                face parentseg;
                sdecode(point2sh(encpt), parentseg);
                if (segfacetadjacent(&parentseg, splitfac)) {
                    rp = getpointinsradius(encpt);
                    if (rv < (sqrt(2.0) * rp)) {
                        // This insertion may cause no termination.
                        return 0; // Reject the insertion of newpt.
                    }
                }
            } else if (pointtype(encpt) == FREEFACETVERTEX) {
                face parentsh;
                sdecode(point2sh(encpt), parentsh);
                if (facetfacetadjacent(&parentsh, splitfac)) {
                    rp = getpointinsradius(encpt);
                    if (rv < rp) {
                        return 0; // Reject the insertion of newpt.
                    }
                }
            }
        }
    } // if (useinsertradius)

    face searchsh;
    insertvertexflags ivf;
    point newpt;
    int i;

    // Initialize the inserting point.
    makepoint(&newpt, FREEFACETVERTEX);
    // Split the subface at its circumcenter.
    for (i = 0; i < 3; i++)
        newpt[i] = ccent[i];

    // Search a subface which contains 'newpt'.
    searchsh = *splitfac;
    // Calculate an above point. It lies above the plane containing
    //   the subface [a,b,c], and save it in dummypoint. Moreover,
    //   the vector cent->dummypoint is the normal of the plane.
    calculateabovepoint4(newpt, sorg(*splitfac), sdest(*splitfac), sapex(*splitfac));
    //   Parameters: 'aflag' = 1, - above point exists.
    //   'cflag' = 0, - non-convex, check co-planarity of the result.
    //   'rflag' = 0, - no need to round the locating result.
    ivf.iloc = (int)slocate(newpt, &searchsh, 1, 0, 0);

    if (!((ivf.iloc == (int)ONFACE) || (ivf.iloc == (int)ONEDGE))) {
        // Point location failed.
        pointdealloc(newpt);
        // Mark this subface to avoid splitting in the future.
        smarktest3(*splitfac);
        return 0;
    }

    triface searchtet;

    // Insert the point.
    stpivot(searchsh, searchtet);
    ivf.bowywat = 3; // Use Bowyer-Watson. Preserve subsegments and subfaces;
    ivf.lawson = 2;
    ivf.rejflag = 1; // Do check the encroachment of segments.
    if (b->metric) {
        ivf.rejflag |= 4; // Do check encroachment of protecting balls.
    }
    ivf.chkencflag = chkencflag;
    ivf.sloc = (int)INSTAR; // ivf.iloc;
    ivf.sbowywat = 3;       // ivf.bowywat;
    ivf.splitbdflag = 1;
    ivf.validflag = 1;
    ivf.respectbdflag = 1;
    ivf.assignmeshsize = b->metric;
    ivf.refineflag = 2;
    ivf.refinesh = *splitfac;
    ivf.smlenflag = useinsertradius; // Update the insertion radius.

    if (insertpoint(newpt, &searchtet, &searchsh, NULL, &ivf)) {
        st_facref_count++;
        if (steinerleft > 0) steinerleft--;
        if (useinsertradius) {
            save_facetpoint_insradius(newpt, ivf.parentpt, ivf.smlen);
        } // if (useinsertradius)
        if (flipstack != NULL) {
            flipconstraints fc;
            fc.chkencflag = chkencflag;
            fc.enqflag = 2;
            lawsonflip3d(&fc);
            unflipqueue->restart();
        }
        return 1;
    } else {
        // Point was not inserted.
        pointdealloc(newpt);
        if (ivf.iloc == (int)ENCSEGMENT) {
            // Select an encroached segment and split it.
            face* paryseg;
            int splitflag = 0;
            for (i = 0; i < encseglist->objects; i++) {
                paryseg = (face*)fastlookup(encseglist, i);
                if (splitsegment(paryseg, NULL, 0.0, encpt, encpt1, qflag, chkencflag | 1)) {
                    splitflag = 1; // A point is inserted on a segment.
                    break;
                }
            } // i
            encseglist->restart();
            if (splitflag) {
                // Some segments may need to be repaired.
                if (badsubsegs->items > 0) {
                    repairencsegs(chkencflag | 1);
                }
                return 1;
            }
        } else {
            if (ivf.iloc == (int)NEARVERTEX) {
                terminatetetgen(this, 2);
            }
        }
        // Mark this subface to avoid splitting in the future.
        smarktest3(*splitfac);
        return 0;
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// repairencfacs()    Repair encroached subfaces.                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::repairencfacs(int chkencflag) {
    face* bface;
    point encpt = NULL;
    int qflag = 0;
    REAL ccent[3];

    // Loop until the pool 'badsubfacs' is empty. Note that steinerleft == -1
    //   if an unlimited number of Steiner points is allowed.
    while ((badsubfacs->items > 0) && (steinerleft != 0)) {
        badsubfacs->traversalinit();
        bface = (face*)badsubfacs->traverse();
        while ((bface != NULL) && (steinerleft != 0)) {
            // Skip a deleted element.
            if (bface->shver >= 0) {
                // A queued subface may have been deleted (split).
                if ((bface->sh != NULL) && (bface->sh[3] != NULL)) {
                    // A queued subface may have been processed.
                    if (smarktest2ed(*bface)) {
                        sunmarktest2(*bface);
                        if (checkfac4split(bface, encpt, qflag, ccent)) {
                            splitsubface(bface, encpt, NULL, qflag, ccent, chkencflag);
                        }
                    }
                }
                bface->shver = -1;                 // Signal it as a deleted element.
                badsubfacs->dealloc((void*)bface); // Remove this entry from list.
            }
            bface = (face*)badsubfacs->traverse();
        }
    }

    if (badsubfacs->items > 0) {
        if (steinerleft == 0) {
            if (b->verbose) {
                printf("The desired number of Steiner points is reached.\n");
            }
        } else {
            terminatetetgen(this, 2);
        }
        badsubfacs->traversalinit();
        bface = (face*)badsubfacs->traverse();
        while (bface != NULL) {
            // Skip a deleted element.
            if (bface->shver >= 0) {
                if ((bface->sh != NULL) && (bface->sh[3] != NULL)) {
                    if (smarktest2ed(*bface)) {
                        sunmarktest2(*bface);
                    }
                }
            }
            bface = (face*)badsubfacs->traverse();
        }
        badsubfacs->restart();
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// checktet4split()    Check if the tet needs to be split.                   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::checktet4split(triface* chktet, int& qflag, REAL* ccent) {
    point pa, pb, pc, pd, *ppt;
    REAL vda[3], vdb[3], vdc[3];
    REAL vab[3], vbc[3], vca[3];
    REAL N[4][3], L[4], cosd[6], elen[6];
    REAL maxcosd, vol, volbnd, smlen = 0, rd;
    REAL A[4][4], rhs[4], D;
    int indx[4];
    int i, j;

    if (b->convex) { // -c
        // Skip this tet if it lies in the exterior.
        if (elemattribute(chktet->tet, numelemattrib - 1) == -1.0) {
            return 0;
        }
    }

    qflag = 0;

    pd = (point)chktet->tet[7];
    if (pd == dummypoint) {
        return 0; // Do not split a hull tet.
    }

    pa = (point)chktet->tet[4];
    pb = (point)chktet->tet[5];
    pc = (point)chktet->tet[6];

    // Get the edge vectors vda: d->a, vdb: d->b, vdc: d->c.
    // Set the matrix A = [vda, vdb, vdc]^T.
    for (i = 0; i < 3; i++)
        A[0][i] = vda[i] = pa[i] - pd[i];
    for (i = 0; i < 3; i++)
        A[1][i] = vdb[i] = pb[i] - pd[i];
    for (i = 0; i < 3; i++)
        A[2][i] = vdc[i] = pc[i] - pd[i];

    // Get the other edge vectors.
    for (i = 0; i < 3; i++)
        vab[i] = pb[i] - pa[i];
    for (i = 0; i < 3; i++)
        vbc[i] = pc[i] - pb[i];
    for (i = 0; i < 3; i++)
        vca[i] = pa[i] - pc[i];

    if (!lu_decmp(A, 3, indx, &D, 0)) {
        // A degenerated tet (vol = 0).
        // This is possible due to the use of exact arithmetic.  We temporarily
        //   leave this tet. It should be fixed by mesh optimization.
        return 0;
    }

    // Check volume if '-a#' and '-a' options are used.
    if (b->varvolume || b->fixedvolume) {
        vol = fabs(A[indx[0]][0] * A[indx[1]][1] * A[indx[2]][2]) / 6.0;
        if (b->fixedvolume) {
            if (vol > b->maxvolume) {
                qflag = 1;
            }
        }
        if (!qflag && b->varvolume) {
            volbnd = volumebound(chktet->tet);
            if ((volbnd > 0.0) && (vol > volbnd)) {
                qflag = 1;
            }
        }
        if (qflag == 1) {
            // Calculate the circumcenter of this tet.
            rhs[0] = 0.5 * dot(vda, vda);
            rhs[1] = 0.5 * dot(vdb, vdb);
            rhs[2] = 0.5 * dot(vdc, vdc);
            lu_solve(A, 3, indx, rhs, 0);
            for (i = 0; i < 3; i++)
                ccent[i] = pd[i] + rhs[i];
            return 1;
        }
    }

    if (b->metric) { // -m option. Check mesh size.
        // Calculate the circumradius of this tet.
        rhs[0] = 0.5 * dot(vda, vda);
        rhs[1] = 0.5 * dot(vdb, vdb);
        rhs[2] = 0.5 * dot(vdc, vdc);
        lu_solve(A, 3, indx, rhs, 0);
        for (i = 0; i < 3; i++)
            ccent[i] = pd[i] + rhs[i];
        rd = sqrt(dot(rhs, rhs));
        // Check if the ccent lies outside one of the prot.balls at vertices.
        ppt = (point*)&(chktet->tet[4]);
        for (i = 0; i < 4; i++) {
            if (ppt[i][pointmtrindex] > 0) {
                if (rd > ppt[i][pointmtrindex]) {
                    qflag = 1; // Enforce mesh size.
                    return 1;
                }
            }
        }
    }

    if (in->tetunsuitable != NULL) {
        // Execute the user-defined meshing sizing evaluation.
        if ((*(in->tetunsuitable))(pa, pb, pc, pd, NULL, 0)) {
            // Calculate the circumcenter of this tet.
            rhs[0] = 0.5 * dot(vda, vda);
            rhs[1] = 0.5 * dot(vdb, vdb);
            rhs[2] = 0.5 * dot(vdc, vdc);
            lu_solve(A, 3, indx, rhs, 0);
            for (i = 0; i < 3; i++)
                ccent[i] = pd[i] + rhs[i];
            return 1;
        }
    }

    if (useinsertradius) {
        // Do not split this tet if the shortest edge is shorter than the
        //   insertion radius of one of its endpoints.
        triface checkedge;
        point e1, e2;
        REAL rrv, smrrv;

        // Get the shortest edge of this tet.
        checkedge.tet = chktet->tet;
        for (i = 0; i < 6; i++) {
            checkedge.ver = edge2ver[i];
            e1 = org(checkedge);
            e2 = dest(checkedge);
            elen[i] = distance(e1, e2);
            if (i == 0) {
                smlen = elen[i];
                j = 0;
            } else {
                if (elen[i] < smlen) {
                    smlen = elen[i];
                    j = i;
                }
            }
        }
        // Check if the edge is too short.
        checkedge.ver = edge2ver[j];
        // Get the smallest rrv of e1 and e2.
        // Note: if rrv of e1 and e2 is zero. Do not use it.
        e1 = org(checkedge);
        smrrv = getpointinsradius(e1);
        e2 = dest(checkedge);
        rrv = getpointinsradius(e2);
        if (rrv > 0) {
            if (smrrv > 0) {
                if (rrv < smrrv) {
                    smrrv = rrv;
                }
            } else {
                smrrv = rrv;
            }
        }
        if (smrrv > 0) {
            // To avoid rounding error, round smrrv before doing comparison.
            if ((fabs(smrrv - smlen) / smlen) < b->epsilon) {
                smrrv = smlen;
            }
            if (smrrv > smlen) {
                return 0;
            }
        }
    } // if (useinsertradius)

    // Check the radius-edge ratio. Set by -q#.
    if (b->minratio > 0) {
        // Calculate the circumcenter and radius of this tet.
        rhs[0] = 0.5 * dot(vda, vda);
        rhs[1] = 0.5 * dot(vdb, vdb);
        rhs[2] = 0.5 * dot(vdc, vdc);
        lu_solve(A, 3, indx, rhs, 0);
        for (i = 0; i < 3; i++)
            ccent[i] = pd[i] + rhs[i];
        rd = sqrt(dot(rhs, rhs));
        if (!useinsertradius) {
            // Calculate the shortest edge length.
            elen[0] = dot(vda, vda);
            elen[1] = dot(vdb, vdb);
            elen[2] = dot(vdc, vdc);
            elen[3] = dot(vab, vab);
            elen[4] = dot(vbc, vbc);
            elen[5] = dot(vca, vca);
            smlen = elen[0]; // sidx = 0;
            for (i = 1; i < 6; i++) {
                if (smlen > elen[i]) {
                    smlen = elen[i]; // sidx = i;
                }
            }
            smlen = sqrt(smlen);
        }
        D = rd / smlen;
        if (D > b->minratio) {
            // A bad radius-edge ratio.
            return 1;
        }
    }

    // Check the minimum dihedral angle. Set by -qq#.
    if (b->mindihedral > 0) {
        // Compute the 4 face normals (N[0], ..., N[3]).
        for (j = 0; j < 3; j++) {
            for (i = 0; i < 3; i++)
                N[j][i] = 0.0;
            N[j][j] = 1.0; // Positive means the inside direction
            lu_solve(A, 3, indx, N[j], 0);
        }
        for (i = 0; i < 3; i++)
            N[3][i] = -N[0][i] - N[1][i] - N[2][i];
        // Normalize the normals.
        for (i = 0; i < 4; i++) {
            L[i] = sqrt(dot(N[i], N[i]));
            if (L[i] == 0) {
                terminatetetgen(this, 2);
            }
            for (j = 0; j < 3; j++)
                N[i][j] /= L[i];
        }
        // Calculate the six dihedral angles.
        cosd[0] = -dot(N[0], N[1]); // Edge cd, bd, bc.
        cosd[1] = -dot(N[0], N[2]);
        cosd[2] = -dot(N[0], N[3]);
        cosd[3] = -dot(N[1], N[2]); // Edge ad, ac
        cosd[4] = -dot(N[1], N[3]);
        cosd[5] = -dot(N[2], N[3]); // Edge ab
        // Get the smallest dihedral angle.
        // maxcosd = mincosd = cosd[0];
        maxcosd = cosd[0];
        for (i = 1; i < 6; i++) {
            // if (cosd[i] > maxcosd) maxcosd = cosd[i];
            maxcosd = (cosd[i] > maxcosd ? cosd[i] : maxcosd);
            // mincosd = (cosd[i] < mincosd ? cosd[i] : maxcosd);
        }
        if (maxcosd > cosmindihed) {
            // Calculate the circumcenter of this tet.
            // A bad dihedral angle.
            // if ((b->quality & 1) == 0) {
            rhs[0] = 0.5 * dot(vda, vda);
            rhs[1] = 0.5 * dot(vdb, vdb);
            rhs[2] = 0.5 * dot(vdc, vdc);
            lu_solve(A, 3, indx, rhs, 0);
            for (i = 0; i < 3; i++)
                ccent[i] = pd[i] + rhs[i];
            //*rd = sqrt(dot(rhs, rhs));
            //}
            return 1;
        }
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// splittetrahedron()    Split a tetrahedron.                                //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::splittetrahedron(triface* splittet, int qflag, REAL* ccent, int chkencflag) {
    triface searchtet;
    face* paryseg;
    point newpt, *ppt;
    badface* bface;
    insertvertexflags ivf;
    int splitflag = 0;
    int i;

    REAL rv = 0.; // Insertion radius of 'newpt'.

    makepoint(&newpt, FREEVOLVERTEX);
    for (i = 0; i < 3; i++)
        newpt[i] = ccent[i];

    // Locate the new point. Starting from an interior point 'q' of the
    //   splittet. We perform a walk from q to the 'newpt', stop walking
    //   either we hit a subface or enter OUTSIDE.
    searchtet = *splittet;
    ivf.iloc = (int)OUTSIDE;
    ivf.iloc = locate(newpt, &searchtet, 1); // 'chkencflag' = 1.

    if ((ivf.iloc == (int)OUTSIDE) || (ivf.iloc == (int)ENCSUBFACE)) {
        // The circumcenter 'c' is not visible from 'q' (the interior of the tet).
        // iffalse
        if (b->verbose > 2) {
            printf("    New point %d is blocked by a polygon.\n", pointmark(newpt));
        }
        // \fi
        pointdealloc(newpt);       // Do not insert this vertex.
        if (b->nobisect) return 0; // -Y option.
        // There must be a polygon that blocks the visibility.
        // Search a subpolygon that contains the proj(c).
        face searchsh;
        REAL prjpt[3];
        locateresult sloc = OUTSIDE;
        tspivot(searchtet, searchsh);
        ppt = (point*)&(searchsh.sh[3]);
        projpt2face(ccent, ppt[0], ppt[1], ppt[2], prjpt);
        // Locate proj(c) on polygon.
        sloc = slocate(prjpt, &searchsh, 0, 0, 1);
        if ((sloc == ONEDGE) || (sloc == ONFACE)) {
            // Found a subface/edge containing proj(c).
            // Check if 'c' encoraches upon this subface.
            REAL fcent[3], r = 0;
            ppt = (point*)&(searchsh.sh[3]);
            if (checkfac4encroach(ppt[0], ppt[1], ppt[2], ccent, fcent, &r)) {
                // Encroached. Split this subface.
                splitflag =
                    splitsubface(&searchsh, NULL, org(*splittet), qflag, fcent, chkencflag | 2);
                if (splitflag) {
                    // Some subfaces may need to be repaired.
                    repairencfacs(chkencflag | 2);
                }
            }
        } else if ((sloc == OUTSIDE) || (sloc == ENCSEGMENT)) {
            // Hit a segment. We should split it.
            // To be done...
            // printf("hit segment, split it.\n"); // For debug only
        }
        if (splitflag) {
            // Queue the tet if it is still alive.
            if ((splittet->tet != NULL) && (splittet->tet[4] != NULL)) {
                enqueuetetrahedron(splittet);
            }
        }
        return splitflag;
    }

    // Use Bowyer-Watson algorithm. Preserve subsegments and subfaces;
    ivf.bowywat = 3;
    ivf.lawson = 2;
    ivf.rejflag = 3; // Do check for encroached segments and subfaces.
    if (b->metric) {
        ivf.rejflag |= 4; // Reject it if it lies in some protecting balls.
    }
    ivf.chkencflag = chkencflag;
    ivf.sloc = ivf.sbowywat = 0; // No use.
    ivf.splitbdflag = 0;         // No use.
    ivf.validflag = 1;
    ivf.respectbdflag = 1;
    ivf.assignmeshsize = b->metric;

    ivf.refineflag = 1;
    ivf.refinetet = *splittet;
    if (useinsertradius) {
        // Need to save insertion radius for this new point.
        ivf.smlenflag = 1; // Return the shortest edge length after inserting
                           // the new vertex. [2016-09-19]
    }

    if (insertpoint(newpt, &searchtet, NULL, NULL, &ivf)) {
        // Vertex is inserted.
        st_volref_count++;
        if (steinerleft > 0) steinerleft--;
        if (useinsertradius) {
            setpointinsradius(newpt, ivf.smlen);
            setpoint2ppt(newpt, ivf.parentpt);
        }
        if (flipstack != NULL) {
            flipconstraints fc;
            fc.chkencflag = chkencflag;
            fc.enqflag = 2;
            lawsonflip3d(&fc);
            unflipqueue->restart();
        }
        return 1;
    } else {
        // Point is not inserted.
        pointdealloc(newpt);
        // Check if there are encroached segments/subfaces.
        if (ivf.iloc == (int)ENCSEGMENT) {
            if (!b->nobisect || checkconstraints) {
                // Select an encroached segment and split it.
                for (i = 0; i < encseglist->objects; i++) {
                    paryseg = (face*)fastlookup(encseglist, i);
                    if (splitsegment(paryseg, NULL, rv, org(*splittet), NULL, qflag,
                                     chkencflag | 3)) {
                        splitflag = 1; // A point is inserted on a segment.
                        break;
                    }
                }
            } // if (!b->nobisect)
            encseglist->restart();
            if (splitflag) {
                // Some segments may need to be repaired.
                if (badsubsegs->items > 0) {
                    repairencsegs(chkencflag | 3);
                }
                // Some subfaces may need to be repaired.
                if (badsubfacs->items > 0) {
                    repairencfacs(chkencflag | 2);
                }
            }
        } else if (ivf.iloc == (int)ENCSUBFACE) {
            if (!b->nobisect || checkconstraints) {
                // Select an encroached subface and split it.
                for (i = 0; i < encshlist->objects; i++) {
                    bface = (badface*)fastlookup(encshlist, i);
                    if (splitsubface(&(bface->ss), NULL, org(*splittet), qflag, bface->cent,
                                     chkencflag | 2)) {
                        splitflag = 1; // A point is inserted on a subface or a segment.
                        break;
                    }
                }
            } // if (!b->nobisect)
            encshlist->restart();
            if (splitflag) {
                // Some subfaces may need to be repaired.
                if (badsubfacs->items > 0) {
                    repairencfacs(chkencflag | 2);
                }
            }
        } else {
            if (ivf.iloc == (int)NEARVERTEX) {
                terminatetetgen(this, 2);
            }
        }
        if (splitflag) {
            // Queue the tet if it is still alive.
            if ((splittet->tet != NULL) && (splittet->tet[4] != NULL)) {
                enqueuetetrahedron(splittet);
            }
        } else {
            // assert(0); // If no small angle, why can this happen?
        }
        return splitflag;
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// repairbadtets()    Repair bad quality tetrahedra.                         //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::repairbadtets(int chkencflag) {
    triface* bface;
    REAL ccent[3];
    int qflag = 0;

    // Loop until the pool 'badsubfacs' is empty. Note that steinerleft == -1
    //   if an unlimited number of Steiner points is allowed.
    while ((badtetrahedrons->items > 0) && (steinerleft != 0)) {
        badtetrahedrons->traversalinit();
        bface = (triface*)badtetrahedrons->traverse();
        while ((bface != NULL) && (steinerleft != 0)) {
            // Skip a deleted element.
            if (bface->ver >= 0) {
                // A queued tet may have been deleted.
                if (!isdeadtet(*bface)) {
                    // A queued tet may have been processed.
                    if (marktest2ed(*bface)) {
                        unmarktest2(*bface);
                        if (checktet4split(bface, qflag, ccent)) {
                            splittetrahedron(bface, qflag, ccent, chkencflag);
                        }
                    }
                }
                bface->ver = -1; // Signal it as a deleted element.
                badtetrahedrons->dealloc((void*)bface);
            }
            bface = (triface*)badtetrahedrons->traverse();
        }
    }

    if (badtetrahedrons->items > 0) {
        if (steinerleft == 0) {
            if (b->verbose) {
                printf("The desired number of Steiner points is reached.\n");
            }
        } else {
            terminatetetgen(this, 2); // Unknown case.
        }
        // Unmark all queued tet.
        badtetrahedrons->traversalinit();
        bface = (triface*)badtetrahedrons->traverse();
        while (bface != NULL) {
            // Skip a deleted element.
            if (bface->ver >= 0) {
                if (!isdeadtet(*bface)) {
                    if (marktest2ed(*bface)) {
                        unmarktest2(*bface);
                    }
                }
            }
            bface = (triface*)badtetrahedrons->traverse();
        }
        // Clear the pool.
        badtetrahedrons->restart();
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// delaunayrefinement()    Refine the mesh by Delaunay refinement.           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::delaunayrefinement() {
    triface checktet;
    face checksh;
    face checkseg;
    long steinercount;
    int chkencflag;

    long bak_segref_count, bak_facref_count, bak_volref_count;
    long bak_flipcount = flip23count + flip32count + flip44count;

    if (!b->quiet) {
        printf("Refining mesh...\n");
    }

    if (b->verbose) {
        printf("  Min radius-edge ratio = %g.\n", b->minratio);
        printf("  Min dihedral   angle  = %g.\n", b->mindihedral);
        // printf("  Min Edge length = %g.\n", b->minedgelength);
    }

    steinerleft = b->steinerleft; // Upperbound of # Steiner points (by -S#).
    if (steinerleft > 0) {
        // Check if we've already used up the given number of Steiner points.
        steinercount = st_segref_count + st_facref_count + st_volref_count;
        if (steinercount < steinerleft) {
            steinerleft -= steinercount;
        } else {
            if (!b->quiet) {
                printf("\nWarning:  ");
                printf("The desired number of Steiner points (%d) has reached.\n\n",
                       b->steinerleft);
            }
            return; // No more Steiner points.
        }
    }

    if (useinsertradius) {
        if ((b->plc && b->nobisect) || b->refine) { // '-pY' or '-r' option.
            makesegmentendpointsmap();
            makefacetverticesmap();
        }
    }

    encseglist = new arraypool(sizeof(face), 8);
    encshlist = new arraypool(sizeof(badface), 8);

    // if (!b->nobisect) { // if no '-Y' option
    if (!b->nobisect || checkconstraints) {
        if (b->verbose) {
            printf("  Splitting encroached subsegments.\n");
        }

        chkencflag = 1; // Only check encroaching subsegments.
        steinercount = points->items;

        // Initialize the pool of encroached subsegments.
        badsubsegs = new memorypool(sizeof(face), b->shellfaceperblock, sizeof(void*), 0);

        // Add all segments into the pool.
        subsegs->traversalinit();
        checkseg.sh = shellfacetraverse(subsegs);
        while (checkseg.sh != (shellface*)NULL) {
            enqueuesubface(badsubsegs, &checkseg);
            checkseg.sh = shellfacetraverse(subsegs);
        }

        // Split all encroached segments.
        repairencsegs(chkencflag);

        if (b->verbose) {
            printf("  Added %ld Steiner points.\n", points->items - steinercount);
        }

        if (b->reflevel > 1) { // '-D2' option
            if (b->verbose) {
                printf("  Splitting encroached subfaces.\n");
            }

            chkencflag = 2; // Only check encroaching subfaces.
            steinercount = points->items;
            bak_segref_count = st_segref_count;
            bak_facref_count = st_facref_count;

            // Initialize the pool of encroached subfaces.
            badsubfacs = new memorypool(sizeof(face), b->shellfaceperblock, sizeof(void*), 0);

            // Add all subfaces into the pool.
            subfaces->traversalinit();
            checksh.sh = shellfacetraverse(subfaces);
            while (checksh.sh != (shellface*)NULL) {
                enqueuesubface(badsubfacs, &checksh);
                checksh.sh = shellfacetraverse(subfaces);
            }

            // Split all encroached subfaces.
            repairencfacs(chkencflag);

            if (b->verbose) {
                printf("  Added %ld (%ld,%ld) Steiner points.\n", points->items - steinercount,
                       st_segref_count - bak_segref_count, st_facref_count - bak_facref_count);
            }
        } // if (b->reflevel > 1)
    }     // if (!b->nobisect)

    if (b->reflevel > 2) { // '-D3' option (The default option)
        if (b->verbose) {
            printf("  Splitting bad quality tets.\n");
        }

        chkencflag = 4; // Only check tetrahedra.
        steinercount = points->items;
        bak_segref_count = st_segref_count;
        bak_facref_count = st_facref_count;
        bak_volref_count = st_volref_count;

        // The cosine value of the min dihedral angle (-qq) for tetrahedra.
        cosmindihed = cos(b->mindihedral / 180.0 * PI);

        // Initialize the pool of bad quality tetrahedra.
        badtetrahedrons = new memorypool(sizeof(triface), b->tetrahedraperblock, sizeof(void*), 0);
        // Add all tetrahedra (no hull tets) into the pool.
        tetrahedrons->traversalinit();
        checktet.tet = tetrahedrontraverse();
        while (checktet.tet != NULL) {
            enqueuetetrahedron(&checktet);
            checktet.tet = tetrahedrontraverse();
        }

        // Split all bad quality tetrahedra.
        repairbadtets(chkencflag);

        if (b->verbose) {
            printf("  Added %ld (%ld,%ld,%ld) Steiner points.\n", points->items - steinercount,
                   st_segref_count - bak_segref_count, st_facref_count - bak_facref_count,
                   st_volref_count - bak_volref_count);
        }
    } // if (b->reflevel > 2)

    if (b->verbose) {
        if (flip23count + flip32count + flip44count > bak_flipcount) {
            printf("  Performed %ld flips.\n",
                   flip23count + flip32count + flip44count - bak_flipcount);
        }
    }

    if (steinerleft == 0) {
        if (!b->quiet) {
            printf("\nWarnning:  ");
            printf("The desired number of Steiner points (%d) is reached.\n\n", b->steinerleft);
        }
    }

    delete encseglist;
    delete encshlist;
    encseglist = NULL;
    encshlist = NULL;

    if (!b->nobisect || checkconstraints) {
        totalworkmemory += (badsubsegs->maxitems * badsubsegs->itembytes);
        delete badsubsegs;
        badsubsegs = NULL;
        if (b->reflevel > 1) {
            totalworkmemory += (badsubfacs->maxitems * badsubfacs->itembytes);
            delete badsubfacs;
            badsubfacs = NULL;
        }
    }
    if (b->reflevel > 2) {
        totalworkmemory += (badtetrahedrons->maxitems * badtetrahedrons->itembytes);
        delete badtetrahedrons;
        badtetrahedrons = NULL;
    }
}

////                                                                       ////
////                                                                       ////
//// refine_cxx ///////////////////////////////////////////////////////////////

//// optimize_cxx /////////////////////////////////////////////////////////////
////                                                                       ////
////                                                                       ////

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// lawsonflip3d()    A three-dimensional Lawson's algorithm.                 //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

long tetgenmesh::lawsonflip3d(flipconstraints* fc) {
    triface fliptets[5], neightet, hulltet;
    face checksh, casingout;
    badface *popface, *bface;
    point pd, pe, *pts;
    REAL sign, ori;
    REAL vol, len3;
    long flipcount, totalcount = 0l;
    long sliver_peels = 0l;
    int t1ver;
    int i;

    while (1) {

        if (b->verbose > 2) {
            printf("      Lawson flip %ld faces.\n", flippool->items);
        }
        flipcount = 0l;

        while (flipstack != (badface*)NULL) {
            // Pop a face from the stack.
            popface = flipstack;
            fliptets[0] = popface->tt;
            flipstack = flipstack->nextitem; // The next top item in stack.
            flippool->dealloc((void*)popface);

            // Skip it if it is a dead tet (destroyed by previous flips).
            if (isdeadtet(fliptets[0])) continue;
            // Skip it if it is not the same tet as we saved.
            if (!facemarked(fliptets[0])) continue;

            unmarkface(fliptets[0]);

            if (ishulltet(fliptets[0])) continue;

            fsym(fliptets[0], fliptets[1]);
            if (ishulltet(fliptets[1])) {
                if (nonconvex) {
                    // Check if 'fliptets[0]' it is a hull sliver.
                    tspivot(fliptets[0], checksh);
                    for (i = 0; i < 3; i++) {
                        if (!isshsubseg(checksh)) {
                            spivot(checksh, casingout);
                            // assert(casingout.sh != NULL);
                            if (sorg(checksh) != sdest(casingout)) sesymself(casingout);
                            stpivot(casingout, neightet);
                            if (neightet.tet == fliptets[0].tet) {
                                // Found a hull sliver 'neightet'. Let it be [e,d,a,b], where
                                //   [e,d,a] and [d,e,b] are hull faces.
                                edestoppo(neightet, hulltet); // [a,b,e,d]
                                fsymself(hulltet);            // [b,a,e,#]
                                if (oppo(hulltet) == dummypoint) {
                                    pe = org(neightet);
                                    if ((pointtype(pe) == FREEFACETVERTEX) ||
                                        (pointtype(pe) == FREESEGVERTEX)) {
                                        removevertexbyflips(pe);
                                    }
                                } else {
                                    eorgoppo(neightet, hulltet); // [b,a,d,e]
                                    fsymself(hulltet);           // [a,b,d,#]
                                    if (oppo(hulltet) == dummypoint) {
                                        pd = dest(neightet);
                                        if ((pointtype(pd) == FREEFACETVERTEX) ||
                                            (pointtype(pd) == FREESEGVERTEX)) {
                                            removevertexbyflips(pd);
                                        }
                                    } else {
                                        // Perform a 3-to-2 flip to remove the sliver.
                                        fliptets[0] = neightet;          // [e,d,a,b]
                                        fnext(fliptets[0], fliptets[1]); // [e,d,b,c]
                                        fnext(fliptets[1], fliptets[2]); // [e,d,c,a]
                                        flip32(fliptets, 1, fc);
                                        // Update counters.
                                        flip32count--;
                                        flip22count--;
                                        sliver_peels++;
                                        if (fc->remove_ndelaunay_edge) {
                                            // Update the volume (must be decreased).
                                            // assert(fc->tetprism_vol_sum <= 0);
                                            tetprism_vol_sum += fc->tetprism_vol_sum;
                                            fc->tetprism_vol_sum = 0.0; // Clear it.
                                        }
                                    }
                                }
                                break;
                            } // if (neightet.tet == fliptets[0].tet)
                        }     // if (!isshsubseg(checksh))
                        senextself(checksh);
                    } // i
                }     // if (nonconvex)
                continue;
            }

            if (checksubfaceflag) {
                // Do not flip if it is a subface.
                if (issubface(fliptets[0])) continue;
            }

            // Test whether the face is locally Delaunay or not.
            pts = (point*)fliptets[1].tet;
            sign = insphere_s(pts[4], pts[5], pts[6], pts[7], oppo(fliptets[0]));

            if (sign < 0) {
                // A non-Delaunay face. Try to flip it.
                pd = oppo(fliptets[0]);
                pe = oppo(fliptets[1]);

                // Use the length of the edge [d,e] as a reference to determine
                //   a nearly degenerated new tet.
                len3 = distance(pd, pe);
                len3 = (len3 * len3 * len3);
                int round_flag = 0; // [2017-10-20]
                // Check the convexity of its three edges. Stop checking either a
                //   locally non-convex edge (ori < 0) or a flat edge (ori = 0) is
                //   encountered, and 'fliptet' represents that edge.
                for (i = 0; i < 3; i++) {
                    ori = orient3d(org(fliptets[0]), dest(fliptets[0]), pd, pe);
                    if (ori > 0) {
                        // Avoid creating a nearly degenerated new tet at boundary.
                        //   Re-use fliptets[2], fliptets[3];
                        esym(fliptets[0], fliptets[2]);
                        esym(fliptets[1], fliptets[3]);
                        if (issubface(fliptets[2]) || issubface(fliptets[3])) {
                            vol = orient3dfast(org(fliptets[0]), dest(fliptets[0]), pd, pe);
                            if ((fabs(vol) / len3) < b->epsilon) {
                                ori = 0.0;      // Do rounding.
                                round_flag = 1; // [2017-10-20]
                            }
                        }
                    } // Rounding check
                    if (ori <= 0) break;
                    enextself(fliptets[0]);
                    eprevself(fliptets[1]);
                }

                if (ori > 0) {
                    // A 2-to-3 flip is found.
                    //   [0] [a,b,c,d],
                    //   [1] [b,a,c,e]. no dummypoint.
                    flip23(fliptets, 0, fc);
                    flipcount++;
                    if (fc->remove_ndelaunay_edge) {
                        // Update the volume (must be decreased).
                        // assert(fc->tetprism_vol_sum <= 0);
                        tetprism_vol_sum += fc->tetprism_vol_sum;
                        fc->tetprism_vol_sum = 0.0; // Clear it.
                    }
                    continue;
                } else { // ori <= 0
                    // The edge ('fliptets[0]' = [a',b',c',d]) is non-convex or flat,
                    //   where the edge [a',b'] is one of [a,b], [b,c], and [c,a].
                    if (checksubsegflag) {
                        // Do not flip if it is a segment.
                        if (issubseg(fliptets[0])) continue;
                    }
                    // Check if there are three or four tets sharing at this edge.
                    esymself(fliptets[0]); // [b,a,d,c]
                    for (i = 0; i < 3; i++) {
                        fnext(fliptets[i], fliptets[i + 1]);
                    }
                    if (fliptets[3].tet == fliptets[0].tet) {
                        // A 3-to-2 flip is found. (No hull tet.)
                        flip32(fliptets, 0, fc);
                        flipcount++;
                        if (fc->remove_ndelaunay_edge) {
                            // Update the volume (must be decreased).
                            // assert(fc->tetprism_vol_sum <= 0);
                            tetprism_vol_sum += fc->tetprism_vol_sum;
                            fc->tetprism_vol_sum = 0.0; // Clear it.
                        }
                        continue;
                    } else {
                        // There are more than 3 tets at this edge.
                        fnext(fliptets[3], fliptets[4]);
                        if (fliptets[4].tet == fliptets[0].tet) {
                            // There are exactly 4 tets at this edge.
                            if (round_flag == 1) {
                                continue; // [2017-10-20]
                            }
                            if (nonconvex) {
                                if (apex(fliptets[3]) == dummypoint) {
                                    // This edge is locally non-convex on the hull.
                                    // It can be removed by a 4-to-4 flip.
                                    ori = 0;
                                }
                            } // if (nonconvex)
                            if (ori == 0) {
                                // A 4-to-4 flip is found. (Two hull tets may be involved.)
                                // Current tets in 'fliptets':
                                //   [0] [b,a,d,c] (d may be newpt)
                                //   [1] [b,a,c,e]
                                //   [2] [b,a,e,f] (f may be dummypoint)
                                //   [3] [b,a,f,d]
                                esymself(fliptets[0]); // [a,b,c,d]
                                // A 2-to-3 flip replaces face [a,b,c] by edge [e,d].
                                //   This creates a degenerate tet [e,d,a,b] (tmpfliptets[0]).
                                //   It will be removed by the followed 3-to-2 flip.
                                flip23(fliptets, 0, fc); // No hull tet.
                                fnext(fliptets[3], fliptets[1]);
                                fnext(fliptets[1], fliptets[2]);
                                // Current tets in 'fliptets':
                                //   [0] [...]
                                //   [1] [b,a,d,e] (degenerated, d may be new point).
                                //   [2] [b,a,e,f] (f may be dummypoint)
                                //   [3] [b,a,f,d]
                                // A 3-to-2 flip replaces edge [b,a] by face [d,e,f].
                                //   Hull tets may be involved (f may be dummypoint).
                                flip32(&(fliptets[1]), (apex(fliptets[3]) == dummypoint), fc);
                                flipcount++;
                                flip23count--;
                                flip32count--;
                                flip44count++;
                                if (fc->remove_ndelaunay_edge) {
                                    // Update the volume (must be decreased).
                                    // assert(fc->tetprism_vol_sum <= 0);
                                    tetprism_vol_sum += fc->tetprism_vol_sum;
                                    fc->tetprism_vol_sum = 0.0; // Clear it.
                                }
                                /////// Debug
                                // if (checkmesh(0) > 0) {
                                //	assert(0);
                                //}
                                continue;
                            } // if (ori == 0)
                        }
                    }
                } // if (ori <= 0)

                // This non-Delaunay face is unflippable. Save it.
                unflipqueue->newindex((void**)&bface);
                bface->tt = fliptets[0];
                bface->forg = org(fliptets[0]);
                bface->fdest = dest(fliptets[0]);
                bface->fapex = apex(fliptets[0]);
            } // if (sign < 0)
        }     // while (flipstack)

        if (b->verbose > 2) {
            if (flipcount > 0) {
                printf("      Performed %ld flips.\n", flipcount);
            }
        }
        // Accumulate the counter of flips.
        totalcount += flipcount;

        // Return if no unflippable faces left.
        if (unflipqueue->objects == 0l) break;
        // Return if no flip has been performed.
        if (flipcount == 0l) break;

        // Try to flip the unflippable faces.
        for (i = 0; i < unflipqueue->objects; i++) {
            bface = (badface*)fastlookup(unflipqueue, i);
            if (!isdeadtet(bface->tt) && (org(bface->tt) == bface->forg) &&
                (dest(bface->tt) == bface->fdest) && (apex(bface->tt) == bface->fapex)) {
                flippush(flipstack, &(bface->tt));
            }
        }
        unflipqueue->restart();

    } // while (1)

    if (b->verbose > 2) {
        if (totalcount > 0) {
            printf("      Performed %ld flips.\n", totalcount);
        }
        if (sliver_peels > 0) {
            printf("      Removed %ld hull slivers.\n", sliver_peels);
        }
        if (unflipqueue->objects > 0l) {
            printf("      %ld unflippable edges remained.\n", unflipqueue->objects);
        }
    }

    return totalcount + sliver_peels;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// recoverdelaunay()    Recovery the locally Delaunay property.              //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::recoverdelaunay() {
    arraypool *flipqueue, *nextflipqueue, *swapqueue;
    triface tetloop, neightet, *parytet;
    badface *bface, *parybface;
    point* ppt;
    flipconstraints fc;
    int i, j;

    if (!b->quiet) {
        printf("Recovering Delaunayness...\n");
    }

    tetprism_vol_sum = 0.0; // Initialize it.

    // Put all interior faces of the mesh into 'flipstack'.
    tetrahedrons->traversalinit();
    tetloop.tet = tetrahedrontraverse();
    while (tetloop.tet != NULL) {
        for (tetloop.ver = 0; tetloop.ver < 4; tetloop.ver++) {
            decode(tetloop.tet[tetloop.ver], neightet);
            if (!facemarked(neightet)) {
                flippush(flipstack, &tetloop);
            }
        }
        ppt = (point*)&(tetloop.tet[4]);
        tetprism_vol_sum += tetprismvol(ppt[0], ppt[1], ppt[2], ppt[3]);
        tetloop.tet = tetrahedrontraverse();
    }

    // Calulate a relatively lower bound for small improvement.
    //   Used to avoid rounding error in volume calculation.
    fc.bak_tetprism_vol = tetprism_vol_sum * b->epsilon * 1e-3;

    if (b->verbose) {
        printf("  Initial obj = %.17g\n", tetprism_vol_sum);
    }

    if (b->verbose > 1) {
        printf("    Recover Delaunay [Lawson] : %ld\n", flippool->items);
    }

    // First only use the basic Lawson's flip.
    fc.remove_ndelaunay_edge = 1;
    fc.enqflag = 2;

    lawsonflip3d(&fc);

    if (b->verbose > 1) {
        printf("    obj (after Lawson) = %.17g\n", tetprism_vol_sum);
    }

    if (unflipqueue->objects == 0l) {
        return; // The mesh is Delaunay.
    }

    fc.unflip = 1;         // Unflip if the edge is not flipped.
    fc.collectnewtets = 1; // new tets are returned in 'cavetetlist'.
    fc.enqflag = 0;

    autofliplinklevel = 1; // Init level.
    b->fliplinklevel = -1; // No fixed level.

    // For efficiency reason, we limit the maximium size of the edge star.
    int bakmaxflipstarsize = b->flipstarsize;
    b->flipstarsize = 10; // default

    flipqueue = new arraypool(sizeof(badface), 10);
    nextflipqueue = new arraypool(sizeof(badface), 10);

    // Swap the two flip queues.
    swapqueue = flipqueue;
    flipqueue = unflipqueue;
    unflipqueue = swapqueue;

    while (flipqueue->objects > 0l) {

        if (b->verbose > 1) {
            printf("    Recover Delaunay [level = %2d] #:  %ld.\n", autofliplinklevel,
                   flipqueue->objects);
        }

        for (i = 0; i < flipqueue->objects; i++) {
            bface = (badface*)fastlookup(flipqueue, i);
            if (getedge(bface->forg, bface->fdest, &bface->tt)) {
                if (removeedgebyflips(&(bface->tt), &fc) == 2) {
                    tetprism_vol_sum += fc.tetprism_vol_sum;
                    fc.tetprism_vol_sum = 0.0; // Clear it.
                    // Queue new faces for flips.
                    for (j = 0; j < cavetetlist->objects; j++) {
                        parytet = (triface*)fastlookup(cavetetlist, j);
                        // A queued new tet may be dead.
                        if (!isdeadtet(*parytet)) {
                            for (parytet->ver = 0; parytet->ver < 4; parytet->ver++) {
                                // Avoid queue a face twice.
                                decode(parytet->tet[parytet->ver], neightet);
                                if (!facemarked(neightet)) {
                                    flippush(flipstack, parytet);
                                }
                            } // parytet->ver
                        }
                    } // j
                    cavetetlist->restart();
                    // Remove locally non-Delaunay faces. New non-Delaunay edges
                    //   may be found. They are saved in 'unflipqueue'.
                    fc.enqflag = 2;
                    lawsonflip3d(&fc);
                    fc.enqflag = 0;
                    // There may be unflipable faces. Add them in flipqueue.
                    for (j = 0; j < unflipqueue->objects; j++) {
                        bface = (badface*)fastlookup(unflipqueue, j);
                        flipqueue->newindex((void**)&parybface);
                        *parybface = *bface;
                    }
                    unflipqueue->restart();
                } else {
                    // Unable to remove this edge. Save it.
                    nextflipqueue->newindex((void**)&parybface);
                    *parybface = *bface;
                    // Normally, it should be zero.
                    // assert(fc.tetprism_vol_sum == 0.0);
                    // However, due to rounding errors, a tiny value may appear.
                    fc.tetprism_vol_sum = 0.0;
                }
            }
        } // i

        if (b->verbose > 1) {
            printf("    obj (after level %d) = %.17g.\n", autofliplinklevel, tetprism_vol_sum);
        }
        flipqueue->restart();

        // Swap the two flip queues.
        swapqueue = flipqueue;
        flipqueue = nextflipqueue;
        nextflipqueue = swapqueue;

        if (flipqueue->objects > 0l) {
            // default 'b->delmaxfliplevel' is 1.
            if (autofliplinklevel >= b->delmaxfliplevel) {
                // For efficiency reason, we do not search too far.
                break;
            }
            autofliplinklevel += b->fliplinklevelinc;
        }
    } // while (flipqueue->objects > 0l)

    if (flipqueue->objects > 0l) {
        if (b->verbose > 1) {
            printf("    %ld non-Delaunay edges remained.\n", flipqueue->objects);
        }
    }

    if (b->verbose) {
        printf("  Final obj  = %.17g\n", tetprism_vol_sum);
    }

    b->flipstarsize = bakmaxflipstarsize;
    delete flipqueue;
    delete nextflipqueue;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// gettetrahedron()    Get a tetrahedron which have the given vertices.      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::gettetrahedron(point pa, point pb, point pc, point pd, triface* searchtet) {
    triface spintet;
    int t1ver;

    if (getedge(pa, pb, searchtet)) {
        spintet = *searchtet;
        while (1) {
            if (apex(spintet) == pc) {
                *searchtet = spintet;
                break;
            }
            fnextself(spintet);
            if (spintet.tet == searchtet->tet) break;
        }
        if (apex(*searchtet) == pc) {
            if (oppo(*searchtet) == pd) {
                return 1;
            } else {
                fsymself(*searchtet);
                if (oppo(*searchtet) == pd) {
                    return 1;
                }
            }
        }
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// improvequalitybyflips()    Improve the mesh quality by flips.             //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

long tetgenmesh::improvequalitybyflips() {
    arraypool *flipqueue, *nextflipqueue, *swapqueue;
    badface *bface, *parybface;
    triface* parytet;
    point* ppt;
    flipconstraints fc;
    REAL *cosdd, ncosdd[6], maxdd;
    long totalremcount, remcount;
    int remflag;
    int n, i, j, k;

    // assert(unflipqueue->objects > 0l);
    flipqueue = new arraypool(sizeof(badface), 10);
    nextflipqueue = new arraypool(sizeof(badface), 10);

    // Backup flip edge options.
    int bakautofliplinklevel = autofliplinklevel;
    int bakfliplinklevel = b->fliplinklevel;
    int bakmaxflipstarsize = b->flipstarsize;

    // Set flip edge options.
    autofliplinklevel = 1;
    b->fliplinklevel = -1;
    b->flipstarsize = 10; // b->optmaxflipstarsize;

    fc.remove_large_angle = 1;
    fc.unflip = 1;
    fc.collectnewtets = 1;
    fc.checkflipeligibility = 1;

    totalremcount = 0l;

    // Swap the two flip queues.
    swapqueue = flipqueue;
    flipqueue = unflipqueue;
    unflipqueue = swapqueue;

    while (flipqueue->objects > 0l) {

        remcount = 0l;

        while (flipqueue->objects > 0l) {
            if (b->verbose > 1) {
                printf("    Improving mesh qualiy by flips [%d]#:  %ld.\n", autofliplinklevel,
                       flipqueue->objects);
            }

            for (k = 0; k < flipqueue->objects; k++) {
                bface = (badface*)fastlookup(flipqueue, k);
                if (gettetrahedron(bface->forg, bface->fdest, bface->fapex, bface->foppo,
                                   &bface->tt)) {
                    // assert(!ishulltet(bface->tt));
                    // There are bad dihedral angles in this tet.
                    if (bface->tt.ver != 11) {
                        // The dihedral angles are permuted.
                        // Here we simply re-compute them. Slow!!.
                        ppt = (point*)&(bface->tt.tet[4]);
                        tetalldihedral(ppt[0], ppt[1], ppt[2], ppt[3], bface->cent, &bface->key,
                                       NULL);
                        bface->forg = ppt[0];
                        bface->fdest = ppt[1];
                        bface->fapex = ppt[2];
                        bface->foppo = ppt[3];
                        bface->tt.ver = 11;
                    }
                    if (bface->key == 0) {
                        // Re-comput the quality values. Due to smoothing operations.
                        ppt = (point*)&(bface->tt.tet[4]);
                        tetalldihedral(ppt[0], ppt[1], ppt[2], ppt[3], bface->cent, &bface->key,
                                       NULL);
                    }
                    cosdd = bface->cent;
                    remflag = 0;
                    for (i = 0; (i < 6) && !remflag; i++) {
                        if (cosdd[i] < cosmaxdihed) {
                            // Found a large dihedral angle.
                            bface->tt.ver = edge2ver[i]; // Go to the edge.
                            fc.cosdihed_in = cosdd[i];
                            fc.cosdihed_out = 0.0; // 90 degree.
                            n = removeedgebyflips(&(bface->tt), &fc);
                            if (n == 2) {
                                // Edge is flipped.
                                remflag = 1;
                                if (fc.cosdihed_out < cosmaxdihed) {
                                    // Queue new bad tets for further improvements.
                                    for (j = 0; j < cavetetlist->objects; j++) {
                                        parytet = (triface*)fastlookup(cavetetlist, j);
                                        if (!isdeadtet(*parytet)) {
                                            ppt = (point*)&(parytet->tet[4]);
                                            // Do not test a hull tet.
                                            if (ppt[3] != dummypoint) {
                                                tetalldihedral(ppt[0], ppt[1], ppt[2], ppt[3],
                                                               ncosdd, &maxdd, NULL);
                                                if (maxdd < cosmaxdihed) {
                                                    // There are bad dihedral angles in this tet.
                                                    nextflipqueue->newindex((void**)&parybface);
                                                    parybface->tt.tet = parytet->tet;
                                                    parybface->tt.ver = 11;
                                                    parybface->forg = ppt[0];
                                                    parybface->fdest = ppt[1];
                                                    parybface->fapex = ppt[2];
                                                    parybface->foppo = ppt[3];
                                                    parybface->key = maxdd;
                                                    for (n = 0; n < 6; n++) {
                                                        parybface->cent[n] = ncosdd[n];
                                                    }
                                                }
                                            } // if (ppt[3] != dummypoint)
                                        }
                                    } // j
                                }     // if (fc.cosdihed_out < cosmaxdihed)
                                cavetetlist->restart();
                                remcount++;
                            }
                        }
                    } // i
                    if (!remflag) {
                        // An unremoved bad tet. Queue it again.
                        unflipqueue->newindex((void**)&parybface);
                        *parybface = *bface;
                    }
                } // if (gettetrahedron(...))
            }     // k

            flipqueue->restart();

            // Swap the two flip queues.
            swapqueue = flipqueue;
            flipqueue = nextflipqueue;
            nextflipqueue = swapqueue;
        } // while (flipqueues->objects > 0)

        if (b->verbose > 1) {
            printf("    Removed %ld bad tets.\n", remcount);
        }
        totalremcount += remcount;

        if (unflipqueue->objects > 0l) {
            // if (autofliplinklevel >= b->optmaxfliplevel) {
            if (autofliplinklevel >= b->optlevel) {
                break;
            }
            autofliplinklevel += b->fliplinklevelinc;
            // b->flipstarsize = 10 + (1 << (b->optlevel - 1));
        }

        // Swap the two flip queues.
        swapqueue = flipqueue;
        flipqueue = unflipqueue;
        unflipqueue = swapqueue;
    } // while (flipqueues->objects > 0)

    // Restore original flip edge options.
    autofliplinklevel = bakautofliplinklevel;
    b->fliplinklevel = bakfliplinklevel;
    b->flipstarsize = bakmaxflipstarsize;

    delete flipqueue;
    delete nextflipqueue;

    return totalremcount;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// smoothpoint()    Moving a vertex to improve the mesh quality.             //
//                                                                           //
// 'smtpt' (p) is a point to be smoothed. Generally, it is a Steiner point.  //
// It may be not a vertex of the mesh.                                       //
//                                                                           //
// This routine tries to move 'p' inside its star until a selected objective //
// function over all tetrahedra in the star is improved. The function may be //
// the some quality measures, i.e., aspect ratio, maximum dihedral angel, or //
// simply the volume of the tetrahedra.                                      //
//                                                                           //
// 'linkfacelist' contains the list of link faces of 'p'.  Since a link face //
// has two orientations, ccw or cw, with respect to 'p'.  'ccw' indicates    //
// the orientation is ccw (1) or not (0).                                    //
//                                                                           //
// 'opm' is a structure contains the parameters of the objective function.   //
// It is needed by the evaluation of the function value.                     //
//                                                                           //
// The return value indicates weather the point is smoothed or not.          //
//                                                                           //
// ASSUMPTION: This routine assumes that all link faces are true faces, i.e, //
// no face has 'dummypoint' as its vertex.                                   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::smoothpoint(point smtpt, arraypool* linkfacelist, int ccw, optparameters* opm) {
    triface *parytet, *parytet1, swaptet;
    point pa, pb, pc;
    REAL fcent[3], startpt[3], nextpt[3], bestpt[3];
    REAL oldval, minval = 0.0, val;
    REAL maxcosd; // oldang, newang;
    REAL ori, diff;
    int numdirs, iter;
    int i, j, k;

    // Decide the number of moving directions.
    numdirs = (int)linkfacelist->objects;
    if (numdirs > opm->numofsearchdirs) {
        numdirs = opm->numofsearchdirs; // Maximum search directions.
    }

    // Set the initial value.
    opm->imprval = opm->initval;
    iter = 0;

    for (i = 0; i < 3; i++) {
        bestpt[i] = startpt[i] = smtpt[i];
    }

    // Iterate until the obj function is not improved.
    while (1) {

        // Find the best next location.
        oldval = opm->imprval;

        for (i = 0; i < numdirs; i++) {
            // Randomly pick a link face (0 <= k <= objects - i - 1).
            k = (int)randomnation(linkfacelist->objects - i);
            parytet = (triface*)fastlookup(linkfacelist, k);
            // Calculate a new position from 'p' to the center of this face.
            pa = org(*parytet);
            pb = dest(*parytet);
            pc = apex(*parytet);
            for (j = 0; j < 3; j++) {
                fcent[j] = (pa[j] + pb[j] + pc[j]) / 3.0;
            }
            for (j = 0; j < 3; j++) {
                nextpt[j] = startpt[j] + opm->searchstep * (fcent[j] - startpt[j]);
            }
            // Calculate the largest minimum function value for the new location.
            for (j = 0; j < linkfacelist->objects; j++) {
                parytet = (triface*)fastlookup(linkfacelist, j);
                if (ccw) {
                    pa = org(*parytet);
                    pb = dest(*parytet);
                } else {
                    pb = org(*parytet);
                    pa = dest(*parytet);
                }
                pc = apex(*parytet);
                ori = orient3d(pa, pb, pc, nextpt);
                if (ori < 0.0) {
                    // Calcuate the objective function value.
                    if (opm->max_min_volume) {
                        // val = -ori;
                        val = -orient3dfast(pa, pb, pc, nextpt);
                    } else if (opm->min_max_aspectratio) {
                        val = 1.0 / tetaspectratio(pa, pb, pc, nextpt);
                    } else if (opm->min_max_dihedangle) {
                        tetalldihedral(pa, pb, pc, nextpt, NULL, &maxcosd, NULL);
                        if (maxcosd < -1) maxcosd = -1.0; // Rounding.
                        val = maxcosd + 1.0;              // Make it be positive.
                    } else {
                        // Unknown objective function.
                        val = 0.0;
                    }
                } else { // ori >= 0.0;
                    // An invalid new tet.
                    // This may happen if the mesh contains inverted elements.
                    if (opm->max_min_volume) {
                        // val = -ori;
                        val = -orient3dfast(pa, pb, pc, nextpt);
                    } else {
                        // Discard this point.
                        break; // j
                    }
                } // if (ori >= 0.0)
                // Stop looping when the object value is not improved.
                if (val <= opm->imprval) {
                    break; // j
                } else {
                    // Remember the smallest improved value.
                    if (j == 0) {
                        minval = val;
                    } else {
                        minval = (val < minval) ? val : minval;
                    }
                }
            } // j
            if (j == linkfacelist->objects) {
                // The function value has been improved.
                opm->imprval = minval;
                // Save the new location of the point.
                for (j = 0; j < 3; j++)
                    bestpt[j] = nextpt[j];
            }
            // Swap k-th and (object-i-1)-th entries.
            j = linkfacelist->objects - i - 1;
            parytet = (triface*)fastlookup(linkfacelist, k);
            parytet1 = (triface*)fastlookup(linkfacelist, j);
            swaptet = *parytet1;
            *parytet1 = *parytet;
            *parytet = swaptet;
        } // i

        diff = opm->imprval - oldval;
        if (diff > 0.0) {
            // Is the function value improved effectively?
            if (opm->max_min_volume) {
                // if ((diff / oldval) < b->epsilon) diff = 0.0;
            } else if (opm->min_max_aspectratio) {
                if ((diff / oldval) < 1e-3) diff = 0.0;
            } else if (opm->min_max_dihedangle) {
                // oldang = acos(oldval - 1.0);
                // newang = acos(opm->imprval - 1.0);
                // if ((oldang - newang) < 0.00174) diff = 0.0; // about 0.1 degree.
            } else {
                // Unknown objective function.
                terminatetetgen(this, 2);
            }
        }

        if (diff > 0.0) {
            // Yes, move p to the new location and continue.
            for (j = 0; j < 3; j++)
                startpt[j] = bestpt[j];
            iter++;
            if ((opm->maxiter > 0) && (iter >= opm->maxiter)) {
                // Maximum smoothing iterations reached.
                break;
            }
        } else {
            break;
        }

    } // while (1)

    if (iter > 0) {
        // The point has been smoothed.
        opm->smthiter = iter; // Remember the number of iterations.
        // The point has been smoothed. Update it to its new position.
        for (i = 0; i < 3; i++)
            smtpt[i] = startpt[i];
    }

    return iter;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// improvequalitysmoothing()    Improve mesh quality by smoothing.           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

long tetgenmesh::improvequalitybysmoothing(optparameters* opm) {
    arraypool *flipqueue, *swapqueue;
    triface* parytet;
    badface *bface, *parybface;
    point* ppt;
    long totalsmtcount, smtcount;
    int smtflag;
    int iter, i, j, k;

    // assert(unflipqueue->objects > 0l);
    flipqueue = new arraypool(sizeof(badface), 10);

    // Swap the two flip queues.
    swapqueue = flipqueue;
    flipqueue = unflipqueue;
    unflipqueue = swapqueue;

    totalsmtcount = 0l;
    iter = 0;

    while (flipqueue->objects > 0l) {

        smtcount = 0l;

        if (b->verbose > 1) {
            printf("    Improving mesh quality by smoothing [%d]#:  %ld.\n", iter,
                   flipqueue->objects);
        }

        for (k = 0; k < flipqueue->objects; k++) {
            bface = (badface*)fastlookup(flipqueue, k);
            if (gettetrahedron(bface->forg, bface->fdest, bface->fapex, bface->foppo, &bface->tt)) {
                // Operate on it if it is not in 'unflipqueue'.
                if (!marktested(bface->tt)) {
                    // Here we simply re-compute the quality. Since other smoothing
                    //   operation may have moved the vertices of this tet.
                    ppt = (point*)&(bface->tt.tet[4]);
                    tetalldihedral(ppt[0], ppt[1], ppt[2], ppt[3], bface->cent, &bface->key, NULL);
                    if (bface->key < cossmtdihed) { // if (maxdd < cosslidihed) {
                        // It is a sliver. Try to smooth its vertices.
                        smtflag = 0;
                        opm->initval = bface->key + 1.0;
                        for (i = 0; (i < 4) && !smtflag; i++) {
                            if (pointtype(ppt[i]) == FREEVOLVERTEX) {
                                getvertexstar(1, ppt[i], cavetetlist, NULL, NULL);
                                opm->searchstep = 0.001; // Search step size
                                smtflag = smoothpoint(ppt[i], cavetetlist, 1, opm);
                                if (smtflag) {
                                    while (opm->smthiter == opm->maxiter) {
                                        opm->searchstep *= 10.0; // Increase the step size.
                                        opm->initval = opm->imprval;
                                        opm->smthiter = 0; // reset
                                        smoothpoint(ppt[i], cavetetlist, 1, opm);
                                    }
                                    // This tet is modifed.
                                    smtcount++;
                                    if ((opm->imprval - 1.0) < cossmtdihed) {
                                        // There are slivers in new tets. Queue them.
                                        for (j = 0; j < cavetetlist->objects; j++) {
                                            parytet = (triface*)fastlookup(cavetetlist, j);
                                            // Operate it if it is not in 'unflipqueue'.
                                            if (!marktested(*parytet)) {
                                                // Evaluate its quality.
                                                // Re-use ppt, bface->key, bface->cent.
                                                ppt = (point*)&(parytet->tet[4]);
                                                tetalldihedral(ppt[0], ppt[1], ppt[2], ppt[3],
                                                               bface->cent, &bface->key, NULL);
                                                if (bface->key < cossmtdihed) {
                                                    // A new sliver. Queue it.
                                                    marktest(*parytet); // It is in unflipqueue.
                                                    unflipqueue->newindex((void**)&parybface);
                                                    parybface->tt = *parytet;
                                                    parybface->forg = ppt[0];
                                                    parybface->fdest = ppt[1];
                                                    parybface->fapex = ppt[2];
                                                    parybface->foppo = ppt[3];
                                                    parybface->tt.ver = 11;
                                                    parybface->key = 0.0;
                                                }
                                            }
                                        } // j
                                    }     // if ((opm->imprval - 1.0) < cossmtdihed)
                                }         // if (smtflag)
                                cavetetlist->restart();
                            } // if (pointtype(ppt[i]) == FREEVOLVERTEX)
                        }     // i
                        if (!smtflag) {
                            // Didn't smooth. Queue it again.
                            marktest(bface->tt); // It is in unflipqueue.
                            unflipqueue->newindex((void**)&parybface);
                            parybface->tt = bface->tt;
                            parybface->forg = ppt[0];
                            parybface->fdest = ppt[1];
                            parybface->fapex = ppt[2];
                            parybface->foppo = ppt[3];
                            parybface->tt.ver = 11;
                            parybface->key = 0.0;
                        }
                    } // if (maxdd < cosslidihed)
                }     // if (!marktested(...))
            }         // if (gettetrahedron(...))
        }             // k

        flipqueue->restart();

        // Unmark the tets in unflipqueue.
        for (i = 0; i < unflipqueue->objects; i++) {
            bface = (badface*)fastlookup(unflipqueue, i);
            unmarktest(bface->tt);
        }

        if (b->verbose > 1) {
            printf("    Smooth %ld points.\n", smtcount);
        }
        totalsmtcount += smtcount;

        if (smtcount == 0l) {
            // No point has been smoothed.
            break;
        } else {
            iter++;
            if (iter == 2) { // if (iter >= b->optpasses) {
                break;
            }
        }

        // Swap the two flip queues.
        swapqueue = flipqueue;
        flipqueue = unflipqueue;
        unflipqueue = swapqueue;
    } // while

    delete flipqueue;

    return totalsmtcount;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// splitsliver()    Split a sliver.                                          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::splitsliver(triface* slitet, REAL cosd, int chkencflag) {
    triface* abtets;
    triface searchtet, spintet, *parytet;
    point pa, pb, steinerpt;
    optparameters opm;
    insertvertexflags ivf;
    REAL smtpt[3], midpt[3];
    int success;
    int t1ver;
    int n, i;

    // 'slitet' is [c,d,a,b], where [c,d] has a big dihedral angle.
    // Go to the opposite edge [a,b].
    edestoppo(*slitet, searchtet); // [a,b,c,d].

    // Do not split a segment.
    if (issubseg(searchtet)) {
        return 0;
    }

    // Count the number of tets shared at [a,b].
    // Do not split it if it is a hull edge.
    spintet = searchtet;
    n = 0;
    while (1) {
        if (ishulltet(spintet)) break;
        n++;
        fnextself(spintet);
        if (spintet.tet == searchtet.tet) break;
    }
    if (ishulltet(spintet)) {
        return 0; // It is a hull edge.
    }

    // Get all tets at edge [a,b].
    abtets = new triface[n];
    spintet = searchtet;
    for (i = 0; i < n; i++) {
        abtets[i] = spintet;
        fnextself(spintet);
    }

    // Initialize the list of 2n boundary faces.
    for (i = 0; i < n; i++) {
        eprev(abtets[i], searchtet);
        esymself(searchtet); // [a,p_i,p_i+1].
        cavetetlist->newindex((void**)&parytet);
        *parytet = searchtet;
        enext(abtets[i], searchtet);
        esymself(searchtet); // [p_i,b,p_i+1].
        cavetetlist->newindex((void**)&parytet);
        *parytet = searchtet;
    }

    // Init the Steiner point at the midpoint of edge [a,b].
    pa = org(abtets[0]);
    pb = dest(abtets[0]);
    for (i = 0; i < 3; i++) {
        smtpt[i] = midpt[i] = 0.5 * (pa[i] + pb[i]);
    }

    // Point smooth options.
    opm.min_max_dihedangle = 1;
    opm.initval = cosd + 1.0; // Initial volume is zero.
    opm.numofsearchdirs = 20;
    opm.searchstep = 0.001;
    opm.maxiter = 100; // Limit the maximum iterations.

    success = smoothpoint(smtpt, cavetetlist, 1, &opm);

    if (success) {
        while (opm.smthiter == opm.maxiter) {
            // It was relocated and the prescribed maximum iteration reached.
            // Try to increase the search stepsize.
            opm.searchstep *= 10.0;
            // opm.maxiter = 100; // Limit the maximum iterations.
            opm.initval = opm.imprval;
            opm.smthiter = 0; // Init.
            smoothpoint(smtpt, cavetetlist, 1, &opm);
        }
    } // if (success)

    cavetetlist->restart();

    if (!success) {
        delete[] abtets;
        return 0;
    }

    // Insert the Steiner point.
    makepoint(&steinerpt, FREEVOLVERTEX);
    for (i = 0; i < 3; i++)
        steinerpt[i] = smtpt[i];

    // Insert the created Steiner point.
    for (i = 0; i < n; i++) {
        infect(abtets[i]);
        caveoldtetlist->newindex((void**)&parytet);
        *parytet = abtets[i];
    }

    searchtet = abtets[0]; // No need point location.
    if (b->metric) {
        locate(steinerpt, &searchtet); // For size interpolation.
    }

    delete[] abtets;

    ivf.iloc = (int)INSTAR;
    ivf.chkencflag = chkencflag;
    ivf.assignmeshsize = b->metric;

    if (insertpoint(steinerpt, &searchtet, NULL, NULL, &ivf)) {
        // The vertex has been inserted.
        st_volref_count++;
        if (steinerleft > 0) steinerleft--;
        return 1;
    } else {
        // The Steiner point is too close to an existing vertex. Reject it.
        pointdealloc(steinerpt);
        return 0;
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// removeslivers()    Remove slivers by adding Steiner points.               //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

long tetgenmesh::removeslivers(int chkencflag) {
    arraypool *flipqueue, *swapqueue;
    badface *bface, *parybface;
    triface slitet, *parytet;
    point* ppt;
    REAL cosdd[6], maxcosd;
    long totalsptcount, sptcount;
    int iter, i, j, k;

    // assert(unflipqueue->objects > 0l);
    flipqueue = new arraypool(sizeof(badface), 10);

    // Swap the two flip queues.
    swapqueue = flipqueue;
    flipqueue = unflipqueue;
    unflipqueue = swapqueue;

    totalsptcount = 0l;
    iter = 0;

    while ((flipqueue->objects > 0l) && (steinerleft != 0)) {

        sptcount = 0l;

        if (b->verbose > 1) {
            printf("    Splitting bad quality tets [%d]#:  %ld.\n", iter, flipqueue->objects);
        }

        for (k = 0; (k < flipqueue->objects) && (steinerleft != 0); k++) {
            bface = (badface*)fastlookup(flipqueue, k);
            if (gettetrahedron(bface->forg, bface->fdest, bface->fapex, bface->foppo, &bface->tt)) {
                if ((bface->key == 0) || (bface->tt.ver != 11)) {
                    // Here we need to re-compute the quality. Since other smoothing
                    //   operation may have moved the vertices of this tet.
                    ppt = (point*)&(bface->tt.tet[4]);
                    tetalldihedral(ppt[0], ppt[1], ppt[2], ppt[3], bface->cent, &bface->key, NULL);
                }
                if (bface->key < cosslidihed) {
                    // It is a sliver. Try to split it.
                    slitet.tet = bface->tt.tet;
                    // cosdd = bface->cent;
                    for (j = 0; j < 6; j++) {
                        if (bface->cent[j] < cosslidihed) {
                            // Found a large dihedral angle.
                            slitet.ver = edge2ver[j]; // Go to the edge.
                            if (splitsliver(&slitet, bface->cent[j], chkencflag)) {
                                sptcount++;
                                break;
                            }
                        }
                    } // j
                    if (j < 6) {
                        // A sliver is split. Queue new slivers.
                        badtetrahedrons->traversalinit();
                        parytet = (triface*)badtetrahedrons->traverse();
                        while (parytet != NULL) {
                            unmarktest2(*parytet);
                            ppt = (point*)&(parytet->tet[4]);
                            tetalldihedral(ppt[0], ppt[1], ppt[2], ppt[3], cosdd, &maxcosd, NULL);
                            if (maxcosd < cosslidihed) {
                                // A new sliver. Queue it.
                                unflipqueue->newindex((void**)&parybface);
                                parybface->forg = ppt[0];
                                parybface->fdest = ppt[1];
                                parybface->fapex = ppt[2];
                                parybface->foppo = ppt[3];
                                parybface->tt.tet = parytet->tet;
                                parybface->tt.ver = 11;
                                parybface->key = maxcosd;
                                for (i = 0; i < 6; i++) {
                                    parybface->cent[i] = cosdd[i];
                                }
                            }
                            parytet = (triface*)badtetrahedrons->traverse();
                        }
                        badtetrahedrons->restart();
                    } else {
                        // Didn't split. Queue it again.
                        unflipqueue->newindex((void**)&parybface);
                        *parybface = *bface;
                    } // if (j == 6)
                }     // if (bface->key < cosslidihed)
            }         // if (gettetrahedron(...))
        }             // k

        flipqueue->restart();

        if (b->verbose > 1) {
            printf("    Split %ld tets.\n", sptcount);
        }
        totalsptcount += sptcount;

        if (sptcount == 0l) {
            // No point has been smoothed.
            break;
        } else {
            iter++;
            if (iter == 2) { // if (iter >= b->optpasses) {
                break;
            }
        }

        // Swap the two flip queues.
        swapqueue = flipqueue;
        flipqueue = unflipqueue;
        unflipqueue = swapqueue;
    } // while

    delete flipqueue;

    return totalsptcount;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// optimizemesh()    Optimize mesh for specified objective functions.        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::optimizemesh() {
    badface* parybface;
    triface checktet;
    point* ppt;
    int optpasses;
    optparameters opm;
    REAL ncosdd[6], maxdd;
    long totalremcount, remcount;
    long totalsmtcount, smtcount;
    long totalsptcount, sptcount;
    int chkencflag;
    int iter;
    int n;

    if (!b->quiet) {
        printf("Optimizing mesh...\n");
    }

    optpasses = ((1 << b->optlevel) - 1);

    if (b->verbose) {
        printf("  Optimization level  = %d.\n", b->optlevel);
        printf("  Optimization scheme = %d.\n", b->optscheme);
        printf("  Number of iteration = %d.\n", optpasses);
        printf("  Min_Max dihed angle = %g.\n", b->optmaxdihedral);
    }

    totalsmtcount = totalsptcount = totalremcount = 0l;

    cosmaxdihed = cos(b->optmaxdihedral / 180.0 * PI);
    cossmtdihed = cos(b->optminsmtdihed / 180.0 * PI);
    cosslidihed = cos(b->optminslidihed / 180.0 * PI);

    int attrnum = numelemattrib - 1;

    // Put all bad tetrahedra into array.
    tetrahedrons->traversalinit();
    checktet.tet = tetrahedrontraverse();
    while (checktet.tet != NULL) {
        if (b->convex) { // -c
            // Skip this tet if it lies in the exterior.
            if (elemattribute(checktet.tet, attrnum) == -1.0) {
                checktet.tet = tetrahedrontraverse();
                continue;
            }
        }
        ppt = (point*)&(checktet.tet[4]);
        tetalldihedral(ppt[0], ppt[1], ppt[2], ppt[3], ncosdd, &maxdd, NULL);
        if (maxdd < cosmaxdihed) {
            // There are bad dihedral angles in this tet.
            unflipqueue->newindex((void**)&parybface);
            parybface->tt.tet = checktet.tet;
            parybface->tt.ver = 11;
            parybface->forg = ppt[0];
            parybface->fdest = ppt[1];
            parybface->fapex = ppt[2];
            parybface->foppo = ppt[3];
            parybface->key = maxdd;
            for (n = 0; n < 6; n++) {
                parybface->cent[n] = ncosdd[n];
            }
        }
        checktet.tet = tetrahedrontraverse();
    }

    totalremcount = improvequalitybyflips();

    if ((unflipqueue->objects > 0l) && ((b->optscheme & 2) || (b->optscheme & 4))) {
        // The pool is only used by removeslivers().
        badtetrahedrons = new memorypool(sizeof(triface), b->tetrahedraperblock, sizeof(void*), 0);

        // Smoothing options.
        opm.min_max_dihedangle = 1;
        opm.numofsearchdirs = 10;
        // opm.searchstep = 0.001;
        opm.maxiter = 30; // Limit the maximum iterations.
        // opm.checkencflag = 4; // Queue affected tets after smoothing.
        chkencflag = 4; // Queue affected tets after splitting a sliver.
        iter = 0;

        while (iter < optpasses) {
            smtcount = sptcount = remcount = 0l;
            if (b->optscheme & 2) {
                smtcount += improvequalitybysmoothing(&opm);
                totalsmtcount += smtcount;
                if (smtcount > 0l) {
                    remcount = improvequalitybyflips();
                    totalremcount += remcount;
                }
            }
            if (unflipqueue->objects > 0l) {
                if (b->optscheme & 4) {
                    sptcount += removeslivers(chkencflag);
                    totalsptcount += sptcount;
                    if (sptcount > 0l) {
                        remcount = improvequalitybyflips();
                        totalremcount += remcount;
                    }
                }
            }
            if (unflipqueue->objects > 0l) {
                if (remcount > 0l) {
                    iter++;
                } else {
                    break;
                }
            } else {
                break;
            }
        } // while (iter)

        delete badtetrahedrons;
        badtetrahedrons = NULL;
    }

    if (unflipqueue->objects > 0l) {
        if (b->verbose > 1) {
            printf("    %ld bad tets remained.\n", unflipqueue->objects);
        }
        unflipqueue->restart();
    }

    if (b->verbose) {
        if (totalremcount > 0l) {
            printf("  Removed %ld edges.\n", totalremcount);
        }
        if (totalsmtcount > 0l) {
            printf("  Smoothed %ld points.\n", totalsmtcount);
        }
        if (totalsptcount > 0l) {
            printf("  Split %ld slivers.\n", totalsptcount);
        }
    }
}

////                                                                       ////
////                                                                       ////
//// optimize_cxx /////////////////////////////////////////////////////////////

//// meshstat_cxx /////////////////////////////////////////////////////////////
////                                                                       ////
////                                                                       ////

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// printfcomma()    Print a (large) number with the 'thousands separator'.   //
//                                                                           //
// The following code was simply copied from "stackoverflow".                //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::printfcomma(unsigned long n) {
    unsigned long n2 = 0;
    int scale = 1;
    while (n >= 1000) {
        n2 = n2 + scale * (n % 1000);
        n /= 1000;
        scale *= 1000;
    }
    printf("%ld", n);
    while (scale != 1) {
        scale /= 1000;
        n = n2 / scale;
        n2 = n2 % scale;
        printf(",%03ld", n);
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// checkmesh()    Test the mesh for topological consistency.                 //
//                                                                           //
// If 'topoflag' is set, only check the topological connection of the mesh,  //
// i.e., do not report degenerated or inverted elements.                     //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::checkmesh(int topoflag) {
    triface tetloop, neightet, symtet;
    point pa, pb, pc, pd;
    REAL ori;
    int horrors, i;

    if (!b->quiet) {
        printf("  Checking consistency of mesh...\n");
    }

    horrors = 0;
    tetloop.ver = 0;
    // Run through the list of tetrahedra, checking each one.
    tetrahedrons->traversalinit();
    tetloop.tet = alltetrahedrontraverse();
    while (tetloop.tet != (tetrahedron*)NULL) {
        // Check all four faces of the tetrahedron.
        for (tetloop.ver = 0; tetloop.ver < 4; tetloop.ver++) {
            pa = org(tetloop);
            pb = dest(tetloop);
            pc = apex(tetloop);
            pd = oppo(tetloop);
            if (tetloop.ver == 0) {        // Only test for inversion once.
                if (!ishulltet(tetloop)) { // Only do test if it is not a hull tet.
                    if (!topoflag) {
                        ori = orient3d(pa, pb, pc, pd);
                        if (ori >= 0.0) {
                            printf("  !! !! %s ", ori > 0.0 ? "Inverted" : "Degenerated");
                            printf("  (%d, %d, %d, %d) (ori = %.17g)\n", pointmark(pa),
                                   pointmark(pb), pointmark(pc), pointmark(pd), ori);
                            horrors++;
                        }
                    }
                }
                if (infected(tetloop)) {
                    // This may be a bug. Report it.
                    printf("  !! (%d, %d, %d, %d) is infected.\n", pointmark(pa), pointmark(pb),
                           pointmark(pc), pointmark(pd));
                    horrors++;
                }
                if (marktested(tetloop)) {
                    // This may be a bug. Report it.
                    printf("  !! (%d, %d, %d, %d) is marked.\n", pointmark(pa), pointmark(pb),
                           pointmark(pc), pointmark(pd));
                    horrors++;
                }
            }
            if (tetloop.tet[tetloop.ver] == NULL) {
                printf("  !! !! No neighbor at face (%d, %d, %d).\n", pointmark(pa), pointmark(pb),
                       pointmark(pc));
                horrors++;
            } else {
                // Find the neighboring tetrahedron on this face.
                fsym(tetloop, neightet);
                if (neightet.tet != NULL) {
                    // Check that the tetrahedron's neighbor knows it's a neighbor.
                    fsym(neightet, symtet);
                    if ((tetloop.tet != symtet.tet) || (tetloop.ver != symtet.ver)) {
                        printf("  !! !! Asymmetric tetra-tetra bond:\n");
                        if (tetloop.tet == symtet.tet) {
                            printf("   (Right tetrahedron, wrong orientation)\n");
                        }
                        printf("    First:  (%d, %d, %d, %d)\n", pointmark(pa), pointmark(pb),
                               pointmark(pc), pointmark(pd));
                        printf("    Second: (%d, %d, %d, %d)\n", pointmark(org(neightet)),
                               pointmark(dest(neightet)), pointmark(apex(neightet)),
                               pointmark(oppo(neightet)));
                        horrors++;
                    }
                    // Check if they have the same edge (the bond() operation).
                    if ((org(neightet) != pb) || (dest(neightet) != pa)) {
                        printf("  !! !! Wrong edge-edge bond:\n");
                        printf("    First:  (%d, %d, %d, %d)\n", pointmark(pa), pointmark(pb),
                               pointmark(pc), pointmark(pd));
                        printf("    Second: (%d, %d, %d, %d)\n", pointmark(org(neightet)),
                               pointmark(dest(neightet)), pointmark(apex(neightet)),
                               pointmark(oppo(neightet)));
                        horrors++;
                    }
                    // Check if they have the same apex.
                    if (apex(neightet) != pc) {
                        printf("  !! !! Wrong face-face bond:\n");
                        printf("    First:  (%d, %d, %d, %d)\n", pointmark(pa), pointmark(pb),
                               pointmark(pc), pointmark(pd));
                        printf("    Second: (%d, %d, %d, %d)\n", pointmark(org(neightet)),
                               pointmark(dest(neightet)), pointmark(apex(neightet)),
                               pointmark(oppo(neightet)));
                        horrors++;
                    }
                    // Check if they have the same opposite.
                    if (oppo(neightet) == pd) {
                        printf("  !! !! Two identical tetra:\n");
                        printf("    First:  (%d, %d, %d, %d)\n", pointmark(pa), pointmark(pb),
                               pointmark(pc), pointmark(pd));
                        printf("    Second: (%d, %d, %d, %d)\n", pointmark(org(neightet)),
                               pointmark(dest(neightet)), pointmark(apex(neightet)),
                               pointmark(oppo(neightet)));
                        horrors++;
                    }
                } else {
                    printf("  !! !! Tet-face has no neighbor (%d, %d, %d) - %d:\n", pointmark(pa),
                           pointmark(pb), pointmark(pc), pointmark(pd));
                    horrors++;
                }
            }
            if (facemarked(tetloop)) {
                // This may be a bug. Report it.
                printf("  !! tetface (%d, %d, %d) %d is marked.\n", pointmark(pa), pointmark(pb),
                       pointmark(pc), pointmark(pd));
            }
        }
        // Check the six edges of this tet.
        for (i = 0; i < 6; i++) {
            tetloop.ver = edge2ver[i];
            if (edgemarked(tetloop)) {
                // This may be a bug. Report it.
                printf("  !! tetedge (%d, %d) %d, %d is marked.\n", pointmark(org(tetloop)),
                       pointmark(dest(tetloop)), pointmark(apex(tetloop)),
                       pointmark(oppo(tetloop)));
            }
        }
        tetloop.tet = alltetrahedrontraverse();
    }
    if (horrors == 0) {
        if (!b->quiet) {
            printf("  In my studied opinion, the mesh appears to be consistent.\n");
        }
    } else {
        printf("  !! !! !! !! %d %s witnessed.\n", horrors,
               horrors > 1 ? "abnormity" : "abnormities");
    }

    return horrors;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// checkshells()       Test the boundary mesh for topological consistency.   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::checkshells() {
    triface neightet, symtet;
    face shloop, spinsh, nextsh;
    face checkseg;
    point pa, pb;
    int bakcount;
    int horrors, i;

    if (!b->quiet) {
        printf("  Checking consistency of the mesh boundary...\n");
    }
    horrors = 0;

    void** bakpathblock = subfaces->pathblock;
    void* bakpathitem = subfaces->pathitem;
    int bakpathitemsleft = subfaces->pathitemsleft;
    int bakalignbytes = subfaces->alignbytes;

    subfaces->traversalinit();
    shloop.sh = shellfacetraverse(subfaces);
    while (shloop.sh != NULL) {
        shloop.shver = 0;
        for (i = 0; i < 3; i++) {
            // Check the face ring at this edge.
            pa = sorg(shloop);
            pb = sdest(shloop);
            spinsh = shloop;
            spivot(spinsh, nextsh);
            bakcount = horrors;
            while ((nextsh.sh != NULL) && (nextsh.sh != shloop.sh)) {
                if (nextsh.sh[3] == NULL) {
                    printf("  !! !! Wrong subface-subface connection (Dead subface).\n");
                    printf("    First: x%lx (%d, %d, %d).\n", (uintptr_t)spinsh.sh,
                           pointmark(sorg(spinsh)), pointmark(sdest(spinsh)),
                           pointmark(sapex(spinsh)));
                    printf("    Second: x%lx (DEAD)\n", (uintptr_t)nextsh.sh);
                    horrors++;
                    break;
                }
                // check if they have the same edge.
                if (!(((sorg(nextsh) == pa) && (sdest(nextsh) == pb)) ||
                      ((sorg(nextsh) == pb) && (sdest(nextsh) == pa)))) {
                    printf("  !! !! Wrong subface-subface connection.\n");
                    printf("    First: x%lx (%d, %d, %d).\n", (uintptr_t)spinsh.sh,
                           pointmark(sorg(spinsh)), pointmark(sdest(spinsh)),
                           pointmark(sapex(spinsh)));
                    printf("    Scond: x%lx (%d, %d, %d).\n", (uintptr_t)nextsh.sh,
                           pointmark(sorg(nextsh)), pointmark(sdest(nextsh)),
                           pointmark(sapex(nextsh)));
                    horrors++;
                    break;
                }
                // Check they should not have the same apex.
                if (sapex(nextsh) == sapex(spinsh)) {
                    printf("  !! !! Existing two duplicated subfaces.\n");
                    printf("    First: x%lx (%d, %d, %d).\n", (uintptr_t)spinsh.sh,
                           pointmark(sorg(spinsh)), pointmark(sdest(spinsh)),
                           pointmark(sapex(spinsh)));
                    printf("    Scond: x%lx (%d, %d, %d).\n", (uintptr_t)nextsh.sh,
                           pointmark(sorg(nextsh)), pointmark(sdest(nextsh)),
                           pointmark(sapex(nextsh)));
                    horrors++;
                    break;
                }
                spinsh = nextsh;
                spivot(spinsh, nextsh);
            }
            // Check subface-subseg bond.
            sspivot(shloop, checkseg);
            if (checkseg.sh != NULL) {
                if (checkseg.sh[3] == NULL) {
                    printf("  !! !! Wrong subface-subseg connection (Dead subseg).\n");
                    printf("    Sub: x%lx (%d, %d, %d).\n", (uintptr_t)shloop.sh,
                           pointmark(sorg(shloop)), pointmark(sdest(shloop)),
                           pointmark(sapex(shloop)));
                    printf("    Sub: x%lx (Dead)\n", (uintptr_t)checkseg.sh);
                    horrors++;
                } else {
                    if (!(((sorg(checkseg) == pa) && (sdest(checkseg) == pb)) ||
                          ((sorg(checkseg) == pb) && (sdest(checkseg) == pa)))) {
                        printf("  !! !! Wrong subface-subseg connection.\n");
                        printf("    Sub: x%lx (%d, %d, %d).\n", (uintptr_t)shloop.sh,
                               pointmark(sorg(shloop)), pointmark(sdest(shloop)),
                               pointmark(sapex(shloop)));
                        printf("    Seg: x%lx (%d, %d).\n", (uintptr_t)checkseg.sh,
                               pointmark(sorg(checkseg)), pointmark(sdest(checkseg)));
                        horrors++;
                    }
                }
            }
            if (horrors > bakcount) break; // An error detected.
            senextself(shloop);
        }
        // Check tet-subface connection.
        stpivot(shloop, neightet);
        if (neightet.tet != NULL) {
            if (neightet.tet[4] == NULL) {
                printf("  !! !! Wrong sub-to-tet connection (Dead tet)\n");
                printf("    Sub: x%lx (%d, %d, %d).\n", (uintptr_t)shloop.sh,
                       pointmark(sorg(shloop)), pointmark(sdest(shloop)), pointmark(sapex(shloop)));
                printf("    Tet: x%lx (DEAD)\n", (uintptr_t)neightet.tet);
                horrors++;
            } else {
                if (!((sorg(shloop) == org(neightet)) && (sdest(shloop) == dest(neightet)))) {
                    printf("  !! !! Wrong sub-to-tet connection\n");
                    printf("    Sub: x%lx (%d, %d, %d).\n", (uintptr_t)shloop.sh,
                           pointmark(sorg(shloop)), pointmark(sdest(shloop)),
                           pointmark(sapex(shloop)));
                    printf("    Tet: x%lx (%d, %d, %d, %d).\n", (uintptr_t)neightet.tet,
                           pointmark(org(neightet)), pointmark(dest(neightet)),
                           pointmark(apex(neightet)), pointmark(oppo(neightet)));
                    horrors++;
                }
                tspivot(neightet, spinsh);
                if (!((sorg(spinsh) == org(neightet)) && (sdest(spinsh) == dest(neightet)))) {
                    printf("  !! !! Wrong tet-sub connection.\n");
                    printf("    Sub: x%lx (%d, %d, %d).\n", (uintptr_t)spinsh.sh,
                           pointmark(sorg(spinsh)), pointmark(sdest(spinsh)),
                           pointmark(sapex(spinsh)));
                    printf("    Tet: x%lx (%d, %d, %d, %d).\n", (uintptr_t)neightet.tet,
                           pointmark(org(neightet)), pointmark(dest(neightet)),
                           pointmark(apex(neightet)), pointmark(oppo(neightet)));
                    horrors++;
                }
                fsym(neightet, symtet);
                tspivot(symtet, spinsh);
                if (spinsh.sh != NULL) {
                    if (!((sorg(spinsh) == org(symtet)) && (sdest(spinsh) == dest(symtet)))) {
                        printf("  !! !! Wrong tet-sub connection.\n");
                        printf("    Sub: x%lx (%d, %d, %d).\n", (uintptr_t)spinsh.sh,
                               pointmark(sorg(spinsh)), pointmark(sdest(spinsh)),
                               pointmark(sapex(spinsh)));
                        printf("    Tet: x%lx (%d, %d, %d, %d).\n", (uintptr_t)symtet.tet,
                               pointmark(org(symtet)), pointmark(dest(symtet)),
                               pointmark(apex(symtet)), pointmark(oppo(symtet)));
                        horrors++;
                    }
                } else {
                    printf("  Warning: Broken tet-sub-tet connection.\n");
                }
            }
        }
        if (sinfected(shloop)) {
            // This may be a bug. report it.
            printf("  !! A infected subface: (%d, %d, %d).\n", pointmark(sorg(shloop)),
                   pointmark(sdest(shloop)), pointmark(sapex(shloop)));
        }
        if (smarktested(shloop)) {
            // This may be a bug. report it.
            printf("  !! A marked subface: (%d, %d, %d).\n", pointmark(sorg(shloop)),
                   pointmark(sdest(shloop)), pointmark(sapex(shloop)));
        }
        shloop.sh = shellfacetraverse(subfaces);
    }

    if (horrors == 0) {
        if (!b->quiet) {
            printf("  Mesh boundaries connected correctly.\n");
        }
    } else {
        printf("  !! !! !! !! %d boundary connection viewed with horror.\n", horrors);
    }

    subfaces->pathblock = bakpathblock;
    subfaces->pathitem = bakpathitem;
    subfaces->pathitemsleft = bakpathitemsleft;
    subfaces->alignbytes = bakalignbytes;

    return horrors;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// checksegments()    Check the connections between tetrahedra and segments. //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::checksegments() {
    triface tetloop, neightet, spintet;
    shellface* segs;
    face neighsh, spinsh, checksh;
    face sseg, checkseg;
    point pa, pb;
    int miscount;
    int t1ver;
    int horrors, i;

    if (!b->quiet) {
        printf("  Checking tet->seg connections...\n");
    }

    horrors = 0;
    tetrahedrons->traversalinit();
    tetloop.tet = tetrahedrontraverse();
    while (tetloop.tet != NULL) {
        // Loop the six edges of the tet.
        if (tetloop.tet[8] != NULL) {
            segs = (shellface*)tetloop.tet[8];
            for (i = 0; i < 6; i++) {
                sdecode(segs[i], sseg);
                if (sseg.sh != NULL) {
                    // Get the edge of the tet.
                    tetloop.ver = edge2ver[i];
                    // Check if they are the same edge.
                    pa = (point)sseg.sh[3];
                    pb = (point)sseg.sh[4];
                    if (!(((org(tetloop) == pa) && (dest(tetloop) == pb)) ||
                          ((org(tetloop) == pb) && (dest(tetloop) == pa)))) {
                        printf("  !! Wrong tet-seg connection.\n");
                        printf("    Tet: x%lx (%d, %d, %d, %d) - Seg: x%lx (%d, %d).\n",
                               (uintptr_t)tetloop.tet, pointmark(org(tetloop)),
                               pointmark(dest(tetloop)), pointmark(apex(tetloop)),
                               pointmark(oppo(tetloop)), (uintptr_t)sseg.sh, pointmark(pa),
                               pointmark(pb));
                        horrors++;
                    } else {
                        // Loop all tets sharing at this edge.
                        neightet = tetloop;
                        do {
                            tsspivot1(neightet, checkseg);
                            if (checkseg.sh != sseg.sh) {
                                printf("  !! Wrong tet->seg connection.\n");
                                printf("    Tet: x%lx (%d, %d, %d, %d) - ", (uintptr_t)neightet.tet,
                                       pointmark(org(neightet)), pointmark(dest(neightet)),
                                       pointmark(apex(neightet)), pointmark(oppo(neightet)));
                                if (checkseg.sh != NULL) {
                                    printf("Seg x%lx (%d, %d).\n", (uintptr_t)checkseg.sh,
                                           pointmark(sorg(checkseg)), pointmark(sdest(checkseg)));
                                } else {
                                    printf("Seg: NULL.\n");
                                }
                                horrors++;
                            }
                            fnextself(neightet);
                        } while (neightet.tet != tetloop.tet);
                    }
                    // Check the seg->tet pointer.
                    sstpivot1(sseg, neightet);
                    if (neightet.tet == NULL) {
                        printf("  !! Wrong seg->tet connection (A NULL tet).\n");
                        horrors++;
                    } else {
                        if (!(((org(neightet) == pa) && (dest(neightet) == pb)) ||
                              ((org(neightet) == pb) && (dest(neightet) == pa)))) {
                            printf("  !! Wrong seg->tet connection (Wrong edge).\n");
                            printf("    Tet: x%lx (%d, %d, %d, %d) - Seg: x%lx (%d, %d).\n",
                                   (uintptr_t)neightet.tet, pointmark(org(neightet)),
                                   pointmark(dest(neightet)), pointmark(apex(neightet)),
                                   pointmark(oppo(neightet)), (uintptr_t)sseg.sh, pointmark(pa),
                                   pointmark(pb));
                            horrors++;
                        }
                    }
                }
            }
        }
        // Loop the six edge of this tet.
        neightet.tet = tetloop.tet;
        for (i = 0; i < 6; i++) {
            neightet.ver = edge2ver[i];
            if (edgemarked(neightet)) {
                // A possible bug. Report it.
                printf("  !! A marked edge: (%d, %d, %d, %d) -- x%lx %d.\n",
                       pointmark(org(neightet)), pointmark(dest(neightet)),
                       pointmark(apex(neightet)), pointmark(oppo(neightet)),
                       (uintptr_t)neightet.tet, neightet.ver);
                // Check if all tets at the edge are marked.
                spintet = neightet;
                while (1) {
                    fnextself(spintet);
                    if (!edgemarked(spintet)) {
                        printf("  !! !! An unmarked edge (%d, %d, %d, %d) -- x%lx %d.\n",
                               pointmark(org(spintet)), pointmark(dest(spintet)),
                               pointmark(apex(spintet)), pointmark(oppo(spintet)),
                               (uintptr_t)spintet.tet, spintet.ver);
                        horrors++;
                    }
                    if (spintet.tet == neightet.tet) break;
                }
            }
        }
        tetloop.tet = tetrahedrontraverse();
    }

    if (!b->quiet) {
        printf("  Checking seg->tet connections...\n");
    }

    miscount = 0; // Count the number of unrecovered segments.
    subsegs->traversalinit();
    sseg.shver = 0;
    sseg.sh = shellfacetraverse(subsegs);
    while (sseg.sh != NULL) {
        pa = sorg(sseg);
        pb = sdest(sseg);
        spivot(sseg, neighsh);
        if (neighsh.sh != NULL) {
            spinsh = neighsh;
            while (1) {
                // Check seg-subface bond.
                if (((sorg(spinsh) == pa) && (sdest(spinsh) == pb)) ||
                    ((sorg(spinsh) == pb) && (sdest(spinsh) == pa))) {
                    // Keep the same rotate direction.
                    // if (sorg(spinsh) != pa) {
                    //  sesymself(spinsh);
                    //  printf("  !! Wrong ori at subface (%d, %d, %d) -- x%lx %d\n",
                    //         pointmark(sorg(spinsh)), pointmark(sdest(spinsh)),
                    //         pointmark(sapex(spinsh)), (uintptr_t) spinsh.sh,
                    //         spinsh.shver);
                    //  horrors++;
                    //}
                    stpivot(spinsh, spintet);
                    if (spintet.tet != NULL) {
                        // Check if all tets at this segment.
                        while (1) {
                            tsspivot1(spintet, checkseg);
                            if (checkseg.sh == NULL) {
                                printf("  !! !! No seg at tet (%d, %d, %d, %d) -- x%lx %d\n",
                                       pointmark(org(spintet)), pointmark(dest(spintet)),
                                       pointmark(apex(spintet)), pointmark(oppo(spintet)),
                                       (uintptr_t)spintet.tet, spintet.ver);
                                horrors++;
                            }
                            if (checkseg.sh != sseg.sh) {
                                printf("  !! !! Wrong seg (%d, %d) at tet (%d, %d, %d, %d)\n",
                                       pointmark(sorg(checkseg)), pointmark(sdest(checkseg)),
                                       pointmark(org(spintet)), pointmark(dest(spintet)),
                                       pointmark(apex(spintet)), pointmark(oppo(spintet)));
                                horrors++;
                            }
                            fnextself(spintet);
                            // Stop at the next subface.
                            tspivot(spintet, checksh);
                            if (checksh.sh != NULL) break;
                        } // while (1)
                    }
                } else {
                    printf("  !! Wrong seg-subface (%d, %d, %d) -- x%lx %d connect\n",
                           pointmark(sorg(spinsh)), pointmark(sdest(spinsh)),
                           pointmark(sapex(spinsh)), (uintptr_t)spinsh.sh, spinsh.shver);
                    horrors++;
                    break;
                } // if pa, pb
                spivotself(spinsh);
                if (spinsh.sh == NULL) break; // A dangling segment.
                if (spinsh.sh == neighsh.sh) break;
            } // while (1)
        }     // if (neighsh.sh != NULL)
        // Count the number of "un-recovered" segments.
        sstpivot1(sseg, neightet);
        if (neightet.tet == NULL) {
            miscount++;
        }
        sseg.sh = shellfacetraverse(subsegs);
    }

    if (!b->quiet) {
        printf("  Checking seg->seg connections...\n");
    }

    points->traversalinit();
    pa = pointtraverse();
    while (pa != NULL) {
        if (pointtype(pa) == FREESEGVERTEX) {
            // There should be two subsegments connected at 'pa'.
            // Get a subsegment containing 'pa'.
            sdecode(point2sh(pa), sseg);
            if ((sseg.sh == NULL) || sseg.sh[3] == NULL) {
                printf("  !! Dead point-to-seg pointer at point %d.\n", pointmark(pa));
                horrors++;
            } else {
                sseg.shver = 0;
                if (sorg(sseg) != pa) {
                    if (sdest(sseg) != pa) {
                        printf("  !! Wrong point-to-seg pointer at point %d.\n", pointmark(pa));
                        horrors++;
                    } else {
                        // Find the next subsegment at 'pa'.
                        senext(sseg, checkseg);
                        if ((checkseg.sh == NULL) || (checkseg.sh[3] == NULL)) {
                            printf("  !! Dead seg-seg connection at point %d.\n", pointmark(pa));
                            horrors++;
                        } else {
                            spivotself(checkseg);
                            checkseg.shver = 0;
                            if ((sorg(checkseg) != pa) && (sdest(checkseg) != pa)) {
                                printf("  !! Wrong seg-seg connection at point %d.\n",
                                       pointmark(pa));
                                horrors++;
                            }
                        }
                    }
                } else {
                    // Find the previous subsegment at 'pa'.
                    senext2(sseg, checkseg);
                    if ((checkseg.sh == NULL) || (checkseg.sh[3] == NULL)) {
                        printf("  !! Dead seg-seg connection at point %d.\n", pointmark(pa));
                        horrors++;
                    } else {
                        spivotself(checkseg);
                        checkseg.shver = 0;
                        if ((sorg(checkseg) != pa) && (sdest(checkseg) != pa)) {
                            printf("  !! Wrong seg-seg connection at point %d.\n", pointmark(pa));
                            horrors++;
                        }
                    }
                }
            }
        }
        pa = pointtraverse();
    }

    if (horrors == 0) {
        printf("  Segments are connected properly.\n");
    } else {
        printf("  !! !! !! !! Found %d missing connections.\n", horrors);
    }
    if (miscount > 0) {
        printf("  !! !! Found %d missing segments.\n", miscount);
    }

    return horrors;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// checkdelaunay()    Ensure that the mesh is (constrained) Delaunay.        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::checkdelaunay(int perturb) {
    triface tetloop;
    triface symtet;
    face checksh;
    point pa, pb, pc, pd, pe;
    REAL sign;
    int ndcount; // Count the non-locally Delaunay faces.
    int horrors;

    if (!b->quiet) {
        printf("  Checking Delaunay property of the mesh...\n");
    }

    ndcount = 0;
    horrors = 0;
    tetloop.ver = 0;
    // Run through the list of triangles, checking each one.
    tetrahedrons->traversalinit();
    tetloop.tet = tetrahedrontraverse();
    while (tetloop.tet != (tetrahedron*)NULL) {
        // Check all four faces of the tetrahedron.
        for (tetloop.ver = 0; tetloop.ver < 4; tetloop.ver++) {
            fsym(tetloop, symtet);
            // Only do test if its adjoining tet is not a hull tet or its pointer
            //   is larger (to ensure that each pair isn't tested twice).
            if (((point)symtet.tet[7] != dummypoint) && (tetloop.tet < symtet.tet)) {
                pa = org(tetloop);
                pb = dest(tetloop);
                pc = apex(tetloop);
                pd = oppo(tetloop);
                pe = oppo(symtet);
                if (perturb) {
                    sign = insphere_s(pa, pb, pc, pd, pe);
                } else {
                    sign = insphere(pa, pb, pc, pd, pe);
                }
                if (sign < 0.0) {
                    ndcount++;
                    if (checksubfaceflag) {
                        tspivot(tetloop, checksh);
                    }
                    if (checksh.sh == NULL) {
                        printf("  !! Non-locally Delaunay (%d, %d, %d) - %d, %d\n", pointmark(pa),
                               pointmark(pb), pointmark(pc), pointmark(pd), pointmark(pe));
                        horrors++;
                    }
                }
            }
        }
        tetloop.tet = tetrahedrontraverse();
    }

    if (horrors == 0) {
        if (!b->quiet) {
            if (ndcount > 0) {
                printf("  The mesh is constrained Delaunay.\n");
            } else {
                printf("  The mesh is Delaunay.\n");
            }
        }
    } else {
        printf("  !! !! !! !! Found %d non-Delaunay faces.\n", horrors);
    }

    return horrors;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Check if the current tetrahedralization is (constrained) regular.         //
//                                                                           //
// The parameter 'type' determines which regularity should be checked:       //
//   - 0:  check the Delaunay property.                                      //
//   - 1:  check the Delaunay property with symbolic perturbation.           //
//   - 2:  check the regular property, the weights are stored in p[3].       //
//   - 3:  check the regular property with symbolic perturbation.            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::checkregular(int type) {
    triface tetloop;
    triface symtet;
    face checksh;
    point p[5];
    REAL sign;
    int ndcount; // Count the non-locally Delaunay faces.
    int horrors;

    if (!b->quiet) {
        printf("  Checking %s %s property of the mesh...\n",
               (type & 2) == 0 ? "Delaunay" : "regular", (type & 1) == 0 ? " " : "(s)");
    }

    // Make sure orient3d(p[1], p[0], p[2], p[3]) > 0;
    //   Hence if (insphere(p[1], p[0], p[2], p[3], p[4]) > 0) means that
    //     p[4] lies inside the circumsphere of p[1], p[0], p[2], p[3].
    //   The same if orient4d(p[1], p[0], p[2], p[3], p[4]) > 0 means that
    //     p[4] lies below the oriented hyperplane passing through
    //     p[1], p[0], p[2], p[3].

    ndcount = 0;
    horrors = 0;
    tetloop.ver = 0;
    // Run through the list of triangles, checking each one.
    tetrahedrons->traversalinit();
    tetloop.tet = tetrahedrontraverse();
    while (tetloop.tet != (tetrahedron*)NULL) {
        // Check all four faces of the tetrahedron.
        for (tetloop.ver = 0; tetloop.ver < 4; tetloop.ver++) {
            fsym(tetloop, symtet);
            // Only do test if its adjoining tet is not a hull tet or its pointer
            //   is larger (to ensure that each pair isn't tested twice).
            if (((point)symtet.tet[7] != dummypoint) && (tetloop.tet < symtet.tet)) {
                p[0] = org(tetloop);  // pa
                p[1] = dest(tetloop); // pb
                p[2] = apex(tetloop); // pc
                p[3] = oppo(tetloop); // pd
                p[4] = oppo(symtet);  // pe

                if (type == 0) {
                    sign = insphere(p[1], p[0], p[2], p[3], p[4]);
                } else if (type == 1) {
                    sign = insphere_s(p[1], p[0], p[2], p[3], p[4]);
                } else if (type == 2) {
                    sign = orient4d(p[1], p[0], p[2], p[3], p[4], p[1][3], p[0][3], p[2][3],
                                    p[3][3], p[4][3]);
                } else { // type == 3
                    sign = orient4d_s(p[1], p[0], p[2], p[3], p[4], p[1][3], p[0][3], p[2][3],
                                      p[3][3], p[4][3]);
                }

                if (sign > 0.0) {
                    ndcount++;
                    if (checksubfaceflag) {
                        tspivot(tetloop, checksh);
                    }
                    if (checksh.sh == NULL) {
                        printf("  !! Non-locally %s (%d, %d, %d) - %d, %d\n",
                               (type & 2) == 0 ? "Delaunay" : "regular", pointmark(p[0]),
                               pointmark(p[1]), pointmark(p[2]), pointmark(p[3]), pointmark(p[4]));
                        horrors++;
                    }
                }
            }
        }
        tetloop.tet = tetrahedrontraverse();
    }

    if (horrors == 0) {
        if (!b->quiet) {
            if (ndcount > 0) {
                printf("  The mesh is constrained %s.\n", (type & 2) == 0 ? "Delaunay" : "regular");
            } else {
                printf("  The mesh is %s.\n", (type & 2) == 0 ? "Delaunay" : "regular");
            }
        }
    } else {
        printf("  !! !! !! !! Found %d non-%s faces.\n", horrors,
               (type & 2) == 0 ? "Delaunay" : "regular");
    }

    return horrors;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// checkconforming()    Ensure that the mesh is conforming Delaunay.         //
//                                                                           //
// If 'flag' is 1, only check subsegments. If 'flag' is 2, check subfaces.   //
// If 'flag' is 3, check both subsegments and subfaces.                      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int tetgenmesh::checkconforming(int flag) {
    triface searchtet, neightet, spintet;
    face shloop;
    face segloop;
    point eorg, edest, eapex, pa, pb, pc;
    REAL cent[3], radius, dist, diff, rd, len;
    bool enq;
    int encsubsegs, encsubfaces;
    int t1ver;
    int i;

    REAL A[4][4], rhs[4], D;
    int indx[4];
    REAL elen[3];

    encsubsegs = 0;

    if (flag & 1) {
        if (!b->quiet) {
            printf("  Checking conforming property of segments...\n");
        }
        encsubsegs = 0;

        // Run through the list of subsegments, check each one.
        subsegs->traversalinit();
        segloop.sh = shellfacetraverse(subsegs);
        while (segloop.sh != (shellface*)NULL) {
            eorg = (point)segloop.sh[3];
            edest = (point)segloop.sh[4];
            radius = 0.5 * distance(eorg, edest);
            for (i = 0; i < 3; i++)
                cent[i] = 0.5 * (eorg[i] + edest[i]);

            enq = false;
            sstpivot1(segloop, neightet);
            if (neightet.tet != NULL) {
                spintet = neightet;
                while (1) {
                    eapex = apex(spintet);
                    if (eapex != dummypoint) {
                        dist = distance(eapex, cent);
                        diff = dist - radius;
                        if (fabs(diff) / radius <= b->epsilon) diff = 0.0; // Rounding.
                        if (diff < 0) {
                            enq = true;
                            break;
                        }
                    }
                    fnextself(spintet);
                    if (spintet.tet == neightet.tet) break;
                }
            }
            if (enq) {
                printf("  !! !! Non-conforming segment: (%d, %d)\n", pointmark(eorg),
                       pointmark(edest));
                encsubsegs++;
            }
            segloop.sh = shellfacetraverse(subsegs);
        }

        if (encsubsegs == 0) {
            if (!b->quiet) {
                printf("  The segments are conforming Delaunay.\n");
            }
        } else {
            printf("  !! !! %d subsegments are non-conforming.\n", encsubsegs);
        }
    } // if (flag & 1)

    encsubfaces = 0;

    if (flag & 2) {
        if (!b->quiet) {
            printf("  Checking conforming property of subfaces...\n");
        }

        // Run through the list of subfaces, check each one.
        subfaces->traversalinit();
        shloop.sh = shellfacetraverse(subfaces);
        while (shloop.sh != (shellface*)NULL) {
            pa = (point)shloop.sh[3];
            pb = (point)shloop.sh[4];
            pc = (point)shloop.sh[5];

            // Compute the coefficient matrix A (3x3).
            A[0][0] = pb[0] - pa[0];
            A[0][1] = pb[1] - pa[1];
            A[0][2] = pb[2] - pa[2]; // vector V1 (pa->pb)
            A[1][0] = pc[0] - pa[0];
            A[1][1] = pc[1] - pa[1];
            A[1][2] = pc[2] - pa[2]; // vector V2 (pa->pc)
            cross(A[0], A[1], A[2]); // vector V3 (V1 X V2)

            // Compute the right hand side vector b (3x1).
            elen[0] = dot(A[0], A[0]);
            elen[1] = dot(A[1], A[1]);
            rhs[0] = 0.5 * elen[0];
            rhs[1] = 0.5 * elen[1];
            rhs[2] = 0.0;

            if (lu_decmp(A, 3, indx, &D, 0)) {
                lu_solve(A, 3, indx, rhs, 0);
                cent[0] = pa[0] + rhs[0];
                cent[1] = pa[1] + rhs[1];
                cent[2] = pa[2] + rhs[2];
                rd = sqrt(rhs[0] * rhs[0] + rhs[1] * rhs[1] + rhs[2] * rhs[2]);

                // Check if this subface is encroached.
                for (i = 0; i < 2; i++) {
                    stpivot(shloop, searchtet);
                    if (!ishulltet(searchtet)) {
                        len = distance(oppo(searchtet), cent);
                        if ((fabs(len - rd) / rd) < b->epsilon) len = rd; // Rounding.
                        if (len < rd) {
                            printf("  !! !! Non-conforming subface: (%d, %d, %d)\n", pointmark(pa),
                                   pointmark(pb), pointmark(pc));
                            encsubfaces++;
                            enq = true;
                            break;
                        }
                    }
                    sesymself(shloop);
                }
            }
            shloop.sh = shellfacetraverse(subfaces);
        }

        if (encsubfaces == 0) {
            if (!b->quiet) {
                printf("  The subfaces are conforming Delaunay.\n");
            }
        } else {
            printf("  !! !! %d subfaces are non-conforming.\n", encsubfaces);
        }
    } // if (flag & 2)

    return encsubsegs + encsubfaces;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// qualitystatistics()    Print statistics about the quality of the mesh.    //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::qualitystatistics() {
    triface tetloop, neightet;
    point p[4];
    char sbuf[128];
    REAL radiusratiotable[12];
    REAL aspectratiotable[12];
    REAL A[4][4], rhs[4], D;
    REAL V[6][3], N[4][3], H[4]; // edge-vectors, face-normals, face-heights.
    REAL edgelength[6], alldihed[6], faceangle[3];
    REAL shortest, longest;
    REAL smallestvolume, biggestvolume;
    REAL smallestratio, biggestratio;
    REAL smallestradiusratio, biggestradiusratio; // radius-edge ratio.
    REAL smallestdiangle, biggestdiangle;
    REAL smallestfaangle, biggestfaangle;
    REAL total_tet_vol, total_tetprism_vol;
    REAL tetvol, minaltitude;
    REAL cirradius, minheightinv; // insradius;
    REAL shortlen, longlen;
    REAL tetaspect, tetradius;
    REAL smalldiangle, bigdiangle;
    REAL smallfaangle, bigfaangle;
    unsigned long radiustable[12];
    unsigned long aspecttable[16];
    unsigned long dihedangletable[18];
    unsigned long faceangletable[18];
    int indx[4];
    int radiusindex;
    int aspectindex;
    int tendegree;
    int i, j;
    // Report the tet which has the biggest radius-edge ratio.
    triface biggestradiusratiotet;

    printf("Mesh quality statistics:\n\n");

    shortlen = longlen = 0.0;
    smalldiangle = bigdiangle = 0.0;
    total_tet_vol = 0.0;
    total_tetprism_vol = 0.0;

    radiusratiotable[0] = 0.707;
    radiusratiotable[1] = 1.0;
    radiusratiotable[2] = 1.1;
    radiusratiotable[3] = 1.2;
    radiusratiotable[4] = 1.4;
    radiusratiotable[5] = 1.6;
    radiusratiotable[6] = 1.8;
    radiusratiotable[7] = 2.0;
    radiusratiotable[8] = 2.5;
    radiusratiotable[9] = 3.0;
    radiusratiotable[10] = 10.0;
    radiusratiotable[11] = 0.0;

    aspectratiotable[0] = 1.5;
    aspectratiotable[1] = 2.0;
    aspectratiotable[2] = 2.5;
    aspectratiotable[3] = 3.0;
    aspectratiotable[4] = 4.0;
    aspectratiotable[5] = 6.0;
    aspectratiotable[6] = 10.0;
    aspectratiotable[7] = 15.0;
    aspectratiotable[8] = 25.0;
    aspectratiotable[9] = 50.0;
    aspectratiotable[10] = 100.0;
    aspectratiotable[11] = 0.0;

    for (i = 0; i < 12; i++)
        radiustable[i] = 0l;
    for (i = 0; i < 12; i++)
        aspecttable[i] = 0l;
    for (i = 0; i < 18; i++)
        dihedangletable[i] = 0l;
    for (i = 0; i < 18; i++)
        faceangletable[i] = 0l;

    minaltitude = xmax - xmin + ymax - ymin + zmax - zmin;
    minaltitude = minaltitude * minaltitude;
    shortest = minaltitude;
    longest = 0.0;
    smallestvolume = minaltitude;
    biggestvolume = 0.0;
    smallestratio = smallestradiusratio = 1e+16; // minaltitude;
    biggestratio = biggestradiusratio = 0.0;
    smallestdiangle = smallestfaangle = 180.0;
    biggestdiangle = biggestfaangle = 0.0;

    int attrnum = numelemattrib - 1;

    // Loop all elements, calculate quality parameters for each element.
    tetrahedrons->traversalinit();
    tetloop.tet = tetrahedrontraverse();
    while (tetloop.tet != (tetrahedron*)NULL) {

        if (b->convex) {
            // Skip tets in the exterior.
            if (elemattribute(tetloop.tet, attrnum) == -1.0) {
                tetloop.tet = tetrahedrontraverse();
                continue;
            }
        }

        // Get four vertices: p0, p1, p2, p3.
        for (i = 0; i < 4; i++)
            p[i] = (point)tetloop.tet[4 + i];

        // Get the tet volume.
        tetvol = orient3dfast(p[1], p[0], p[2], p[3]) / 6.0;
        total_tet_vol += tetvol;
        total_tetprism_vol += tetprismvol(p[0], p[1], p[2], p[3]);

        // Calculate the largest and smallest volume.
        if (tetvol < smallestvolume) {
            smallestvolume = tetvol;
        }
        if (tetvol > biggestvolume) {
            biggestvolume = tetvol;
        }

        // Set the edge vectors: V[0], ..., V[5]
        for (i = 0; i < 3; i++)
            V[0][i] = p[0][i] - p[3][i]; // V[0]: p3->p0.
        for (i = 0; i < 3; i++)
            V[1][i] = p[1][i] - p[3][i]; // V[1]: p3->p1.
        for (i = 0; i < 3; i++)
            V[2][i] = p[2][i] - p[3][i]; // V[2]: p3->p2.
        for (i = 0; i < 3; i++)
            V[3][i] = p[1][i] - p[0][i]; // V[3]: p0->p1.
        for (i = 0; i < 3; i++)
            V[4][i] = p[2][i] - p[1][i]; // V[4]: p1->p2.
        for (i = 0; i < 3; i++)
            V[5][i] = p[0][i] - p[2][i]; // V[5]: p2->p0.

        // Get the squares of the edge lengths.
        for (i = 0; i < 6; i++)
            edgelength[i] = dot(V[i], V[i]);

        // Calculate the longest and shortest edge length.
        for (i = 0; i < 6; i++) {
            if (i == 0) {
                shortlen = longlen = edgelength[i];
            } else {
                shortlen = edgelength[i] < shortlen ? edgelength[i] : shortlen;
                longlen = edgelength[i] > longlen ? edgelength[i] : longlen;
            }
            if (edgelength[i] > longest) {
                longest = edgelength[i];
            }
            if (edgelength[i] < shortest) {
                shortest = edgelength[i];
            }
        }

        // Set the matrix A = [V[0], V[1], V[2]]^T.
        for (j = 0; j < 3; j++) {
            for (i = 0; i < 3; i++)
                A[j][i] = V[j][i];
        }

        // Decompose A just once.
        if (lu_decmp(A, 3, indx, &D, 0)) {
            // Get the three faces normals.
            for (j = 0; j < 3; j++) {
                for (i = 0; i < 3; i++)
                    rhs[i] = 0.0;
                rhs[j] = 1.0; // Positive means the inside direction
                lu_solve(A, 3, indx, rhs, 0);
                for (i = 0; i < 3; i++)
                    N[j][i] = rhs[i];
            }
            // Get the fourth face normal by summing up the first three.
            for (i = 0; i < 3; i++)
                N[3][i] = -N[0][i] - N[1][i] - N[2][i];
            // Get the radius of the circumsphere.
            for (i = 0; i < 3; i++)
                rhs[i] = 0.5 * dot(V[i], V[i]);
            lu_solve(A, 3, indx, rhs, 0);
            cirradius = sqrt(dot(rhs, rhs));
            // Normalize the face normals.
            for (i = 0; i < 4; i++) {
                // H[i] is the inverse of height of its corresponding face.
                H[i] = sqrt(dot(N[i], N[i]));
                for (j = 0; j < 3; j++)
                    N[i][j] /= H[i];
            }
            // Get the radius of the inscribed sphere.
            // insradius = 1.0 / (H[0] + H[1] + H[2] + H[3]);
            // Get the biggest H[i] (corresponding to the smallest height).
            minheightinv = H[0];
            for (i = 1; i < 4; i++) {
                if (H[i] > minheightinv) minheightinv = H[i];
            }
        } else {
            // A nearly degenerated tet.
            if (tetvol <= 0.0) {
                printf("  !! Warning:  A %s tet (%d,%d,%d,%d).\n",
                       tetvol < 0 ? "inverted" : "degenerated", pointmark(p[0]), pointmark(p[1]),
                       pointmark(p[2]), pointmark(p[3]));
                // Skip it.
                tetloop.tet = tetrahedrontraverse();
                continue;
            }
            // Calculate the four face normals.
            facenormal(p[2], p[1], p[3], N[0], 1, NULL);
            facenormal(p[0], p[2], p[3], N[1], 1, NULL);
            facenormal(p[1], p[0], p[3], N[2], 1, NULL);
            facenormal(p[0], p[1], p[2], N[3], 1, NULL);
            // Normalize the face normals.
            for (i = 0; i < 4; i++) {
                // H[i] is the twice of the area of the face.
                H[i] = sqrt(dot(N[i], N[i]));
                for (j = 0; j < 3; j++)
                    N[i][j] /= H[i];
            }
            // Get the biggest H[i] / tetvol (corresponding to the smallest height).
            minheightinv = (H[0] / tetvol);
            for (i = 1; i < 4; i++) {
                if ((H[i] / tetvol) > minheightinv) minheightinv = (H[i] / tetvol);
            }
            // Let the circumradius to be the half of its longest edge length.
            cirradius = 0.5 * sqrt(longlen);
        }

        // Get the dihedrals (in degree) at each edges.
        j = 0;
        for (i = 1; i < 4; i++) {
            alldihed[j] = -dot(N[0], N[i]); // Edge cd, bd, bc.
            if (alldihed[j] < -1.0)
                alldihed[j] = -1; // Rounding.
            else if (alldihed[j] > 1.0)
                alldihed[j] = 1;
            alldihed[j] = acos(alldihed[j]) / PI * 180.0;
            j++;
        }
        for (i = 2; i < 4; i++) {
            alldihed[j] = -dot(N[1], N[i]); // Edge ad, ac.
            if (alldihed[j] < -1.0)
                alldihed[j] = -1; // Rounding.
            else if (alldihed[j] > 1.0)
                alldihed[j] = 1;
            alldihed[j] = acos(alldihed[j]) / PI * 180.0;
            j++;
        }
        alldihed[j] = -dot(N[2], N[3]); // Edge ab.
        if (alldihed[j] < -1.0)
            alldihed[j] = -1; // Rounding.
        else if (alldihed[j] > 1.0)
            alldihed[j] = 1;
        alldihed[j] = acos(alldihed[j]) / PI * 180.0;

        // Calculate the largest and smallest dihedral angles.
        for (i = 0; i < 6; i++) {
            if (i == 0) {
                smalldiangle = bigdiangle = alldihed[i];
            } else {
                smalldiangle = alldihed[i] < smalldiangle ? alldihed[i] : smalldiangle;
                bigdiangle = alldihed[i] > bigdiangle ? alldihed[i] : bigdiangle;
            }
            if (alldihed[i] < smallestdiangle) {
                smallestdiangle = alldihed[i];
            }
            if (alldihed[i] > biggestdiangle) {
                biggestdiangle = alldihed[i];
            }
            // Accumulate the corresponding number in the dihedral angle histogram.
            if (alldihed[i] < 5.0) {
                tendegree = 0;
            } else if (alldihed[i] >= 5.0 && alldihed[i] < 10.0) {
                tendegree = 1;
            } else if (alldihed[i] >= 80.0 && alldihed[i] < 110.0) {
                tendegree = 9; // Angles between 80 to 110 degree are in one entry.
            } else if (alldihed[i] >= 170.0 && alldihed[i] < 175.0) {
                tendegree = 16;
            } else if (alldihed[i] >= 175.0) {
                tendegree = 17;
            } else {
                tendegree = (int)(alldihed[i] / 10.);
                if (alldihed[i] < 80.0) {
                    tendegree++; // In the left column.
                } else {
                    tendegree--; // In the right column.
                }
            }
            dihedangletable[tendegree]++;
        }

        // Calculate the largest and smallest face angles.
        for (tetloop.ver = 0; tetloop.ver < 4; tetloop.ver++) {
            fsym(tetloop, neightet);
            // Only do the calulation once for a face.
            if (((point)neightet.tet[7] == dummypoint) || (tetloop.tet < neightet.tet)) {
                p[0] = org(tetloop);
                p[1] = dest(tetloop);
                p[2] = apex(tetloop);
                faceangle[0] = interiorangle(p[0], p[1], p[2], NULL);
                faceangle[1] = interiorangle(p[1], p[2], p[0], NULL);
                faceangle[2] = PI - (faceangle[0] + faceangle[1]);
                // Translate angles into degrees.
                for (i = 0; i < 3; i++) {
                    faceangle[i] = (faceangle[i] * 180.0) / PI;
                }
                // Calculate the largest and smallest face angles.
                for (i = 0; i < 3; i++) {
                    if (i == 0) {
                        smallfaangle = bigfaangle = faceangle[i];
                    } else {
                        smallfaangle = faceangle[i] < smallfaangle ? faceangle[i] : smallfaangle;
                        bigfaangle = faceangle[i] > bigfaangle ? faceangle[i] : bigfaangle;
                    }
                    if (faceangle[i] < smallestfaangle) {
                        smallestfaangle = faceangle[i];
                    }
                    if (faceangle[i] > biggestfaangle) {
                        biggestfaangle = faceangle[i];
                    }
                    tendegree = (int)(faceangle[i] / 10.);
                    faceangletable[tendegree]++;
                }
            }
        }

        // Calculate aspect ratio and radius-edge ratio for this element.
        tetradius = cirradius / sqrt(shortlen);
        if (tetradius < smallestradiusratio) {
            smallestradiusratio = tetradius;
        }
        if (tetradius > biggestradiusratio) {
            biggestradiusratio = tetradius;
            biggestradiusratiotet.tet = tetloop.tet;
        }
        // tetaspect = sqrt(longlen) / (2.0 * insradius);
        tetaspect = sqrt(longlen) * minheightinv;
        // Remember the largest and smallest aspect ratio.
        if (tetaspect < smallestratio) {
            smallestratio = tetaspect;
        }
        if (tetaspect > biggestratio) {
            biggestratio = tetaspect;
        }
        // Accumulate the corresponding number in the aspect ratio histogram.
        aspectindex = 0;
        while ((tetaspect > aspectratiotable[aspectindex]) && (aspectindex < 11)) {
            aspectindex++;
        }
        aspecttable[aspectindex]++;
        radiusindex = 0;
        while ((tetradius > radiusratiotable[radiusindex]) && (radiusindex < 11)) {
            radiusindex++;
        }
        radiustable[radiusindex]++;

        tetloop.tet = tetrahedrontraverse();
    }

    shortest = sqrt(shortest);
    longest = sqrt(longest);
    minaltitude = sqrt(minaltitude);

    printf("  Smallest volume: %16.5g   |  Largest volume: %16.5g\n", smallestvolume,
           biggestvolume);
    printf("  Shortest edge:   %16.5g   |  Longest edge:   %16.5g\n", shortest, longest);
    printf("  Smallest asp.ratio: %13.5g   |  Largest asp.ratio: %13.5g\n", smallestratio,
           biggestratio);
    sprintf(sbuf, "%.17g", biggestfaangle);
    if (strlen(sbuf) > 8) {
        sbuf[8] = '\0';
    }
    printf("  Smallest facangle: %14.5g   |  Largest facangle:       %s\n", smallestfaangle, sbuf);
    sprintf(sbuf, "%.17g", biggestdiangle);
    if (strlen(sbuf) > 8) {
        sbuf[8] = '\0';
    }
    printf("  Smallest dihedral: %14.5g   |  Largest dihedral:       %s\n\n", smallestdiangle,
           sbuf);

    printf("  Aspect ratio histogram:\n");
    printf("         < %-6.6g    :  %8ld      | %6.6g - %-6.6g     :  %8ld\n", aspectratiotable[0],
           aspecttable[0], aspectratiotable[5], aspectratiotable[6], aspecttable[6]);
    for (i = 1; i < 5; i++) {
        printf("  %6.6g - %-6.6g    :  %8ld      | %6.6g - %-6.6g     :  %8ld\n",
               aspectratiotable[i - 1], aspectratiotable[i], aspecttable[i],
               aspectratiotable[i + 5], aspectratiotable[i + 6], aspecttable[i + 6]);
    }
    printf("  %6.6g - %-6.6g    :  %8ld      | %6.6g -            :  %8ld\n", aspectratiotable[4],
           aspectratiotable[5], aspecttable[5], aspectratiotable[10], aspecttable[11]);
    printf("  (A tetrahedron's aspect ratio is its longest edge length");
    printf(" divided by its\n");
    printf("    smallest side height)\n\n");

    printf("  Face angle histogram:\n");
    for (i = 0; i < 9; i++) {
        printf("    %3d - %3d degrees:  %8ld      |    %3d - %3d degrees:  %8ld\n", i * 10,
               i * 10 + 10, faceangletable[i], i * 10 + 90, i * 10 + 100, faceangletable[i + 9]);
    }
    if (minfaceang != PI) {
        printf("  Minimum input face angle is %g (degree).\n", minfaceang / PI * 180.0);
    }
    printf("\n");

    printf("  Dihedral angle histogram:\n");
    // Print the three two rows:
    printf("     %3d - %2d degrees:  %8ld      |    %3d - %3d degrees:  %8ld\n", 0, 5,
           dihedangletable[0], 80, 110, dihedangletable[9]);
    printf("     %3d - %2d degrees:  %8ld      |    %3d - %3d degrees:  %8ld\n", 5, 10,
           dihedangletable[1], 110, 120, dihedangletable[10]);
    // Print the third to seventh rows.
    for (i = 2; i < 7; i++) {
        printf("     %3d - %2d degrees:  %8ld      |    %3d - %3d degrees:  %8ld\n", (i - 1) * 10,
               (i - 1) * 10 + 10, dihedangletable[i], (i - 1) * 10 + 110, (i - 1) * 10 + 120,
               dihedangletable[i + 9]);
    }
    // Print the last two rows.
    printf("     %3d - %2d degrees:  %8ld      |    %3d - %3d degrees:  %8ld\n", 60, 70,
           dihedangletable[7], 170, 175, dihedangletable[16]);
    printf("     %3d - %2d degrees:  %8ld      |    %3d - %3d degrees:  %8ld\n", 70, 80,
           dihedangletable[8], 175, 180, dihedangletable[17]);
    if (minfacetdihed != PI) {
        printf("  Minimum input dihedral angle is %g (degree).\n", minfacetdihed / PI * 180.0);
    }
    printf("\n");

    printf("\n");
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// memorystatistics()    Report the memory usage.                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::memorystatistics() {
    printf("Memory usage statistics:\n\n");

    // Count the number of blocks of tetrahedra.
    int tetblocks = 0;
    tetrahedrons->pathblock = tetrahedrons->firstblock;
    while (tetrahedrons->pathblock != NULL) {
        tetblocks++;
        tetrahedrons->pathblock = (void**)*(tetrahedrons->pathblock);
    }

    // Calculate the total memory (in bytes) used by storing meshes.
    unsigned long totalmeshmemory = 0l, totalt2shmemory = 0l;
    totalmeshmemory =
        points->maxitems * points->itembytes + tetrahedrons->maxitems * tetrahedrons->itembytes;
    if (b->plc || b->refine) {
        totalmeshmemory +=
            (subfaces->maxitems * subfaces->itembytes + subsegs->maxitems * subsegs->itembytes);
        totalt2shmemory = (tet2subpool->maxitems * tet2subpool->itembytes +
                           tet2segpool->maxitems * tet2segpool->itembytes);
    }

    unsigned long totalalgomemory = 0l;
    totalalgomemory = cavetetlist->totalmemory + cavebdrylist->totalmemory +
                      caveoldtetlist->totalmemory + flippool->maxitems * flippool->itembytes;
    if (b->plc || b->refine) {
        totalalgomemory +=
            (subsegstack->totalmemory + subfacstack->totalmemory + subvertstack->totalmemory +
             caveshlist->totalmemory + caveshbdlist->totalmemory + cavesegshlist->totalmemory +
             cavetetshlist->totalmemory + cavetetseglist->totalmemory + caveencshlist->totalmemory +
             caveencseglist->totalmemory + cavetetvertlist->totalmemory + unflipqueue->totalmemory);
    }

    printf("  Maximum number of tetrahedra:  %ld\n", tetrahedrons->maxitems);
    printf("  Maximum number of tet blocks (blocksize = %d):  %d\n", b->tetrahedraperblock,
           tetblocks);
    /*
    if (b->plc || b->refine) {
      printf("  Approximate memory for tetrahedral mesh (bytes):  %ld\n",
             totalmeshmemory);

      printf("  Approximate memory for extra pointers (bytes):  %ld\n",
             totalt2shmemory);
    } else {
      printf("  Approximate memory for tetrahedralization (bytes):  %ld\n",
             totalmeshmemory);
    }
    printf("  Approximate memory for algorithms (bytes):  %ld\n",
           totalalgomemory);
    printf("  Approximate memory for working arrays (bytes):  %ld\n",
           totalworkmemory);
    printf("  Approximate total used memory (bytes):  %ld\n",
           totalmeshmemory + totalt2shmemory + totalalgomemory +
           totalworkmemory);
    */
    if (b->plc || b->refine) {
        printf("  Approximate memory for tetrahedral mesh (bytes):  ");
        printfcomma(totalmeshmemory);
        printf("\n");

        printf("  Approximate memory for extra pointers (bytes):  ");
        printfcomma(totalt2shmemory);
        printf("\n");
    } else {
        printf("  Approximate memory for tetrahedralization (bytes):  ");
        printfcomma(totalmeshmemory);
        printf("\n");
    }
    printf("  Approximate memory for algorithms (bytes):  ");
    printfcomma(totalalgomemory);
    printf("\n");
    printf("  Approximate memory for working arrays (bytes):  ");
    printfcomma(totalworkmemory);
    printf("\n");
    printf("  Approximate total used memory (bytes):  ");
    printfcomma(totalmeshmemory + totalt2shmemory + totalalgomemory + totalworkmemory);
    printf("\n");

    printf("\n");
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// statistics()    Print all sorts of cool facts.                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::statistics() {
    long tetnumber, facenumber;

    printf("\nStatistics:\n\n");
    printf("  Input points: %d\n", in->numberofpoints);
    if (b->refine) {
        printf("  Input tetrahedra: %d\n", in->numberoftetrahedra);
        if (in->numberoftrifaces > 0) {
            printf("  Input triangles: %d\n", in->numberoftrifaces);
        }
        if (in->numberofedges > 0) {
            printf("  Input edges: %d\n", in->numberofedges);
        }
    } else if (b->plc) {
        printf("  Input facets: %d\n", in->numberoffacets);
        printf("  Input segments: %ld\n", insegments);
        if (in->numberofedges > 0) {
            printf("  Input edges: %d\n", in->numberofedges);
        }
        printf("  Input holes: %d\n", in->numberofholes);
        printf("  Input regions: %d\n", in->numberofregions);
    }

    tetnumber = tetrahedrons->items - hullsize;
    facenumber = (tetnumber * 4l + hullsize) / 2l;

    if (b->weighted) { // -w option
        printf("\n  Mesh points: %ld\n", points->items - nonregularcount);
    } else {
        printf("\n  Mesh points: %ld\n", points->items);
    }
    printf("  Mesh tetrahedra: %ld\n", tetnumber);
    printf("  Mesh faces: %ld\n", facenumber);
    if (meshedges > 0l) {
        printf("  Mesh edges: %ld\n", meshedges);
    } else {
        if (!nonconvex) {
            long vsize = points->items - dupverts - unuverts;
            if (b->weighted) vsize -= nonregularcount;
            meshedges = vsize + facenumber - tetnumber - 1;
            printf("  Mesh edges: %ld\n", meshedges);
        }
    }

    if (b->plc || b->refine) {
        printf("  Mesh faces on exterior boundary: %ld\n", hullsize);
        if (meshhulledges > 0l) {
            printf("  Mesh edges on exterior boundary: %ld\n", meshhulledges);
        }
        printf("  Mesh faces on input facets: %ld\n", subfaces->items);
        printf("  Mesh edges on input segments: %ld\n", subsegs->items);
        if (st_facref_count > 0l) {
            printf("  Steiner points on input facets:  %ld\n", st_facref_count);
        }
        if (st_segref_count > 0l) {
            printf("  Steiner points on input segments:  %ld\n", st_segref_count);
        }
        if (st_volref_count > 0l) {
            printf("  Steiner points inside domain: %ld\n", st_volref_count);
        }
    } else {
        printf("  Convex hull faces: %ld\n", hullsize);
        if (meshhulledges > 0l) {
            printf("  Convex hull edges: %ld\n", meshhulledges);
        }
    }
    if (b->weighted) { // -w option
        printf("  Skipped non-regular points: %ld\n", nonregularcount);
    }
    printf("\n");

    if (b->verbose > 0) {
        if (b->plc || b->refine) { // -p or -r
            if (tetrahedrons->items > 0l) {
                qualitystatistics();
            }
        }
        if (tetrahedrons->items > 0l) {
            memorystatistics();
        }
    }
}

////                                                                       ////
////                                                                       ////
//// meshstat_cxx /////////////////////////////////////////////////////////////

//// output_cxx ///////////////////////////////////////////////////////////////
////                                                                       ////
////                                                                       ////

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// jettisonnodes()    Jettison unused or duplicated vertices.                //
//                                                                           //
// Unused points are those input points which are outside the mesh domain or //
// have no connection (isolated) to the mesh.  Duplicated points exist for   //
// example if the input PLC is read from a .stl mesh file (marked during the //
// Delaunay tetrahedralization step. This routine remove these points from   //
// points list. All existing points are reindexed.                           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::jettisonnodes() {
    point pointloop;
    bool jetflag;
    int oldidx, newidx;
    int remcount;

    if (!b->quiet) {
        printf("Jettisoning redundant points.\n");
    }

    points->traversalinit();
    pointloop = pointtraverse();
    oldidx = newidx = 0; // in->firstnumber;
    remcount = 0;
    while (pointloop != (point)NULL) {
        jetflag =
            (pointtype(pointloop) == DUPLICATEDVERTEX) || (pointtype(pointloop) == UNUSEDVERTEX);
        if (jetflag) {
            // It is a duplicated or unused point, delete it.
            pointdealloc(pointloop);
            remcount++;
        } else {
            // Re-index it.
            setpointmark(pointloop, newidx + in->firstnumber);
            if (in->pointmarkerlist != (int*)NULL) {
                if (oldidx < in->numberofpoints) {
                    // Re-index the point marker as well.
                    in->pointmarkerlist[newidx] = in->pointmarkerlist[oldidx];
                }
            }
            newidx++;
        }
        oldidx++;
        pointloop = pointtraverse();
    }
    if (b->verbose) {
        printf("  %ld duplicated vertices are removed.\n", dupverts);
        printf("  %ld unused vertices are removed.\n", unuverts);
    }
    dupverts = 0l;
    unuverts = 0l;

    // The following line ensures that dead items in the pool of nodes cannot
    //   be allocated for the new created nodes. This ensures that the input
    //   nodes will occur earlier in the output files, and have lower indices.
    points->deaditemstack = (void*)NULL;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// highorder()   Create extra nodes for quadratic subparametric elements.    //
//                                                                           //
// 'highordertable' is an array (size = numberoftetrahedra * 6) for storing  //
// high-order nodes of each tetrahedron.  This routine is used only when -o2 //
// switch is used.                                                           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::highorder() {
    triface tetloop, worktet, spintet;
    point *extralist, *adjextralist;
    point torg, tdest, newpoint;
    int highorderindex;
    int t1ver;
    int i, j;

    if (!b->quiet) {
        printf("Adding vertices for second-order tetrahedra.\n");
    }

    // Initialize the 'highordertable'.
    highordertable = new point[tetrahedrons->items * 6];
    if (highordertable == (point*)NULL) {
        terminatetetgen(this, 1);
    }

    // This will overwrite the slot for element markers.
    highorderindex = 11;

    // The following line ensures that dead items in the pool of nodes cannot
    //   be allocated for the extra nodes associated with high order elements.
    //   This ensures that the primary nodes (at the corners of elements) will
    //   occur earlier in the output files, and have lower indices, than the
    //   extra nodes.
    points->deaditemstack = (void*)NULL;

    // Assign an entry for each tetrahedron to find its extra nodes. At the
    //   mean while, initialize all extra nodes be NULL.
    i = 0;
    tetrahedrons->traversalinit();
    tetloop.tet = tetrahedrontraverse();
    while (tetloop.tet != (tetrahedron*)NULL) {
        tetloop.tet[highorderindex] = (tetrahedron)&highordertable[i];
        for (j = 0; j < 6; j++) {
            highordertable[i + j] = (point)NULL;
        }
        i += 6;
        tetloop.tet = tetrahedrontraverse();
    }

    // To create a unique node on each edge. Loop over all tetrahedra, and
    //   look at the six edges of each tetrahedron.  If the extra node in
    //   the tetrahedron corresponding to this edge is NULL, create a node
    //   for this edge, at the same time, set the new node into the extra
    //   node lists of all other tetrahedra sharing this edge.
    tetrahedrons->traversalinit();
    tetloop.tet = tetrahedrontraverse();
    while (tetloop.tet != (tetrahedron*)NULL) {
        // Get the list of extra nodes.
        extralist = (point*)tetloop.tet[highorderindex];
        worktet.tet = tetloop.tet;
        for (i = 0; i < 6; i++) {
            if (extralist[i] == (point)NULL) {
                // Go to the ith-edge.
                worktet.ver = edge2ver[i];
                // Create a new point in the middle of this edge.
                torg = org(worktet);
                tdest = dest(worktet);
                makepoint(&newpoint, FREEVOLVERTEX);
                for (j = 0; j < 3 + numpointattrib; j++) {
                    newpoint[j] = 0.5 * (torg[j] + tdest[j]);
                }
                // Interpolate its metrics.
                for (j = 0; j < in->numberofpointmtrs; j++) {
                    newpoint[pointmtrindex + j] =
                        0.5 * (torg[pointmtrindex + j] + tdest[pointmtrindex + j]);
                }
                // Set this point into all extra node lists at this edge.
                spintet = worktet;
                while (1) {
                    if (!ishulltet(spintet)) {
                        adjextralist = (point*)spintet.tet[highorderindex];
                        adjextralist[ver2edge[spintet.ver]] = newpoint;
                    }
                    fnextself(spintet);
                    if (spintet.tet == worktet.tet) break;
                }
            } // if (!extralist[i])
        }     // i
        tetloop.tet = tetrahedrontraverse();
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// indexelements()    Index all tetrahedra.                                  //
//                                                                           //
// Many output functions require that the tetrahedra are indexed.  This      //
// routine is called when -E option is used.                                 //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::indexelements() {
    triface worktet;
    int eindex = b->zeroindex ? 0 : in->firstnumber; // firstindex;
    tetrahedrons->traversalinit();
    worktet.tet = tetrahedrontraverse();
    while (worktet.tet != NULL) {
        setelemindex(worktet.tet, eindex);
        eindex++;
        if (b->metric) { // -m option
            // Update the point-to-tet map, so that every point is pointing
            //   to a real tet, not a fictious one. Used by .p2t file.
            tetrahedron tptr = encode(worktet);
            for (int i = 0; i < 4; i++) {
                setpoint2tet((point)(worktet.tet[4 + i]), tptr);
            }
        }
        worktet.tet = tetrahedrontraverse();
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// numberedges()    Count the number of edges, save in "meshedges".          //
//                                                                           //
// This routine is called when '-p' or '-r', and '-E' options are used.  The //
// total number of edges depends on the genus of the input surface mesh.     //
//                                                                           //
// NOTE:  This routine must be called after outelements().  So all elements  //
// have been indexed.                                                        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::numberedges() {
    triface worktet, spintet;
    int ishulledge;
    int t1ver;
    int i;

    meshedges = meshhulledges = 0l;

    tetrahedrons->traversalinit();
    worktet.tet = tetrahedrontraverse();
    while (worktet.tet != NULL) {
        for (i = 0; i < 6; i++) {
            worktet.ver = edge2ver[i];
            ishulledge = 0;
            fnext(worktet, spintet);
            do {
                if (!ishulltet(spintet)) {
                    if (elemindex(spintet.tet) < elemindex(worktet.tet)) break;
                } else {
                    ishulledge = 1;
                }
                fnextself(spintet);
            } while (spintet.tet != worktet.tet);
            if (spintet.tet == worktet.tet) {
                meshedges++;
                if (ishulledge) meshhulledges++;
            }
        }
        infect(worktet);
        worktet.tet = tetrahedrontraverse();
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// outnodes()    Output the points to a .node file or a tetgenio structure.  //
//                                                                           //
// Note: each point has already been numbered on input (the first index is   //
// 'in->firstnumber').                                                       //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::outnodes(tetgenio* out) {
    FILE* outfile = NULL;
    char outnodefilename[FILENAMESIZE];
    face parentsh;
    point pointloop;
    int nextras, bmark, marker = 0, weightDT = 0;
    int coordindex, attribindex;
    int pointnumber, firstindex;
    int index, i;

    if (out == (tetgenio*)NULL) {
        strcpy(outnodefilename, b->outfilename);
        strcat(outnodefilename, ".node");
    }

    if (!b->quiet) {
        if (out == (tetgenio*)NULL) {
            printf("Writing %s.\n", outnodefilename);
        } else {
            printf("Writing nodes.\n");
        }
    }

    nextras = numpointattrib;
    if (b->weighted) {                            // -w
        if (b->weighted_param == 0) weightDT = 1; // Weighted DT.
    }

    bmark = !b->nobound && in->pointmarkerlist;

    if (out == (tetgenio*)NULL) {
        outfile = fopen(outnodefilename, "w");
        if (outfile == (FILE*)NULL) {
            printf("File I/O Error:  Cannot create file %s.\n", outnodefilename);
            terminatetetgen(this, 1);
        }
        // Number of points, number of dimensions, number of point attributes,
        //   and number of boundary markers (zero or one).
        fprintf(outfile, "%ld  %d  %d  %d\n", points->items, 3, nextras, bmark);
    } else {
        // Allocate space for 'pointlist';
        out->pointlist = new REAL[points->items * 3];
        if (out->pointlist == (REAL*)NULL) {
            printf("Error:  Out of memory.\n");
            terminatetetgen(this, 1);
        }
        // Allocate space for 'pointattributelist' if necessary;
        if (nextras > 0) {
            out->pointattributelist = new REAL[points->items * nextras];
            if (out->pointattributelist == (REAL*)NULL) {
                printf("Error:  Out of memory.\n");
                terminatetetgen(this, 1);
            }
        }
        // Allocate space for 'pointmarkerlist' if necessary;
        if (bmark) {
            out->pointmarkerlist = new int[points->items];
            if (out->pointmarkerlist == (int*)NULL) {
                printf("Error:  Out of memory.\n");
                terminatetetgen(this, 1);
            }
        }
        if (b->psc) {
            out->pointparamlist = new tetgenio::pointparam[points->items];
            if (out->pointparamlist == NULL) {
                printf("Error:  Out of memory.\n");
                terminatetetgen(this, 1);
            }
        }
        out->numberofpoints = points->items;
        out->numberofpointattributes = nextras;
        coordindex = 0;
        attribindex = 0;
    }

    // Determine the first index (0 or 1).
    firstindex = b->zeroindex ? 0 : in->firstnumber;

    points->traversalinit();
    pointloop = pointtraverse();
    pointnumber = firstindex; // in->firstnumber;
    index = 0;
    while (pointloop != (point)NULL) {
        if (bmark) {
            // Default the vertex has a zero marker.
            marker = 0;
            // Is it an input vertex?
            if (index < in->numberofpoints) {
                // Input point's marker is directly copied to output.
                marker = in->pointmarkerlist[index];
            } else {
                if ((pointtype(pointloop) == FREESEGVERTEX) ||
                    (pointtype(pointloop) == FREEFACETVERTEX)) {
                    sdecode(point2sh(pointloop), parentsh);
                    if (parentsh.sh != NULL) {
                        marker = shellmark(parentsh);
                    }
                } // if (pointtype(...))
            }
        }
        if (out == (tetgenio*)NULL) {
            // Point number, x, y and z coordinates.
            fprintf(outfile, "%4d    %.17g  %.17g  %.17g", pointnumber, pointloop[0], pointloop[1],
                    pointloop[2]);
            for (i = 0; i < nextras; i++) {
                // Write an attribute.
                if ((i == 0) && weightDT) {
                    fprintf(outfile, "  %.17g",
                            pointloop[0] * pointloop[0] + pointloop[1] * pointloop[1] +
                                pointloop[2] * pointloop[2] - pointloop[3 + i]);
                } else {
                    fprintf(outfile, "  %.17g", pointloop[3 + i]);
                }
            }
            if (bmark) {
                // Write the boundary marker.
                fprintf(outfile, "    %d", marker);
            }
            if (b->psc) {
                fprintf(outfile, "  %.8g  %.8g  %d", pointgeomuv(pointloop, 0),
                        pointgeomuv(pointloop, 1), pointgeomtag(pointloop));
                if (pointtype(pointloop) == RIDGEVERTEX) {
                    fprintf(outfile, "  0");
                } else if (pointtype(pointloop) == ACUTEVERTEX) {
                    fprintf(outfile, "  0");
                } else if (pointtype(pointloop) == FREESEGVERTEX) {
                    fprintf(outfile, "  1");
                } else if (pointtype(pointloop) == FREEFACETVERTEX) {
                    fprintf(outfile, "  2");
                } else if (pointtype(pointloop) == FREEVOLVERTEX) {
                    fprintf(outfile, "  3");
                } else {
                    fprintf(outfile, "  -1"); // Unknown type.
                }
            }
            fprintf(outfile, "\n");
        } else {
            // X, y, and z coordinates.
            out->pointlist[coordindex++] = pointloop[0];
            out->pointlist[coordindex++] = pointloop[1];
            out->pointlist[coordindex++] = pointloop[2];
            // Point attributes.
            for (i = 0; i < nextras; i++) {
                // Output an attribute.
                if ((i == 0) && weightDT) {
                    out->pointattributelist[attribindex++] =
                        pointloop[0] * pointloop[0] + pointloop[1] * pointloop[1] +
                        pointloop[2] * pointloop[2] - pointloop[3 + i];
                } else {
                    out->pointattributelist[attribindex++] = pointloop[3 + i];
                }
            }
            if (bmark) {
                // Output the boundary marker.
                out->pointmarkerlist[index] = marker;
            }
            if (b->psc) {
                out->pointparamlist[index].uv[0] = pointgeomuv(pointloop, 0);
                out->pointparamlist[index].uv[1] = pointgeomuv(pointloop, 1);
                out->pointparamlist[index].tag = pointgeomtag(pointloop);
                if (pointtype(pointloop) == RIDGEVERTEX) {
                    out->pointparamlist[index].type = 0;
                } else if (pointtype(pointloop) == ACUTEVERTEX) {
                    out->pointparamlist[index].type = 0;
                } else if (pointtype(pointloop) == FREESEGVERTEX) {
                    out->pointparamlist[index].type = 1;
                } else if (pointtype(pointloop) == FREEFACETVERTEX) {
                    out->pointparamlist[index].type = 2;
                } else if (pointtype(pointloop) == FREEVOLVERTEX) {
                    out->pointparamlist[index].type = 3;
                } else {
                    out->pointparamlist[index].type = -1; // Unknown type.
                }
            }
        }
        pointloop = pointtraverse();
        pointnumber++;
        index++;
    }

    if (out == (tetgenio*)NULL) {
        fprintf(outfile, "# Generated by %s\n", b->commandline);
        fclose(outfile);
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// outmetrics()    Output the metric to a file (*.mtr) or a tetgenio obj.    //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::outmetrics(tetgenio* out) {
    FILE* outfile = NULL;
    char outmtrfilename[FILENAMESIZE];
    point ptloop;
    int mtrindex = 0;
    int i;
    int msize = (sizeoftensor - useinsertradius);
    if (msize == 0) {
        return;
    }

    if (out == (tetgenio*)NULL) {
        strcpy(outmtrfilename, b->outfilename);
        strcat(outmtrfilename, ".mtr");
    }

    if (!b->quiet) {
        if (out == (tetgenio*)NULL) {
            printf("Writing %s.\n", outmtrfilename);
        } else {
            printf("Writing metrics.\n");
        }
    }

    if (out == (tetgenio*)NULL) {
        outfile = fopen(outmtrfilename, "w");
        if (outfile == (FILE*)NULL) {
            printf("File I/O Error:  Cannot create file %s.\n", outmtrfilename);
            terminatetetgen(this, 3);
        }
        // Number of points, number of point metrices,
        fprintf(outfile, "%ld  %d\n", points->items, msize);
    } else {
        // Allocate space for 'pointmtrlist'.
        out->numberofpointmtrs = msize;
        out->pointmtrlist = new REAL[points->items * msize];
        if (out->pointmtrlist == (REAL*)NULL) {
            terminatetetgen(this, 1);
        }
    }

    points->traversalinit();
    ptloop = pointtraverse();
    while (ptloop != (point)NULL) {
        if (out == (tetgenio*)NULL) {
            for (i = 0; i < msize; i++) {
                fprintf(outfile, " %-16.8e", ptloop[pointmtrindex + i]);
            }
            fprintf(outfile, "\n");
        } else {
            for (i = 0; i < msize; i++) {
                out->pointmtrlist[mtrindex++] = ptloop[pointmtrindex + i];
            }
        }
        ptloop = pointtraverse();
    }

    // Output the point-to-tet map.
    if (out == (tetgenio*)NULL) {
        strcpy(outmtrfilename, b->outfilename);
        strcat(outmtrfilename, ".p2t");
    }

    if (!b->quiet) {
        if (out == (tetgenio*)NULL) {
            printf("Writing %s.\n", outmtrfilename);
        } else {
            printf("Writing point-to-tet map.\n");
        }
    }

    if (out == (tetgenio*)NULL) {
        outfile = fopen(outmtrfilename, "w");
        if (outfile == (FILE*)NULL) {
            printf("File I/O Error:  Cannot create file %s.\n", outmtrfilename);
            terminatetetgen(this, 3);
        }
        // Number of points,
        // fprintf(outfile, "%ld\n", points->items);
    } else {
        // Allocate space for 'point2tetlist'.
        out->point2tetlist = new int[points->items];
        if (out->point2tetlist == (int*)NULL) {
            terminatetetgen(this, 1);
        }
    }

    // The list of tetrahedra must be indexed.
    if (bgm != NULL) {
        bgm->indexelements();
    }
    // Determine the first index (0 or 1).
    int firstindex = b->zeroindex ? 0 : in->firstnumber;
    int pointindex = firstindex;
    i = 0;

    triface parenttet;
    points->traversalinit();
    ptloop = pointtraverse();
    while (ptloop != (point)NULL) {
        if (bgm != NULL) {
            bgm->decode(point2bgmtet(ptloop), parenttet);
        } else {
            decode(point2tet(ptloop), parenttet);
        }
        if (out == (tetgenio*)NULL) {
            fprintf(outfile, "%d  %d\n", pointindex, elemindex(parenttet.tet));
        } else {
            out->point2tetlist[i] = elemindex(parenttet.tet);
        }
        pointindex++;
        i++;
        ptloop = pointtraverse();
    }

    if (out == (tetgenio*)NULL) {
        fprintf(outfile, "# Generated by %s\n", b->commandline);
        fclose(outfile);
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// outelements()    Output the tetrahedra to an .ele file or a tetgenio      //
//                  structure.                                               //
//                                                                           //
// This routine also indexes all tetrahedra (exclusing hull tets) (from in-> //
// firstnumber). The total number of mesh edges is counted in 'meshedges'.   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::outelements(tetgenio* out) {
    FILE* outfile = NULL;
    char outelefilename[FILENAMESIZE];
    tetrahedron* tptr;
    point p1, p2, p3, p4;
    point* extralist;
    REAL* talist = NULL;
    int* tlist = NULL;
    long ntets;
    int firstindex, shift;
    int pointindex, attribindex;
    int highorderindex = 11;
    int elementnumber;
    int eextras;
    int i;

    if (out == (tetgenio*)NULL) {
        strcpy(outelefilename, b->outfilename);
        strcat(outelefilename, ".ele");
    }

    if (!b->quiet) {
        if (out == (tetgenio*)NULL) {
            printf("Writing %s.\n", outelefilename);
        } else {
            printf("Writing elements.\n");
        }
    }

    // The number of tets excluding hull tets.
    ntets = tetrahedrons->items - hullsize;

    eextras = numelemattrib;
    if (out == (tetgenio*)NULL) {
        outfile = fopen(outelefilename, "w");
        if (outfile == (FILE*)NULL) {
            printf("File I/O Error:  Cannot create file %s.\n", outelefilename);
            terminatetetgen(this, 1);
        }
        // Number of tetras, points per tetra, attributes per tetra.
        fprintf(outfile, "%ld  %d  %d\n", ntets, b->order == 1 ? 4 : 10, eextras);
    } else {
        // Allocate memory for output tetrahedra.
        out->tetrahedronlist = new int[ntets * (b->order == 1 ? 4 : 10)];
        if (out->tetrahedronlist == (int*)NULL) {
            printf("Error:  Out of memory.\n");
            terminatetetgen(this, 1);
        }
        // Allocate memory for output tetrahedron attributes if necessary.
        if (eextras > 0) {
            out->tetrahedronattributelist = new REAL[ntets * eextras];
            if (out->tetrahedronattributelist == (REAL*)NULL) {
                printf("Error:  Out of memory.\n");
                terminatetetgen(this, 1);
            }
        }
        out->numberoftetrahedra = ntets;
        out->numberofcorners = b->order == 1 ? 4 : 10;
        out->numberoftetrahedronattributes = eextras;
        tlist = out->tetrahedronlist;
        talist = out->tetrahedronattributelist;
        pointindex = 0;
        attribindex = 0;
    }

    // Determine the first index (0 or 1).
    firstindex = b->zeroindex ? 0 : in->firstnumber;
    shift = 0; // Default no shift.
    if ((in->firstnumber == 1) && (firstindex == 0)) {
        shift = 1; // Shift the output indices by 1.
    }

    tetrahedrons->traversalinit();
    tptr = tetrahedrontraverse();
    elementnumber = firstindex; // in->firstnumber;
    while (tptr != (tetrahedron*)NULL) {
        if (!b->reversetetori) {
            p1 = (point)tptr[4];
            p2 = (point)tptr[5];
        } else {
            p1 = (point)tptr[5];
            p2 = (point)tptr[4];
        }
        p3 = (point)tptr[6];
        p4 = (point)tptr[7];
        if (out == (tetgenio*)NULL) {
            // Tetrahedron number, indices for four points.
            fprintf(outfile, "%5d   %5d %5d %5d %5d", elementnumber, pointmark(p1) - shift,
                    pointmark(p2) - shift, pointmark(p3) - shift, pointmark(p4) - shift);
            if (b->order == 2) {
                extralist = (point*)tptr[highorderindex];
                // indices for six extra points.
                fprintf(outfile, "  %5d %5d %5d %5d %5d %5d", pointmark(extralist[0]) - shift,
                        pointmark(extralist[1]) - shift, pointmark(extralist[2]) - shift,
                        pointmark(extralist[3]) - shift, pointmark(extralist[4]) - shift,
                        pointmark(extralist[5]) - shift);
            }
            for (i = 0; i < eextras; i++) {
                fprintf(outfile, "    %.17g", elemattribute(tptr, i));
            }
            fprintf(outfile, "\n");
        } else {
            tlist[pointindex++] = pointmark(p1) - shift;
            tlist[pointindex++] = pointmark(p2) - shift;
            tlist[pointindex++] = pointmark(p3) - shift;
            tlist[pointindex++] = pointmark(p4) - shift;
            if (b->order == 2) {
                extralist = (point*)tptr[highorderindex];
                tlist[pointindex++] = pointmark(extralist[0]) - shift;
                tlist[pointindex++] = pointmark(extralist[1]) - shift;
                tlist[pointindex++] = pointmark(extralist[2]) - shift;
                tlist[pointindex++] = pointmark(extralist[3]) - shift;
                tlist[pointindex++] = pointmark(extralist[4]) - shift;
                tlist[pointindex++] = pointmark(extralist[5]) - shift;
            }
            for (i = 0; i < eextras; i++) {
                talist[attribindex++] = elemattribute(tptr, i);
            }
        }
        // Remember the index of this element (for counting edges).
        setelemindex(tptr, elementnumber);
        if (b->metric) { // -m option
            // Update the point-to-tet map, so that every point is pointing
            //   to a real tet, not a fictious one. Used by .p2t file.
            for (int i = 0; i < 4; i++) {
                setpoint2tet((point)(tptr[4 + i]), (tetrahedron)tptr);
            }
        }
        tptr = tetrahedrontraverse();
        elementnumber++;
    }

    if (out == (tetgenio*)NULL) {
        fprintf(outfile, "# Generated by %s\n", b->commandline);
        fclose(outfile);
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// outfaces()    Output all faces to a .face file or a tetgenio object.      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::outfaces(tetgenio* out) {
    FILE* outfile = NULL;
    char facefilename[FILENAMESIZE];
    triface tface, tsymface;
    face checkmark;
    point torg, tdest, tapex;
    long ntets, faces;
    int *elist = NULL, *emlist = NULL;
    int neigh1 = 0, neigh2 = 0;
    int marker = 0;
    int firstindex, shift;
    int facenumber;
    int index = 0;

    // For -o2 option.
    triface workface;
    point *extralist, pp[3] = {0, 0, 0};
    int highorderindex = 11;
    int o2index = 0, i;

    // For -nn option.
    int* tet2facelist = NULL;
    int tidx;

    if (out == (tetgenio*)NULL) {
        strcpy(facefilename, b->outfilename);
        strcat(facefilename, ".face");
    }

    if (!b->quiet) {
        if (out == (tetgenio*)NULL) {
            printf("Writing %s.\n", facefilename);
        } else {
            printf("Writing faces.\n");
        }
    }

    ntets = tetrahedrons->items - hullsize;
    faces = (ntets * 4l + hullsize) / 2l;

    if (out == (tetgenio*)NULL) {
        outfile = fopen(facefilename, "w");
        if (outfile == (FILE*)NULL) {
            printf("File I/O Error:  Cannot create file %s.\n", facefilename);
            terminatetetgen(this, 1);
        }
        fprintf(outfile, "%ld  %d\n", faces, !b->nobound);
    } else {
        // Allocate memory for 'trifacelist'.
        out->trifacelist = new int[faces * 3];
        if (out->trifacelist == (int*)NULL) {
            printf("Error:  Out of memory.\n");
            terminatetetgen(this, 1);
        }
        if (b->order == 2) {
            out->o2facelist = new int[faces * 3];
        }
        // Allocate memory for 'trifacemarkerlist' if necessary.
        if (!b->nobound) {
            out->trifacemarkerlist = new int[faces];
            if (out->trifacemarkerlist == (int*)NULL) {
                printf("Error:  Out of memory.\n");
                terminatetetgen(this, 1);
            }
        }
        if (b->neighout > 1) {
            // '-nn' switch.
            out->face2tetlist = new int[faces * 2];
            if (out->face2tetlist == (int*)NULL) {
                printf("Error:  Out of memory.\n");
                terminatetetgen(this, 1);
            }
        }
        out->numberoftrifaces = faces;
        elist = out->trifacelist;
        emlist = out->trifacemarkerlist;
    }

    if (b->neighout > 1) { // -nn option
        // Output the tetrahedron-to-face map.
        tet2facelist = new int[ntets * 4];
    }

    // Determine the first index (0 or 1).
    firstindex = b->zeroindex ? 0 : in->firstnumber;
    shift = 0; // Default no shiftment.
    if ((in->firstnumber == 1) && (firstindex == 0)) {
        shift = 1; // Shift the output indices by 1.
    }

    tetrahedrons->traversalinit();
    tface.tet = tetrahedrontraverse();
    facenumber = firstindex; // in->firstnumber;
    // To loop over the set of faces, loop over all tetrahedra, and look at
    //   the four faces of each one. If its adjacent tet is a hull tet,
    //   operate on the face, otherwise, operate on the face only if the
    //   current tet has a smaller index than its neighbor.
    while (tface.tet != (tetrahedron*)NULL) {
        for (tface.ver = 0; tface.ver < 4; tface.ver++) {
            fsym(tface, tsymface);
            if (ishulltet(tsymface) || (elemindex(tface.tet) < elemindex(tsymface.tet))) {
                torg = org(tface);
                tdest = dest(tface);
                tapex = apex(tface);
                if (b->order == 2) { // -o2
                    // Get the three extra vertices on edges.
                    extralist = (point*)(tface.tet[highorderindex]);
                    // The extra vertices are on edges opposite the corners.
                    enext(tface, workface);
                    for (i = 0; i < 3; i++) {
                        pp[i] = extralist[ver2edge[workface.ver]];
                        enextself(workface);
                    }
                }
                if (!b->nobound) {
                    // Get the boundary marker of this face.
                    if (b->plc || b->refine) {
                        // Shell face is used.
                        tspivot(tface, checkmark);
                        if (checkmark.sh == NULL) {
                            marker = 0; // It is an inner face. It's marker is 0.
                        } else {
                            marker = shellmark(checkmark);
                        }
                    } else {
                        // Shell face is not used, only distinguish outer and inner face.
                        marker = (int)ishulltet(tsymface);
                    }
                }
                if (b->neighout > 1) {
                    // '-nn' switch. Output adjacent tets indices.
                    if (!ishulltet(tface)) {
                        neigh1 = elemindex(tface.tet);
                    } else {
                        neigh1 = -1;
                    }
                    if (!ishulltet(tsymface)) {
                        neigh2 = elemindex(tsymface.tet);
                    } else {
                        neigh2 = -1;
                    }
                    // Fill the tetrahedron-to-face map.
                    tidx = elemindex(tface.tet) - firstindex;
                    tet2facelist[tidx * 4 + tface.ver] = facenumber;
                    if (!ishulltet(tsymface)) {
                        tidx = elemindex(tsymface.tet) - firstindex;
                        tet2facelist[tidx * 4 + (tsymface.ver & 3)] = facenumber;
                    }
                }
                if (out == (tetgenio*)NULL) {
                    // Face number, indices of three vertices.
                    fprintf(outfile, "%5d   %4d  %4d  %4d", facenumber, pointmark(torg) - shift,
                            pointmark(tdest) - shift, pointmark(tapex) - shift);
                    if (b->order == 2) { // -o2
                        fprintf(outfile, "  %4d  %4d  %4d", pointmark(pp[0]) - shift,
                                pointmark(pp[1]) - shift, pointmark(pp[2]) - shift);
                    }
                    if (!b->nobound) {
                        // Output a boundary marker.
                        fprintf(outfile, "  %d", marker);
                    }
                    if (b->neighout > 1) {
                        fprintf(outfile, "    %5d  %5d", neigh1, neigh2);
                    }
                    fprintf(outfile, "\n");
                } else {
                    // Output indices of three vertices.
                    elist[index++] = pointmark(torg) - shift;
                    elist[index++] = pointmark(tdest) - shift;
                    elist[index++] = pointmark(tapex) - shift;
                    if (b->order == 2) { // -o2
                        out->o2facelist[o2index++] = pointmark(pp[0]) - shift;
                        out->o2facelist[o2index++] = pointmark(pp[1]) - shift;
                        out->o2facelist[o2index++] = pointmark(pp[2]) - shift;
                    }
                    if (!b->nobound) {
                        emlist[facenumber - in->firstnumber] = marker;
                    }
                    if (b->neighout > 1) {
                        out->face2tetlist[(facenumber - in->firstnumber) * 2] = neigh1;
                        out->face2tetlist[(facenumber - in->firstnumber) * 2 + 1] = neigh2;
                    }
                }
                facenumber++;
            }
        }
        tface.tet = tetrahedrontraverse();
    }

    if (out == (tetgenio*)NULL) {
        fprintf(outfile, "# Generated by %s\n", b->commandline);
        fclose(outfile);
    }

    if (b->neighout > 1) { // -nn option
                           // Output the tetrahedron-to-face map.
        if (out == (tetgenio*)NULL) {
            strcpy(facefilename, b->outfilename);
            strcat(facefilename, ".t2f");
        }
        if (!b->quiet) {
            if (out == (tetgenio*)NULL) {
                printf("Writing %s.\n", facefilename);
            } else {
                printf("Writing tetrahedron-to-face map.\n");
            }
        }
        if (out == (tetgenio*)NULL) {
            outfile = fopen(facefilename, "w");
            for (tidx = 0; tidx < ntets; tidx++) {
                index = tidx * 4;
                fprintf(outfile, "%4d  %d %d %d %d\n", tidx + in->firstnumber, tet2facelist[index],
                        tet2facelist[index + 1], tet2facelist[index + 2], tet2facelist[index + 3]);
            }
            fclose(outfile);
            delete[] tet2facelist;
        } else {
            // Simply copy the address of the list to the output.
            out->tet2facelist = tet2facelist;
        }
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// outhullfaces()    Output hull faces to a .face file or a tetgenio object. //
//                                                                           //
// The normal of each face is pointing to the outside of the domain.         //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::outhullfaces(tetgenio* out) {
    FILE* outfile = NULL;
    char facefilename[FILENAMESIZE];
    triface hulltet;
    point torg, tdest, tapex;
    int* elist = NULL;
    int firstindex, shift;
    int facenumber;
    int index;

    if (out == (tetgenio*)NULL) {
        strcpy(facefilename, b->outfilename);
        strcat(facefilename, ".face");
    }

    if (!b->quiet) {
        if (out == (tetgenio*)NULL) {
            printf("Writing %s.\n", facefilename);
        } else {
            printf("Writing faces.\n");
        }
    }

    if (out == (tetgenio*)NULL) {
        outfile = fopen(facefilename, "w");
        if (outfile == (FILE*)NULL) {
            printf("File I/O Error:  Cannot create file %s.\n", facefilename);
            terminatetetgen(this, 1);
        }
        fprintf(outfile, "%ld  0\n", hullsize);
    } else {
        // Allocate memory for 'trifacelist'.
        out->trifacelist = new int[hullsize * 3];
        if (out->trifacelist == (int*)NULL) {
            printf("Error:  Out of memory.\n");
            terminatetetgen(this, 1);
        }
        out->numberoftrifaces = hullsize;
        elist = out->trifacelist;
        index = 0;
    }

    // Determine the first index (0 or 1).
    firstindex = b->zeroindex ? 0 : in->firstnumber;
    shift = 0; // Default no shiftment.
    if ((in->firstnumber == 1) && (firstindex == 0)) {
        shift = 1; // Shift the output indices by 1.
    }

    tetrahedrons->traversalinit();
    hulltet.tet = alltetrahedrontraverse();
    facenumber = firstindex;
    while (hulltet.tet != (tetrahedron*)NULL) {
        if (ishulltet(hulltet)) {
            torg = (point)hulltet.tet[4];
            tdest = (point)hulltet.tet[5];
            tapex = (point)hulltet.tet[6];
            if (out == (tetgenio*)NULL) {
                // Face number, indices of three vertices.
                fprintf(outfile, "%5d   %4d  %4d  %4d", facenumber, pointmark(torg) - shift,
                        pointmark(tdest) - shift, pointmark(tapex) - shift);
                fprintf(outfile, "\n");
            } else {
                // Output indices of three vertices.
                elist[index++] = pointmark(torg) - shift;
                elist[index++] = pointmark(tdest) - shift;
                elist[index++] = pointmark(tapex) - shift;
            }
            facenumber++;
        }
        hulltet.tet = alltetrahedrontraverse();
    }

    if (out == (tetgenio*)NULL) {
        fprintf(outfile, "# Generated by %s\n", b->commandline);
        fclose(outfile);
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// outsubfaces()    Output subfaces (i.e. boundary faces) to a .face file or //
//                  a tetgenio structure.                                    //
//                                                                           //
// The boundary faces are found in 'subfaces'. For listing triangle vertices //
// in the same sense for all triangles in the mesh, the direction determined //
// by right-hand rule is pointer to the inside of the volume.                //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::outsubfaces(tetgenio* out) {
    FILE* outfile = NULL;
    char facefilename[FILENAMESIZE];
    int* elist = NULL;
    int* emlist = NULL;
    int index = 0, index1 = 0, index2 = 0;
    triface abuttingtet;
    face faceloop;
    point torg, tdest, tapex;
    int marker = 0;
    int firstindex, shift;
    int neigh1 = 0, neigh2 = 0;
    int facenumber;

    // For -o2 option.
    triface workface;
    point *extralist, pp[3] = {0, 0, 0};
    int highorderindex = 11;
    int o2index = 0, i;

    int t1ver; // used by fsymself()

    if (out == (tetgenio*)NULL) {
        strcpy(facefilename, b->outfilename);
        strcat(facefilename, ".face");
    }

    if (!b->quiet) {
        if (out == (tetgenio*)NULL) {
            printf("Writing %s.\n", facefilename);
        } else {
            printf("Writing faces.\n");
        }
    }

    if (out == (tetgenio*)NULL) {
        outfile = fopen(facefilename, "w");
        if (outfile == (FILE*)NULL) {
            printf("File I/O Error:  Cannot create file %s.\n", facefilename);
            terminatetetgen(this, 3);
        }
        // Number of subfaces.
        fprintf(outfile, "%ld  %d\n", subfaces->items, !b->nobound);
    } else {
        // Allocate memory for 'trifacelist'.
        out->trifacelist = new int[subfaces->items * 3];
        if (out->trifacelist == (int*)NULL) {
            terminatetetgen(this, 1);
        }
        if (b->order == 2) {
            out->o2facelist = new int[subfaces->items * 3];
        }
        if (!b->nobound) {
            // Allocate memory for 'trifacemarkerlist'.
            out->trifacemarkerlist = new int[subfaces->items];
            if (out->trifacemarkerlist == (int*)NULL) {
                terminatetetgen(this, 1);
            }
        }
        if (b->neighout > 1) {
            // '-nn' switch.
            out->face2tetlist = new int[subfaces->items * 2];
            if (out->face2tetlist == (int*)NULL) {
                terminatetetgen(this, 1);
            }
        }
        out->numberoftrifaces = subfaces->items;
        elist = out->trifacelist;
        emlist = out->trifacemarkerlist;
    }

    // Determine the first index (0 or 1).
    firstindex = b->zeroindex ? 0 : in->firstnumber;
    shift = 0; // Default no shiftment.
    if ((in->firstnumber == 1) && (firstindex == 0)) {
        shift = 1; // Shift the output indices by 1.
    }

    subfaces->traversalinit();
    faceloop.sh = shellfacetraverse(subfaces);
    facenumber = firstindex; // in->firstnumber;
    while (faceloop.sh != (shellface*)NULL) {
        stpivot(faceloop, abuttingtet);
        // If there is a tetrahedron containing this subface, orient it so
        //   that the normal of this face points to inside of the volume by
        //   right-hand rule.
        if (abuttingtet.tet != NULL) {
            if (ishulltet(abuttingtet)) {
                fsymself(abuttingtet);
            }
        }
        if (abuttingtet.tet != NULL) {
            torg = org(abuttingtet);
            tdest = dest(abuttingtet);
            tapex = apex(abuttingtet);
            if (b->order == 2) { // -o2
                // Get the three extra vertices on edges.
                extralist = (point*)(abuttingtet.tet[highorderindex]);
                workface = abuttingtet;
                for (i = 0; i < 3; i++) {
                    pp[i] = extralist[ver2edge[workface.ver]];
                    enextself(workface);
                }
            }
        } else {
            // This may happen when only a surface mesh be generated.
            torg = sorg(faceloop);
            tdest = sdest(faceloop);
            tapex = sapex(faceloop);
            if (b->order == 2) { // -o2
                // There is no extra node list available.
                pp[0] = torg;
                pp[1] = tdest;
                pp[2] = tapex;
            }
        }
        if (!b->nobound) {
            marker = shellmark(faceloop);
        }
        if (b->neighout > 1) {
            // '-nn' switch. Output adjacent tets indices.
            neigh1 = -1;
            neigh2 = -1;
            stpivot(faceloop, abuttingtet);
            if (abuttingtet.tet != NULL) {
                if (!ishulltet(abuttingtet)) {
                    neigh1 = elemindex(abuttingtet.tet);
                }
                fsymself(abuttingtet);
                if (!ishulltet(abuttingtet)) {
                    neigh2 = elemindex(abuttingtet.tet);
                }
            }
        }
        if (out == (tetgenio*)NULL) {
            fprintf(outfile, "%5d   %4d  %4d  %4d", facenumber, pointmark(torg) - shift,
                    pointmark(tdest) - shift, pointmark(tapex) - shift);
            if (b->order == 2) { // -o2
                fprintf(outfile, "  %4d  %4d  %4d", pointmark(pp[0]) - shift,
                        pointmark(pp[1]) - shift, pointmark(pp[2]) - shift);
            }
            if (!b->nobound) {
                fprintf(outfile, "    %d", marker);
            }
            if (b->neighout > 1) {
                fprintf(outfile, "    %5d  %5d", neigh1, neigh2);
            }
            fprintf(outfile, "\n");
        } else {
            // Output three vertices of this face;
            elist[index++] = pointmark(torg) - shift;
            elist[index++] = pointmark(tdest) - shift;
            elist[index++] = pointmark(tapex) - shift;
            if (b->order == 2) { // -o2
                out->o2facelist[o2index++] = pointmark(pp[0]) - shift;
                out->o2facelist[o2index++] = pointmark(pp[1]) - shift;
                out->o2facelist[o2index++] = pointmark(pp[2]) - shift;
            }
            if (!b->nobound) {
                emlist[index1++] = marker;
            }
            if (b->neighout > 1) {
                out->face2tetlist[index2++] = neigh1;
                out->face2tetlist[index2++] = neigh2;
            }
        }
        facenumber++;
        faceloop.sh = shellfacetraverse(subfaces);
    }

    if (out == (tetgenio*)NULL) {
        fprintf(outfile, "# Generated by %s\n", b->commandline);
        fclose(outfile);
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// outedges()    Output all edges to a .edge file or a tetgenio object.      //
//                                                                           //
// Note: This routine must be called after outelements(),  so that the total //
// number of edges 'meshedges' has been counted.                             //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::outedges(tetgenio* out) {
    FILE* outfile = NULL;
    char edgefilename[FILENAMESIZE];
    triface tetloop, worktet, spintet;
    face checkseg;
    point torg, tdest;
    int ishulledge;
    int firstindex, shift;
    int edgenumber, marker;
    int index = 0, index1 = 0, index2 = 0;
    int t1ver;
    int i;

    // For -o2 option.
    point *extralist, pp = NULL;
    int highorderindex = 11;
    int o2index = 0;

    // For -nn option.
    int* tet2edgelist = NULL;
    int tidx;

    if (out == (tetgenio*)NULL) {
        strcpy(edgefilename, b->outfilename);
        strcat(edgefilename, ".edge");
    }

    if (!b->quiet) {
        if (out == (tetgenio*)NULL) {
            printf("Writing %s.\n", edgefilename);
        } else {
            printf("Writing edges.\n");
        }
    }

    if (meshedges == 0l) {
        if (nonconvex) {
            numberedges(); // Count the edges.
        } else {
            // Use Euler's characteristic to get the numbe of edges.
            // It states V - E + F - C = 1, hence E = V + F - C - 1.
            long tsize = tetrahedrons->items - hullsize;
            long fsize = (tsize * 4l + hullsize) / 2l;
            long vsize = points->items - dupverts - unuverts;
            if (b->weighted) vsize -= nonregularcount;
            meshedges = vsize + fsize - tsize - 1;
        }
    }
    meshhulledges = 0l; // It will be counted.

    if (out == (tetgenio*)NULL) {
        outfile = fopen(edgefilename, "w");
        if (outfile == (FILE*)NULL) {
            printf("File I/O Error:  Cannot create file %s.\n", edgefilename);
            terminatetetgen(this, 1);
        }
        // Write the number of edges, boundary markers (0 or 1).
        fprintf(outfile, "%ld  %d\n", meshedges, !b->nobound);
    } else {
        // Allocate memory for 'edgelist'.
        out->numberofedges = meshedges;
        out->edgelist = new int[meshedges * 2];
        if (out->edgelist == (int*)NULL) {
            printf("Error:  Out of memory.\n");
            terminatetetgen(this, 1);
        }
        if (b->order == 2) { // -o2 switch
            out->o2edgelist = new int[meshedges];
        }
        if (!b->nobound) {
            out->edgemarkerlist = new int[meshedges];
        }
        if (b->neighout > 1) { // '-nn' switch.
            out->edge2tetlist = new int[meshedges];
        }
    }

    if (b->neighout > 1) { // -nn option
                           // Output the tetrahedron-to-edge map.
        long tsize = tetrahedrons->items - hullsize;
        tet2edgelist = new int[tsize * 6];
    }

    // Determine the first index (0 or 1).
    firstindex = b->zeroindex ? 0 : in->firstnumber;
    shift = 0; // Default no shiftment.
    if ((in->firstnumber == 1) && (firstindex == 0)) {
        shift = 1; // Shift (reduce) the output indices by 1.
    }

    tetrahedrons->traversalinit();
    tetloop.tet = tetrahedrontraverse();
    edgenumber = firstindex; // in->firstnumber;
    while (tetloop.tet != (tetrahedron*)NULL) {
        // Count the number of Voronoi faces.
        worktet.tet = tetloop.tet;
        for (i = 0; i < 6; i++) {
            worktet.ver = edge2ver[i];
            ishulledge = 0;
            fnext(worktet, spintet);
            do {
                if (!ishulltet(spintet)) {
                    if (elemindex(spintet.tet) < elemindex(worktet.tet)) break;
                } else {
                    ishulledge = 1;
                }
                fnextself(spintet);
            } while (spintet.tet != worktet.tet);
            if (spintet.tet == worktet.tet) {
                // Found a new edge.
                if (ishulledge) meshhulledges++;
                torg = org(worktet);
                tdest = dest(worktet);
                if (b->order == 2) { // -o2
                    // Get the extra vertex on this edge.
                    extralist = (point*)worktet.tet[highorderindex];
                    pp = extralist[ver2edge[worktet.ver]];
                }
                if (out == (tetgenio*)NULL) {
                    fprintf(outfile, "%5d   %4d  %4d", edgenumber, pointmark(torg) - shift,
                            pointmark(tdest) - shift);
                    if (b->order == 2) { // -o2
                        fprintf(outfile, "  %4d", pointmark(pp) - shift);
                    }
                } else {
                    // Output three vertices of this face;
                    out->edgelist[index++] = pointmark(torg) - shift;
                    out->edgelist[index++] = pointmark(tdest) - shift;
                    if (b->order == 2) { // -o2
                        out->o2edgelist[o2index++] = pointmark(pp) - shift;
                    }
                }
                if (!b->nobound) {
                    if (b->plc || b->refine) {
                        // Check if the edge is a segment.
                        tsspivot1(worktet, checkseg);
                        if (checkseg.sh != NULL) {
                            marker = shellmark(checkseg);
                        } else {
                            marker = 0; // It's not a segment.
                        }
                    } else {
                        // Mark it if it is a hull edge.
                        marker = ishulledge ? 1 : 0;
                    }
                    if (out == (tetgenio*)NULL) {
                        fprintf(outfile, "  %d", marker);
                    } else {
                        out->edgemarkerlist[index1++] = marker;
                    }
                }
                if (b->neighout > 1) { // '-nn' switch.
                    if (out == (tetgenio*)NULL) {
                        fprintf(outfile, "  %d", elemindex(tetloop.tet));
                    } else {
                        out->edge2tetlist[index2++] = elemindex(tetloop.tet);
                    }
                    // Fill the tetrahedron-to-edge map.
                    spintet = worktet;
                    while (1) {
                        if (!ishulltet(spintet)) {
                            tidx = elemindex(spintet.tet) - firstindex;
                            tet2edgelist[tidx * 6 + ver2edge[spintet.ver]] = edgenumber;
                        }
                        fnextself(spintet);
                        if (spintet.tet == worktet.tet) break;
                    }
                }
                if (out == (tetgenio*)NULL) {
                    fprintf(outfile, "\n");
                }
                edgenumber++;
            }
        }
        tetloop.tet = tetrahedrontraverse();
    }

    if (out == (tetgenio*)NULL) {
        fprintf(outfile, "# Generated by %s\n", b->commandline);
        fclose(outfile);
    }

    if (b->neighout > 1) { // -nn option
        long tsize = tetrahedrons->items - hullsize;

        if (b->facesout) { // -f option
                           // Build the face-to-edge map (use the tet-to-edge map).
            long fsize = (tsize * 4l + hullsize) / 2l;
            int* face2edgelist = new int[fsize * 3];

            tetrahedrons->traversalinit();
            tetloop.tet = tetrahedrontraverse();
            int facenumber = 0; // firstindex; // in->firstnumber;
            while (tetloop.tet != (tetrahedron*)NULL) {
                for (tetloop.ver = 0; tetloop.ver < 4; tetloop.ver++) {
                    fsym(tetloop, spintet);
                    if (ishulltet(spintet) || (elemindex(tetloop.tet) < elemindex(spintet.tet))) {
                        // The three edges of this face are ordered such that the
                        //    first edge is opposite to the first vertex of this face
                        //    that appears in the .face file, and so on.
                        tidx = elemindex(tetloop.tet) - firstindex;
                        worktet = tetloop;
                        for (i = 0; i < 3; i++) {
                            enextself(worktet); // The edge opposite to vertex i.
                            int eidx = tet2edgelist[tidx * 6 + ver2edge[worktet.ver]];
                            face2edgelist[facenumber * 3 + i] = eidx;
                        }
                        facenumber++;
                    }
                }
                tetloop.tet = tetrahedrontraverse();
            }

            // Output the face-to-edge map.
            if (out == (tetgenio*)NULL) {
                strcpy(edgefilename, b->outfilename);
                strcat(edgefilename, ".f2e");
            }
            if (!b->quiet) {
                if (out == (tetgenio*)NULL) {
                    printf("Writing %s.\n", edgefilename);
                } else {
                    printf("Writing face-to-edge map.\n");
                }
            }
            if (out == (tetgenio*)NULL) {
                outfile = fopen(edgefilename, "w");
                for (tidx = 0; tidx < fsize; tidx++) { // Re-use `tidx'
                    i = tidx * 3;
                    fprintf(outfile, "%4d  %d %d %d\n", tidx + in->firstnumber, face2edgelist[i],
                            face2edgelist[i + 1], face2edgelist[i + 2]);
                }
                fclose(outfile);
                delete[] face2edgelist;
            } else {
                // Simply copy the address of the list to the output.
                out->face2edgelist = face2edgelist;
            }
        } // if (b->facesout)

        // Output the tetrahedron-to-edge map.
        if (out == (tetgenio*)NULL) {
            strcpy(edgefilename, b->outfilename);
            strcat(edgefilename, ".t2e");
        }
        if (!b->quiet) {
            if (out == (tetgenio*)NULL) {
                printf("Writing %s.\n", edgefilename);
            } else {
                printf("Writing tetrahedron-to-edge map.\n");
            }
        }
        if (out == (tetgenio*)NULL) {
            outfile = fopen(edgefilename, "w");
            for (tidx = 0; tidx < tsize; tidx++) {
                i = tidx * 6;
                fprintf(outfile, "%4d  %d %d %d %d %d %d\n", tidx + in->firstnumber,
                        tet2edgelist[i], tet2edgelist[i + 1], tet2edgelist[i + 2],
                        tet2edgelist[i + 3], tet2edgelist[i + 4], tet2edgelist[i + 5]);
            }
            fclose(outfile);
            delete[] tet2edgelist;
        } else {
            // Simply copy the address of the list to the output.
            out->tet2edgelist = tet2edgelist;
        }
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// outsubsegments()    Output segments to a .edge file or a structure.       //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::outsubsegments(tetgenio* out) {
    FILE* outfile = NULL;
    char edgefilename[FILENAMESIZE];
    int* elist = NULL;
    int index, i;
    face edgeloop;
    point torg, tdest;
    int firstindex, shift;
    int marker;
    int edgenumber;

    // For -o2 option.
    triface workface, spintet;
    point *extralist, pp = NULL;
    int highorderindex = 11;
    int o2index = 0;

    // For -nn option.
    int neigh = -1;
    int index2 = 0;

    int t1ver; // used by fsymself()

    if (out == (tetgenio*)NULL) {
        strcpy(edgefilename, b->outfilename);
        strcat(edgefilename, ".edge");
    }

    if (!b->quiet) {
        if (out == (tetgenio*)NULL) {
            printf("Writing %s.\n", edgefilename);
        } else {
            printf("Writing edges.\n");
        }
    }

    if (out == (tetgenio*)NULL) {
        outfile = fopen(edgefilename, "w");
        if (outfile == (FILE*)NULL) {
            printf("File I/O Error:  Cannot create file %s.\n", edgefilename);
            terminatetetgen(this, 3);
        }
        // Number of subsegments.
        fprintf(outfile, "%ld  1\n", subsegs->items);
    } else {
        // Allocate memory for 'edgelist'.
        out->edgelist = new int[subsegs->items * (b->order == 1 ? 2 : 3)];
        if (out->edgelist == (int*)NULL) {
            terminatetetgen(this, 1);
        }
        if (b->order == 2) {
            out->o2edgelist = new int[subsegs->items];
        }
        out->edgemarkerlist = new int[subsegs->items];
        if (out->edgemarkerlist == (int*)NULL) {
            terminatetetgen(this, 1);
        }
        if (b->neighout > 1) {
            out->edge2tetlist = new int[subsegs->items];
        }
        out->numberofedges = subsegs->items;
        elist = out->edgelist;
    }

    // Determine the first index (0 or 1).
    firstindex = b->zeroindex ? 0 : in->firstnumber;
    shift = 0; // Default no shiftment.
    if ((in->firstnumber == 1) && (firstindex == 0)) {
        shift = 1; // Shift the output indices by 1.
    }
    index = 0;
    i = 0;

    subsegs->traversalinit();
    edgeloop.sh = shellfacetraverse(subsegs);
    edgenumber = firstindex; // in->firstnumber;
    while (edgeloop.sh != (shellface*)NULL) {
        torg = sorg(edgeloop);
        tdest = sdest(edgeloop);
        if ((b->order == 2) || (b->neighout > 1)) {
            sstpivot1(edgeloop, workface);
            if (workface.tet != NULL) {
                // We must find a non-hull tet.
                if (ishulltet(workface)) {
                    spintet = workface;
                    while (1) {
                        fnextself(spintet);
                        if (!ishulltet(spintet)) break;
                        if (spintet.tet == workface.tet) break;
                    }
                    workface = spintet;
                }
            }
        }
        if (b->order == 2) { // -o2
            // Get the extra vertex on this edge.
            if (workface.tet != NULL) {
                extralist = (point*)workface.tet[highorderindex];
                pp = extralist[ver2edge[workface.ver]];
            } else {
                pp = torg; // There is no extra node available.
            }
        }
        if (b->neighout > 1) { // -nn
            if (workface.tet != NULL) {
                neigh = elemindex(workface.tet);
            } else {
                neigh = -1;
            }
        }
        marker = shellmark(edgeloop);
        if (marker == 0) {
            marker = 1; // Default marker of a boundary edge is 1.
        }
        if (out == (tetgenio*)NULL) {
            fprintf(outfile, "%5d   %4d  %4d", edgenumber, pointmark(torg) - shift,
                    pointmark(tdest) - shift);
            if (b->order == 2) { // -o2
                fprintf(outfile, "  %4d", pointmark(pp) - shift);
            }
            fprintf(outfile, "  %d", marker);
            if (b->neighout > 1) { // -nn
                fprintf(outfile, "  %4d", neigh);
            }
            fprintf(outfile, "\n");
        } else {
            // Output three vertices of this face;
            elist[index++] = pointmark(torg) - shift;
            elist[index++] = pointmark(tdest) - shift;
            if (b->order == 2) { // -o2
                out->o2edgelist[o2index++] = pointmark(pp) - shift;
            }
            out->edgemarkerlist[i++] = marker;
            if (b->neighout > 1) { // -nn
                out->edge2tetlist[index2++] = neigh;
            }
        }
        edgenumber++;
        edgeloop.sh = shellfacetraverse(subsegs);
    }

    if (out == (tetgenio*)NULL) {
        fprintf(outfile, "# Generated by %s\n", b->commandline);
        fclose(outfile);
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// outneighbors()    Output tet neighbors to a .neigh file or a structure.   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::outneighbors(tetgenio* out) {
    FILE* outfile = NULL;
    char neighborfilename[FILENAMESIZE];
    int* nlist = NULL;
    int index = 0;
    triface tetloop, tetsym;
    int neighbori[4];
    int firstindex;
    int elementnumber;
    long ntets;

    if (out == (tetgenio*)NULL) {
        strcpy(neighborfilename, b->outfilename);
        strcat(neighborfilename, ".neigh");
    }

    if (!b->quiet) {
        if (out == (tetgenio*)NULL) {
            printf("Writing %s.\n", neighborfilename);
        } else {
            printf("Writing neighbors.\n");
        }
    }

    ntets = tetrahedrons->items - hullsize;

    if (out == (tetgenio*)NULL) {
        outfile = fopen(neighborfilename, "w");
        if (outfile == (FILE*)NULL) {
            printf("File I/O Error:  Cannot create file %s.\n", neighborfilename);
            terminatetetgen(this, 1);
        }
        // Number of tetrahedra, four faces per tetrahedron.
        fprintf(outfile, "%ld  %d\n", ntets, 4);
    } else {
        // Allocate memory for 'neighborlist'.
        out->neighborlist = new int[ntets * 4];
        if (out->neighborlist == (int*)NULL) {
            printf("Error:  Out of memory.\n");
            terminatetetgen(this, 1);
        }
        nlist = out->neighborlist;
    }

    // Determine the first index (0 or 1).
    firstindex = b->zeroindex ? 0 : in->firstnumber;

    tetrahedrons->traversalinit();
    tetloop.tet = tetrahedrontraverse();
    elementnumber = firstindex; // in->firstnumber;
    while (tetloop.tet != (tetrahedron*)NULL) {
        for (tetloop.ver = 0; tetloop.ver < 4; tetloop.ver++) {
            fsym(tetloop, tetsym);
            if (!ishulltet(tetsym)) {
                neighbori[tetloop.ver] = elemindex(tetsym.tet);
            } else {
                neighbori[tetloop.ver] = -1;
            }
        }
        if (out == (tetgenio*)NULL) {
            // Tetrahedra number, neighboring tetrahedron numbers.
            fprintf(outfile, "%4d    %4d  %4d  %4d  %4d\n", elementnumber, neighbori[0],
                    neighbori[1], neighbori[2], neighbori[3]);
        } else {
            nlist[index++] = neighbori[0];
            nlist[index++] = neighbori[1];
            nlist[index++] = neighbori[2];
            nlist[index++] = neighbori[3];
        }
        tetloop.tet = tetrahedrontraverse();
        elementnumber++;
    }

    if (out == (tetgenio*)NULL) {
        fprintf(outfile, "# Generated by %s\n", b->commandline);
        fclose(outfile);
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// outvoronoi()    Output the Voronoi diagram to .v.node, .v.edge, v.face,   //
//                 and .v.cell.                                              //
//                                                                           //
// The Voronoi diagram is the geometric dual of the Delaunay triangulation.  //
// The Voronoi vertices are the circumcenters of Delaunay tetrahedra.  Each  //
// Voronoi edge connects two Voronoi vertices at two sides of a common Dela- //
// unay face. At a face of convex hull, it becomes a ray (goto the infinity).//
// A Voronoi face is the convex hull of all Voronoi vertices around a common //
// Delaunay edge. It is a closed polygon for any internal Delaunay edge. At a//
// ridge, it is unbounded.  Each Voronoi cell is the convex hull of all Vor- //
// onoi vertices around a common Delaunay vertex. It is a polytope for any   //
// internal Delaunay vertex. It is an unbounded polyhedron for a Delaunay    //
// vertex belonging to the convex hull.                                      //
//                                                                           //
// NOTE: This routine is only used when the input is only a set of point.    //
// Comment: Special thanks to Victor Liu for finding and fixing few bugs.    //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::outvoronoi(tetgenio* out) {
    FILE* outfile = NULL;
    char outfilename[FILENAMESIZE];
    tetgenio::voroedge* vedge = NULL;
    tetgenio::vorofacet* vfacet = NULL;
    arraypool *tetlist, *ptlist;
    triface tetloop, worktet, spintet, firsttet;
    point pt[4], ploop, neipt;
    REAL ccent[3], infvec[3], vec1[3], vec2[3], L;
    long ntets, faces, edges;
    int *indexarray, *fidxs, *eidxs;
    int arraysize, *vertarray = NULL;
    int vpointcount, vedgecount, vfacecount, tcount;
    int ishullvert, ishullface;
    int index, shift, end1, end2;
    int i, j;

    int t1ver; // used by fsymself()

    // Output Voronoi vertices to .v.node file.
    if (out == (tetgenio*)NULL) {
        strcpy(outfilename, b->outfilename);
        strcat(outfilename, ".v.node");
    }

    if (!b->quiet) {
        if (out == (tetgenio*)NULL) {
            printf("Writing %s.\n", outfilename);
        } else {
            printf("Writing Voronoi vertices.\n");
        }
    }

    // Determine the first index (0 or 1).
    shift = (b->zeroindex ? 0 : in->firstnumber);

    // Each face and edge of the tetrahedral mesh will be indexed for indexing
    //   the Voronoi edges and facets. Indices of faces and edges are saved in
    //   each tetrahedron (including hull tets).

    // Allocate the total space once.
    indexarray = new int[tetrahedrons->items * 10];

    // Allocate space (10 integers) into each tetrahedron. It re-uses the slot
    //   for element markers, flags.
    i = 0;
    tetrahedrons->traversalinit();
    tetloop.tet = alltetrahedrontraverse();
    while (tetloop.tet != NULL) {
        tetloop.tet[11] = (tetrahedron) & (indexarray[i * 10]);
        i++;
        tetloop.tet = alltetrahedrontraverse();
    }

    // The number of tetrahedra (excluding hull tets) (Voronoi vertices).
    ntets = tetrahedrons->items - hullsize;
    // The number of Delaunay faces (Voronoi edges).
    faces = (4l * ntets + hullsize) / 2l;
    // The number of Delaunay edges (Voronoi faces).
    long vsize = points->items - dupverts - unuverts;
    if (b->weighted) vsize -= nonregularcount;
    if (!nonconvex) {
        edges = vsize + faces - ntets - 1;
    } else {
        if (meshedges == 0l) {
            numberedges(); // Count edges.
        }
        edges = meshedges;
    }

    if (out == (tetgenio*)NULL) {
        outfile = fopen(outfilename, "w");
        if (outfile == (FILE*)NULL) {
            printf("File I/O Error:  Cannot create file %s.\n", outfilename);
            terminatetetgen(this, 3);
        }
        // Number of voronoi points, 3 dim, no attributes, no marker.
        fprintf(outfile, "%ld  3  0  0\n", ntets);
    } else {
        // Allocate space for 'vpointlist'.
        out->numberofvpoints = (int)ntets;
        out->vpointlist = new REAL[out->numberofvpoints * 3];
        if (out->vpointlist == (REAL*)NULL) {
            terminatetetgen(this, 1);
        }
    }

    // Output Voronoi vertices (the circumcenters of tetrahedra).
    tetrahedrons->traversalinit();
    tetloop.tet = tetrahedrontraverse();
    vpointcount = 0; // The (internal) v-index always starts from 0.
    index = 0;
    while (tetloop.tet != (tetrahedron*)NULL) {
        for (i = 0; i < 4; i++) {
            pt[i] = (point)tetloop.tet[4 + i];
            setpoint2tet(pt[i], encode(tetloop));
        }
        if (b->weighted) {
            orthosphere(pt[0], pt[1], pt[2], pt[3], pt[0][3], pt[1][3], pt[2][3], pt[3][3], ccent,
                        NULL);
        } else {
            circumsphere(pt[0], pt[1], pt[2], pt[3], ccent, NULL);
        }
        if (out == (tetgenio*)NULL) {
            fprintf(outfile, "%4d  %16.8e %16.8e %16.8e\n", vpointcount + shift, ccent[0], ccent[1],
                    ccent[2]);
        } else {
            out->vpointlist[index++] = ccent[0];
            out->vpointlist[index++] = ccent[1];
            out->vpointlist[index++] = ccent[2];
        }
        setelemindex(tetloop.tet, vpointcount);
        vpointcount++;
        tetloop.tet = tetrahedrontraverse();
    }

    if (out == (tetgenio*)NULL) {
        fprintf(outfile, "# Generated by %s\n", b->commandline);
        fclose(outfile);
    }

    // Output Voronoi edges to .v.edge file.
    if (out == (tetgenio*)NULL) {
        strcpy(outfilename, b->outfilename);
        strcat(outfilename, ".v.edge");
    }

    if (!b->quiet) {
        if (out == (tetgenio*)NULL) {
            printf("Writing %s.\n", outfilename);
        } else {
            printf("Writing Voronoi edges.\n");
        }
    }

    if (out == (tetgenio*)NULL) {
        outfile = fopen(outfilename, "w");
        if (outfile == (FILE*)NULL) {
            printf("File I/O Error:  Cannot create file %s.\n", outfilename);
            terminatetetgen(this, 3);
        }
        // Number of Voronoi edges, no marker.
        fprintf(outfile, "%ld  0\n", faces);
    } else {
        // Allocate space for 'vpointlist'.
        out->numberofvedges = (int)faces;
        out->vedgelist = new tetgenio::voroedge[out->numberofvedges];
    }

    // Output the Voronoi edges.
    tetrahedrons->traversalinit();
    tetloop.tet = tetrahedrontraverse();
    vedgecount = 0; // D-Face (V-edge) index (from zero).
    index = 0;      // The Delaunay-face index.
    while (tetloop.tet != (tetrahedron*)NULL) {
        // Count the number of Voronoi edges. Look at the four faces of each
        //   tetrahedron. Count the face if the tetrahedron's index is
        //   smaller than its neighbor's or the neighbor is outside.
        end1 = elemindex(tetloop.tet);
        for (tetloop.ver = 0; tetloop.ver < 4; tetloop.ver++) {
            fsym(tetloop, worktet);
            if (ishulltet(worktet) || (elemindex(tetloop.tet) < elemindex(worktet.tet))) {
                // Found a Voronoi edge. Operate on it.
                if (out == (tetgenio*)NULL) {
                    fprintf(outfile, "%4d  %4d", vedgecount + shift, end1 + shift);
                } else {
                    vedge = &(out->vedgelist[index++]);
                    vedge->v1 = end1 + shift;
                }
                if (!ishulltet(worktet)) {
                    end2 = elemindex(worktet.tet);
                } else {
                    end2 = -1;
                }
                // Note that end2 may be -1 (worktet.tet is outside).
                if (end2 == -1) {
                    // Calculate the out normal of this hull face.
                    pt[0] = dest(worktet);
                    pt[1] = org(worktet);
                    pt[2] = apex(worktet);
                    for (j = 0; j < 3; j++)
                        vec1[j] = pt[1][j] - pt[0][j];
                    for (j = 0; j < 3; j++)
                        vec2[j] = pt[2][j] - pt[0][j];
                    cross(vec1, vec2, infvec);
                    // Normalize it.
                    L = sqrt(infvec[0] * infvec[0] + infvec[1] * infvec[1] + infvec[2] * infvec[2]);
                    if (L > 0)
                        for (j = 0; j < 3; j++)
                            infvec[j] /= L;
                    if (out == (tetgenio*)NULL) {
                        fprintf(outfile, " -1");
                        fprintf(outfile, " %g %g %g\n", infvec[0], infvec[1], infvec[2]);
                    } else {
                        vedge->v2 = -1;
                        vedge->vnormal[0] = infvec[0];
                        vedge->vnormal[1] = infvec[1];
                        vedge->vnormal[2] = infvec[2];
                    }
                } else {
                    if (out == (tetgenio*)NULL) {
                        fprintf(outfile, " %4d\n", end2 + shift);
                    } else {
                        vedge->v2 = end2 + shift;
                        vedge->vnormal[0] = 0.0;
                        vedge->vnormal[1] = 0.0;
                        vedge->vnormal[2] = 0.0;
                    }
                }
                // Save the V-edge index in this tet and its neighbor.
                fidxs = (int*)(tetloop.tet[11]);
                fidxs[tetloop.ver] = vedgecount;
                fidxs = (int*)(worktet.tet[11]);
                fidxs[worktet.ver & 3] = vedgecount;
                vedgecount++;
            }
        } // tetloop.ver
        tetloop.tet = tetrahedrontraverse();
    }

    if (out == (tetgenio*)NULL) {
        fprintf(outfile, "# Generated by %s\n", b->commandline);
        fclose(outfile);
    }

    // Output Voronoi faces to .v.face file.
    if (out == (tetgenio*)NULL) {
        strcpy(outfilename, b->outfilename);
        strcat(outfilename, ".v.face");
    }

    if (!b->quiet) {
        if (out == (tetgenio*)NULL) {
            printf("Writing %s.\n", outfilename);
        } else {
            printf("Writing Voronoi faces.\n");
        }
    }

    if (out == (tetgenio*)NULL) {
        outfile = fopen(outfilename, "w");
        if (outfile == (FILE*)NULL) {
            printf("File I/O Error:  Cannot create file %s.\n", outfilename);
            terminatetetgen(this, 3);
        }
        // Number of Voronoi faces.
        fprintf(outfile, "%ld  0\n", edges);
    } else {
        out->numberofvfacets = edges;
        out->vfacetlist = new tetgenio::vorofacet[out->numberofvfacets];
        if (out->vfacetlist == (tetgenio::vorofacet*)NULL) {
            terminatetetgen(this, 1);
        }
    }

    // Output the Voronoi facets.
    tetrahedrons->traversalinit();
    tetloop.tet = tetrahedrontraverse();
    vfacecount = 0; // D-edge (V-facet) index (from zero).
    while (tetloop.tet != (tetrahedron*)NULL) {
        // Count the number of Voronoi faces. Look at the six edges of each
        //   tetrahedron. Count the edge only if the tetrahedron's index is
        //   smaller than those of all other tetrahedra that share the edge.
        worktet.tet = tetloop.tet;
        for (i = 0; i < 6; i++) {
            worktet.ver = edge2ver[i];
            // Count the number of faces at this edge. If the edge is a hull edge,
            //   the face containing dummypoint is also counted.
            // ishulledge = 0; // Is it a hull edge.
            tcount = 0;
            firsttet = worktet;
            spintet = worktet;
            while (1) {
                tcount++;
                fnextself(spintet);
                if (spintet.tet == worktet.tet) break;
                if (!ishulltet(spintet)) {
                    if (elemindex(spintet.tet) < elemindex(worktet.tet)) break;
                } else {
                    // ishulledge = 1;
                    if (apex(spintet) == dummypoint) {
                        // We make this V-edge appear in the end of the edge list.
                        fnext(spintet, firsttet);
                    }
                }
            } // while (1)
            if (spintet.tet == worktet.tet) {
                // Found a Voronoi facet. Operate on it.
                pt[0] = org(worktet);
                pt[1] = dest(worktet);
                end1 = pointmark(pt[0]) - in->firstnumber; // V-cell index
                end2 = pointmark(pt[1]) - in->firstnumber;
                if (out == (tetgenio*)NULL) {
                    fprintf(outfile, "%4d  %4d %4d  %-2d ", vfacecount + shift, end1 + shift,
                            end2 + shift, tcount);
                } else {
                    vfacet = &(out->vfacetlist[vfacecount]);
                    vfacet->c1 = end1 + shift;
                    vfacet->c2 = end2 + shift;
                    vfacet->elist = new int[tcount + 1];
                    vfacet->elist[0] = tcount;
                    index = 1;
                }
                // Output V-edges of this V-facet.
                spintet = firsttet; // worktet;
                while (1) {
                    fidxs = (int*)(spintet.tet[11]);
                    if (apex(spintet) != dummypoint) {
                        vedgecount = fidxs[spintet.ver & 3];
                        ishullface = 0;
                    } else {
                        ishullface = 1; // It's not a real face.
                    }
                    if (out == (tetgenio*)NULL) {
                        fprintf(outfile, " %d", !ishullface ? (vedgecount + shift) : -1);
                    } else {
                        vfacet->elist[index++] = !ishullface ? (vedgecount + shift) : -1;
                    }
                    // Save the V-facet index in this tet at this edge.
                    eidxs = &(fidxs[4]);
                    eidxs[ver2edge[spintet.ver]] = vfacecount;
                    // Go to the next face.
                    fnextself(spintet);
                    if (spintet.tet == firsttet.tet) break;
                } // while (1)
                if (out == (tetgenio*)NULL) {
                    fprintf(outfile, "\n");
                }
                vfacecount++;
            } // if (spintet.tet == worktet.tet)
        }     // if (i = 0; i < 6; i++)
        tetloop.tet = tetrahedrontraverse();
    }

    if (out == (tetgenio*)NULL) {
        fprintf(outfile, "# Generated by %s\n", b->commandline);
        fclose(outfile);
    }

    // Output Voronoi cells to .v.cell file.
    if (out == (tetgenio*)NULL) {
        strcpy(outfilename, b->outfilename);
        strcat(outfilename, ".v.cell");
    }

    if (!b->quiet) {
        if (out == (tetgenio*)NULL) {
            printf("Writing %s.\n", outfilename);
        } else {
            printf("Writing Voronoi cells.\n");
        }
    }

    if (out == (tetgenio*)NULL) {
        outfile = fopen(outfilename, "w");
        if (outfile == (FILE*)NULL) {
            printf("File I/O Error:  Cannot create file %s.\n", outfilename);
            terminatetetgen(this, 3);
        }
        // Number of Voronoi cells.
        fprintf(outfile, "%ld\n", points->items - unuverts - dupverts);
    } else {
        out->numberofvcells = points->items - unuverts - dupverts;
        out->vcelllist = new int*[out->numberofvcells];
        if (out->vcelllist == (int**)NULL) {
            terminatetetgen(this, 1);
        }
    }

    // Output Voronoi cells.
    tetlist = cavetetlist;
    ptlist = cavetetvertlist;
    points->traversalinit();
    ploop = pointtraverse();
    vpointcount = 0;
    while (ploop != (point)NULL) {
        if ((pointtype(ploop) != UNUSEDVERTEX) && (pointtype(ploop) != DUPLICATEDVERTEX) &&
            (pointtype(ploop) != NREGULARVERTEX)) {
            getvertexstar(1, ploop, tetlist, ptlist, NULL);
            // Mark all vertices. Check if it is a hull vertex.
            ishullvert = 0;
            for (i = 0; i < ptlist->objects; i++) {
                neipt = *(point*)fastlookup(ptlist, i);
                if (neipt != dummypoint) {
                    pinfect(neipt);
                } else {
                    ishullvert = 1;
                }
            }
            tcount = (int)ptlist->objects;
            if (out == (tetgenio*)NULL) {
                fprintf(outfile, "%4d  %-2d ", vpointcount + shift, tcount);
            } else {
                arraysize = tcount;
                vertarray = new int[arraysize + 1];
                out->vcelllist[vpointcount] = vertarray;
                vertarray[0] = tcount;
                index = 1;
            }
            // List Voronoi facets bounding this cell.
            for (i = 0; i < tetlist->objects; i++) {
                worktet = *(triface*)fastlookup(tetlist, i);
                // Let 'worktet' be [a,b,c,d] where d = ploop.
                for (j = 0; j < 3; j++) {
                    neipt = org(worktet); // neipt is a, or b, or c
                    // Skip the dummypoint.
                    if (neipt != dummypoint) {
                        if (pinfected(neipt)) {
                            // It's not processed yet.
                            puninfect(neipt);
                            // Go to the DT edge [a,d], or [b,d], or [c,d].
                            esym(worktet, spintet);
                            enextself(spintet);
                            // Get the V-face dual to this edge.
                            eidxs = (int*)spintet.tet[11];
                            vfacecount = eidxs[4 + ver2edge[spintet.ver]];
                            if (out == (tetgenio*)NULL) {
                                fprintf(outfile, " %d", vfacecount + shift);
                            } else {
                                vertarray[index++] = vfacecount + shift;
                            }
                        }
                    }
                    enextself(worktet);
                } // j
            }     // i
            if (ishullvert) {
                // Add a hull facet (-1) to the facet list.
                if (out == (tetgenio*)NULL) {
                    fprintf(outfile, " -1");
                } else {
                    vertarray[index++] = -1;
                }
            }
            if (out == (tetgenio*)NULL) {
                fprintf(outfile, "\n");
            }
            tetlist->restart();
            ptlist->restart();
            vpointcount++;
        }
        ploop = pointtraverse();
    }

    // Delete the space for face/edge indices.
    delete[] indexarray;

    if (out == (tetgenio*)NULL) {
        fprintf(outfile, "# Generated by %s\n", b->commandline);
        fclose(outfile);
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// outsmesh()    Write surface mesh to a .smesh file, which can be read and  //
//               tetrahedralized by TetGen.                                  //
//                                                                           //
// You can specify a filename (without suffix) in 'smfilename'. If you don't //
// supply a filename (let smfilename be NULL), the default name stored in    //
// 'tetgenbehavior' will be used.                                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::outsmesh(char* smfilename) {
    FILE* outfile;
    char nodfilename[FILENAMESIZE];
    char smefilename[FILENAMESIZE];
    face faceloop;
    point p1, p2, p3;
    int firstindex, shift;
    int bmark;
    int marker;
    int i;

    if (smfilename != (char*)NULL && smfilename[0] != '\0') {
        strcpy(smefilename, smfilename);
    } else if (b->outfilename[0] != '\0') {
        strcpy(smefilename, b->outfilename);
    } else {
        strcpy(smefilename, "unnamed");
    }
    strcpy(nodfilename, smefilename);
    strcat(smefilename, ".smesh");
    strcat(nodfilename, ".node");

    if (!b->quiet) {
        printf("Writing %s.\n", smefilename);
    }
    outfile = fopen(smefilename, "w");
    if (outfile == (FILE*)NULL) {
        printf("File I/O Error:  Cannot create file %s.\n", smefilename);
        return;
    }

    // Determine the first index (0 or 1).
    firstindex = b->zeroindex ? 0 : in->firstnumber;
    shift = 0; // Default no shiftment.
    if ((in->firstnumber == 1) && (firstindex == 0)) {
        shift = 1; // Shift the output indices by 1.
    }

    fprintf(outfile, "# %s.  TetGen's input file.\n", smefilename);
    fprintf(outfile, "\n# part 1: node list.\n");
    fprintf(outfile, "0  3  0  0  # nodes are found in %s.\n", nodfilename);

    marker = 0; // avoid compile warning.
    bmark = !b->nobound && (in->facetmarkerlist || in->trifacemarkerlist);

    fprintf(outfile, "\n# part 2: facet list.\n");
    // Number of facets, boundary marker.
    fprintf(outfile, "%ld  %d\n", subfaces->items, bmark);

    subfaces->traversalinit();
    faceloop.sh = shellfacetraverse(subfaces);
    while (faceloop.sh != (shellface*)NULL) {
        p1 = sorg(faceloop);
        p2 = sdest(faceloop);
        p3 = sapex(faceloop);
        if (bmark) {
            marker = shellmark(faceloop);
        }
        fprintf(outfile, "3    %4d  %4d  %4d", pointmark(p1) - shift, pointmark(p2) - shift,
                pointmark(p3) - shift);
        if (bmark) {
            fprintf(outfile, "    %d", marker);
        }
        fprintf(outfile, "\n");
        faceloop.sh = shellfacetraverse(subfaces);
    }

    // Copy input holelist.
    fprintf(outfile, "\n# part 3: hole list.\n");
    fprintf(outfile, "%d\n", in->numberofholes);
    for (i = 0; i < in->numberofholes; i++) {
        fprintf(outfile, "%d  %g  %g  %g\n", i + in->firstnumber, in->holelist[i * 3],
                in->holelist[i * 3 + 1], in->holelist[i * 3 + 2]);
    }

    // Copy input regionlist.
    fprintf(outfile, "\n# part 4: region list.\n");
    fprintf(outfile, "%d\n", in->numberofregions);
    for (i = 0; i < in->numberofregions; i++) {
        fprintf(outfile, "%d  %g  %g  %g  %d  %g\n", i + in->firstnumber, in->regionlist[i * 5],
                in->regionlist[i * 5 + 1], in->regionlist[i * 5 + 2],
                (int)in->regionlist[i * 5 + 3], in->regionlist[i * 5 + 4]);
    }

    fprintf(outfile, "# Generated by %s\n", b->commandline);
    fclose(outfile);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// outmesh2medit()    Write mesh to a .mesh file, which can be read and      //
//                    rendered by Medit (a free mesh viewer from INRIA).     //
//                                                                           //
// You can specify a filename (without suffix) in 'mfilename'.  If you don't //
// supply a filename (let mfilename be NULL), the default name stored in     //
// 'tetgenbehavior' will be used. The output file will have the suffix .mesh.//
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::outmesh2medit(char* mfilename) {
    FILE* outfile;
    char mefilename[FILENAMESIZE];
    tetrahedron* tetptr;
    triface tface, tsymface;
    face segloop, checkmark;
    point ptloop, p1, p2, p3, p4;
    long ntets, faces;
    int pointnumber;
    int marker;
    int i;

    if (mfilename != (char*)NULL && mfilename[0] != '\0') {
        strcpy(mefilename, mfilename);
    } else if (b->outfilename[0] != '\0') {
        strcpy(mefilename, b->outfilename);
    } else {
        strcpy(mefilename, "unnamed");
    }
    strcat(mefilename, ".mesh");

    if (!b->quiet) {
        printf("Writing %s.\n", mefilename);
    }
    outfile = fopen(mefilename, "w");
    if (outfile == (FILE*)NULL) {
        printf("File I/O Error:  Cannot create file %s.\n", mefilename);
        return;
    }

    fprintf(outfile, "MeshVersionFormatted 1\n");
    fprintf(outfile, "\n");
    fprintf(outfile, "Dimension\n");
    fprintf(outfile, "3\n");
    fprintf(outfile, "\n");

    fprintf(outfile, "\n# Set of mesh vertices\n");
    fprintf(outfile, "Vertices\n");
    fprintf(outfile, "%ld\n", points->items);

    points->traversalinit();
    ptloop = pointtraverse();
    pointnumber = 1; // Medit need start number form 1.
    while (ptloop != (point)NULL) {
        // Point coordinates.
        fprintf(outfile, "%.17g  %.17g  %.17g", ptloop[0], ptloop[1], ptloop[2]);
        if (in->numberofpointattributes > 0) {
            // Write an attribute, ignore others if more than one.
            fprintf(outfile, "  %.17g\n", ptloop[3]);
        } else {
            fprintf(outfile, "    0\n");
        }
        setpointmark(ptloop, pointnumber);
        ptloop = pointtraverse();
        pointnumber++;
    }

    // Compute the number of faces.
    ntets = tetrahedrons->items - hullsize;
    faces = (ntets * 4l + hullsize) / 2l;

    fprintf(outfile, "\n# Set of Triangles\n");
    fprintf(outfile, "Triangles\n");
    fprintf(outfile, "%ld\n", faces);

    tetrahedrons->traversalinit();
    tface.tet = tetrahedrontraverse();
    while (tface.tet != (tetrahedron*)NULL) {
        for (tface.ver = 0; tface.ver < 4; tface.ver++) {
            fsym(tface, tsymface);
            if (ishulltet(tsymface) || (elemindex(tface.tet) < elemindex(tsymface.tet))) {
                p1 = org(tface);
                p2 = dest(tface);
                p3 = apex(tface);
                fprintf(outfile, "%5d  %5d  %5d", pointmark(p1), pointmark(p2), pointmark(p3));
                // Check if it is a subface.
                tspivot(tface, checkmark);
                if (checkmark.sh == NULL) {
                    marker = 0; // It is an inner face. It's marker is 0.
                } else {
                    marker = shellmark(checkmark);
                }
                fprintf(outfile, "    %d\n", marker);
            }
        }
        tface.tet = tetrahedrontraverse();
    }

    fprintf(outfile, "\n# Set of Tetrahedra\n");
    fprintf(outfile, "Tetrahedra\n");
    fprintf(outfile, "%ld\n", ntets);

    tetrahedrons->traversalinit();
    tetptr = tetrahedrontraverse();
    while (tetptr != (tetrahedron*)NULL) {
        if (!b->reversetetori) {
            p1 = (point)tetptr[4];
            p2 = (point)tetptr[5];
        } else {
            p1 = (point)tetptr[5];
            p2 = (point)tetptr[4];
        }
        p3 = (point)tetptr[6];
        p4 = (point)tetptr[7];
        fprintf(outfile, "%5d  %5d  %5d  %5d", pointmark(p1), pointmark(p2), pointmark(p3),
                pointmark(p4));
        if (numelemattrib > 0) {
            fprintf(outfile, "  %.17g", elemattribute(tetptr, 0));
        } else {
            fprintf(outfile, "  0");
        }
        fprintf(outfile, "\n");
        tetptr = tetrahedrontraverse();
    }

    fprintf(outfile, "\nCorners\n");
    fprintf(outfile, "%d\n", in->numberofpoints);

    for (i = 0; i < in->numberofpoints; i++) {
        fprintf(outfile, "%4d\n", i + 1);
    }

    if (b->plc || b->refine) {
        fprintf(outfile, "\nEdges\n");
        fprintf(outfile, "%ld\n", subsegs->items);

        subsegs->traversalinit();
        segloop.sh = shellfacetraverse(subsegs);
        while (segloop.sh != (shellface*)NULL) {
            p1 = sorg(segloop);
            p2 = sdest(segloop);
            fprintf(outfile, "%5d  %5d", pointmark(p1), pointmark(p2));
            marker = shellmark(segloop);
            fprintf(outfile, "    %d\n", marker);
            segloop.sh = shellfacetraverse(subsegs);
        }
    }

    fprintf(outfile, "\nEnd\n");
    fclose(outfile);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// outmesh2vtk()    Save mesh to file in VTK Legacy format.                  //
//                                                                           //
// This function was contributed by Bryn Llyod from ETH, 2007.               //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetgenmesh::outmesh2vtk(char* ofilename) {
    FILE* outfile;
    char vtkfilename[FILENAMESIZE];
    point pointloop, p1, p2, p3, p4;
    tetrahedron* tptr;
    double x, y, z;
    int n1, n2, n3, n4;
    int nnodes = 4;
    int celltype = 10;

    if (b->order == 2) {
        printf("  Write VTK not implemented for order 2 elements \n");
        return;
    }

    int NEL = tetrahedrons->items - hullsize;
    int NN = points->items;

    if (ofilename != (char*)NULL && ofilename[0] != '\0') {
        strcpy(vtkfilename, ofilename);
    } else if (b->outfilename[0] != '\0') {
        strcpy(vtkfilename, b->outfilename);
    } else {
        strcpy(vtkfilename, "unnamed");
    }
    strcat(vtkfilename, ".vtk");

    if (!b->quiet) {
        printf("Writing %s.\n", vtkfilename);
    }
    outfile = fopen(vtkfilename, "w");
    if (outfile == (FILE*)NULL) {
        printf("File I/O Error:  Cannot create file %s.\n", vtkfilename);
        return;
    }

    // always write big endian
    // bool ImALittleEndian = !testIsBigEndian();

    fprintf(outfile, "# vtk DataFile Version 2.0\n");
    fprintf(outfile, "Unstructured Grid\n");
    fprintf(outfile, "ASCII\n"); // BINARY
    fprintf(outfile, "DATASET UNSTRUCTURED_GRID\n");
    fprintf(outfile, "POINTS %d double\n", NN);

    points->traversalinit();
    pointloop = pointtraverse();
    for (int id = 0; id < NN && pointloop != (point)NULL; id++) {
        x = pointloop[0];
        y = pointloop[1];
        z = pointloop[2];
        fprintf(outfile, "%.17g %.17g %.17g\n", x, y, z);
        pointloop = pointtraverse();
    }
    fprintf(outfile, "\n");

    fprintf(outfile, "CELLS %d %d\n", NEL, NEL * (4 + 1));
    // NEL rows, each has 1 type id + 4 node id's

    tetrahedrons->traversalinit();
    tptr = tetrahedrontraverse();
    // elementnumber = firstindex; // in->firstnumber;
    while (tptr != (tetrahedron*)NULL) {
        if (!b->reversetetori) {
            p1 = (point)tptr[4];
            p2 = (point)tptr[5];
        } else {
            p1 = (point)tptr[5];
            p2 = (point)tptr[4];
        }
        p3 = (point)tptr[6];
        p4 = (point)tptr[7];
        n1 = pointmark(p1) - in->firstnumber;
        n2 = pointmark(p2) - in->firstnumber;
        n3 = pointmark(p3) - in->firstnumber;
        n4 = pointmark(p4) - in->firstnumber;
        fprintf(outfile, "%d  %4d %4d %4d %4d\n", nnodes, n1, n2, n3, n4);
        tptr = tetrahedrontraverse();
    }
    fprintf(outfile, "\n");

    fprintf(outfile, "CELL_TYPES %d\n", NEL);
    for (int tid = 0; tid < NEL; tid++) {
        fprintf(outfile, "%d\n", celltype);
    }
    fprintf(outfile, "\n");

    if (numelemattrib > 0) {
        // Output tetrahedra region attributes.
        fprintf(outfile, "CELL_DATA %d\n", NEL);
        fprintf(outfile, "SCALARS cell_scalars int 1\n");
        fprintf(outfile, "LOOKUP_TABLE default\n");
        tetrahedrons->traversalinit();
        tptr = tetrahedrontraverse();
        while (tptr != (tetrahedron*)NULL) {
            fprintf(outfile, "%d\n", (int)elemattribute(tptr, numelemattrib - 1));
            tptr = tetrahedrontraverse();
        }
        fprintf(outfile, "\n");
    }

    fclose(outfile);
}

////                                                                       ////
////                                                                       ////
//// output_cxx ///////////////////////////////////////////////////////////////

//// main_cxx /////////////////////////////////////////////////////////////////
////                                                                       ////
////                                                                       ////

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// tetrahedralize()    The interface for users using TetGen library to       //
//                     generate tetrahedral meshes with all features.        //
//                                                                           //
// The sequence is roughly as follows.  Many of these steps can be skipped,  //
// depending on the command line switches.                                   //
//                                                                           //
// - Initialize constants and parse the command line.                        //
// - Read the vertices from a file and either                                //
//   - tetrahedralize them (no -r), or                                       //
//   - read an old mesh from files and reconstruct it (-r).                  //
// - Insert the boundary segments and facets (-p or -Y).                     //
// - Read the holes (-p), regional attributes (-pA), and regional volume     //
//   constraints (-pa).  Carve the holes and concavities, and spread the     //
//   regional attributes and volume constraints.                             //
// - Enforce the constraints on minimum quality bound (-q) and maximum       //
//   volume (-a), and a mesh size function (-m).                             //
// - Optimize the mesh wrt. specified quality measures (-O and -o).          //
// - Write the output files and print the statistics.                        //
// - Check the consistency of the mesh (-C).                                 //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetrahedralize(tetgenbehavior* b, tetgenio* in, tetgenio* out, tetgenio* addin,
                    tetgenio* bgmin) {
    tetgenmesh m;
    clock_t tv[12], ts[5]; // Timing informations (defined in time.h)
    REAL cps = (REAL)CLOCKS_PER_SEC;

    tv[0] = clock();

    m.b = b;
    m.in = in;
    m.addin = addin;

    if (b->metric && bgmin && (bgmin->numberofpoints > 0)) {
        m.bgm = new tetgenmesh(); // Create an empty background mesh.
        m.bgm->b = b;
        m.bgm->in = bgmin;
    }

    m.initializepools();
    m.transfernodes();

    exactinit(b->verbose, b->noexact, b->nostaticfilter, m.xmax - m.xmin, m.ymax - m.ymin,
              m.zmax - m.zmin);

    tv[1] = clock();

    if (b->refine) { // -r
        m.reconstructmesh();
    } else { // -p
        m.incrementaldelaunay(ts[0]);
    }

    tv[2] = clock();

    if (!b->quiet) {
        if (b->refine) {
            printf("Mesh reconstruction seconds:  %g\n", ((REAL)(tv[2] - tv[1])) / cps);
        } else {
            printf("Delaunay seconds:  %g\n", ((REAL)(tv[2] - tv[1])) / cps);
            if (b->verbose) {
                printf("  Point sorting seconds:  %g\n", ((REAL)(ts[0] - tv[1])) / cps);
            }
        }
    }

    if (b->plc && !b->refine) { // -p
        m.meshsurface();

        ts[0] = clock();

        if (!b->quiet) {
            printf("Surface mesh seconds:  %g\n", ((REAL)(ts[0] - tv[2])) / cps);
        }

        if (b->diagnose) { // -d
            m.detectinterfaces();

            ts[1] = clock();

            if (!b->quiet) {
                printf("Self-intersection seconds:  %g\n", ((REAL)(ts[1] - ts[0])) / cps);
            }

            // Only output when self-intersecting faces exist.
            if (m.subfaces->items > 0l) {
                m.outnodes(out);
                m.outsubfaces(out);
            }

            return;
        }
    }

    tv[3] = clock();

    if ((b->metric) && (m.bgm != NULL)) { // -m
        m.bgm->initializepools();
        m.bgm->transfernodes();
        m.bgm->reconstructmesh();

        ts[0] = clock();

        if (!b->quiet) {
            printf("Background mesh reconstruct seconds:  %g\n", ((REAL)(ts[0] - tv[3])) / cps);
        }

        if (b->metric) { // -m
            m.interpolatemeshsize();

            ts[1] = clock();

            if (!b->quiet) {
                printf("Size interpolating seconds:  %g\n", ((REAL)(ts[1] - ts[0])) / cps);
            }
        }
    }

    tv[4] = clock();

    if (b->plc && !b->refine) { // -p
        if (b->nobisect) {      // -Y
            m.recoverboundary(ts[0]);
        } else {
            m.constraineddelaunay(ts[0]);
        }

        ts[1] = clock();

        if (!b->quiet) {
            if (b->nobisect) {
                printf("Boundary recovery ");
            } else {
                printf("Constrained Delaunay ");
            }
            printf("seconds:  %g\n", ((REAL)(ts[1] - tv[4])) / cps);
            if (b->verbose) {
                printf("  Segment recovery seconds:  %g\n", ((REAL)(ts[0] - tv[4])) / cps);
                printf("  Facet recovery seconds:  %g\n", ((REAL)(ts[1] - ts[0])) / cps);
            }
        }

        m.carveholes();

        ts[2] = clock();

        if (!b->quiet) {
            printf("Exterior tets removal seconds:  %g\n", ((REAL)(ts[2] - ts[1])) / cps);
        }

        if (b->nobisect) { // -Y
            if (m.subvertstack->objects > 0l) {
                m.suppresssteinerpoints();

                ts[3] = clock();

                if (!b->quiet) {
                    printf("Steiner suppression seconds:  %g\n", ((REAL)(ts[3] - ts[2])) / cps);
                }
            }
        }
    }

    tv[5] = clock();

    if (b->coarsen) { // -R
        m.meshcoarsening();
    }

    tv[6] = clock();

    if (!b->quiet) {
        if (b->coarsen) {
            printf("Mesh coarsening seconds:  %g\n", ((REAL)(tv[6] - tv[5])) / cps);
        }
    }

    if ((b->plc && b->nobisect) || b->coarsen) {
        m.recoverdelaunay();
    }

    tv[7] = clock();

    if (!b->quiet) {
        if ((b->plc && b->nobisect) || b->coarsen) {
            printf("Delaunay recovery seconds:  %g\n", ((REAL)(tv[7] - tv[6])) / cps);
        }
    }

    if ((b->plc || b->refine) && b->insertaddpoints) { // -i
        if ((addin != NULL) && (addin->numberofpoints > 0)) {
            m.insertconstrainedpoints(addin);
        }
    }

    tv[8] = clock();

    if (!b->quiet) {
        if ((b->plc || b->refine) && b->insertaddpoints) { // -i
            if ((addin != NULL) && (addin->numberofpoints > 0)) {
                printf("Constrained points seconds:  %g\n", ((REAL)(tv[8] - tv[7])) / cps);
            }
        }
    }

    if (b->quality) {
        m.delaunayrefinement();
    }

    tv[9] = clock();

    if (!b->quiet) {
        if (b->quality) {
            printf("Refinement seconds:  %g\n", ((REAL)(tv[9] - tv[8])) / cps);
        }
    }

    if ((b->plc || b->refine) && (b->optlevel > 0)) {
        m.optimizemesh();
    }

    tv[10] = clock();

    if (!b->quiet) {
        if ((b->plc || b->refine) && (b->optlevel > 0)) {
            printf("Optimization seconds:  %g\n", ((REAL)(tv[10] - tv[9])) / cps);
        }
    }

    if (!b->nojettison &&
        ((m.dupverts > 0) || (m.unuverts > 0) || (b->refine && (in->numberofcorners == 10)))) {
        m.jettisonnodes();
    }

    if ((b->order == 2) && !b->convex) {
        m.highorder();
    }

    if (!b->quiet) {
        printf("\n");
    }

    if (out != (tetgenio*)NULL) {
        out->firstnumber = in->firstnumber;
        out->mesh_dim = in->mesh_dim;
    }

    if (b->nonodewritten || b->noiterationnum) {
        if (!b->quiet) {
            printf("NOT writing a .node file.\n");
        }
    } else {
        m.outnodes(out);
    }

    if (b->noelewritten) {
        if (!b->quiet) {
            printf("NOT writing an .ele file.\n");
        }
        m.indexelements();
    } else {
        if (m.tetrahedrons->items > 0l) {
            m.outelements(out);
        }
    }

    if (b->nofacewritten) {
        if (!b->quiet) {
            printf("NOT writing an .face file.\n");
        }
    } else {
        if (b->facesout) {
            if (m.tetrahedrons->items > 0l) {
                m.outfaces(out); // Output all faces.
            }
        } else {
            if (b->plc || b->refine) {
                if (m.subfaces->items > 0l) {
                    m.outsubfaces(out); // Output boundary faces.
                }
            } else {
                if (m.tetrahedrons->items > 0l) {
                    m.outhullfaces(out); // Output convex hull faces.
                }
            }
        }
    }

    if (b->nofacewritten) {
        if (!b->quiet) {
            printf("NOT writing an .edge file.\n");
        }
    } else {
        if (b->edgesout) {   // -e
            m.outedges(out); // output all mesh edges.
        } else {
            if (b->plc || b->refine) {
                m.outsubsegments(out); // output subsegments.
            }
        }
    }

    if ((b->plc || b->refine) && b->metric) { // -m
        m.outmetrics(out);
    }

    if (!out && b->plc &&
        ((b->object == tetgenbehavior::OFF) || (b->object == tetgenbehavior::PLY) ||
         (b->object == tetgenbehavior::STL))) {
        m.outsmesh(b->outfilename);
    }

    if (!out && b->meditview) {
        m.outmesh2medit(b->outfilename);
    }

    if (!out && b->vtkview) {
        m.outmesh2vtk(b->outfilename);
    }

    if (b->neighout) {
        m.outneighbors(out);
    }

    if (b->voroout) {
        m.outvoronoi(out);
    }

    tv[11] = clock();

    if (!b->quiet) {
        printf("\nOutput seconds:  %g\n", ((REAL)(tv[11] - tv[10])) / cps);
        printf("Total running seconds:  %g\n", ((REAL)(tv[11] - tv[0])) / cps);
    }

    if (b->docheck) {
        m.checkmesh(0);
        if (b->plc || b->refine) {
            m.checkshells();
            m.checksegments();
        }
        if (b->docheck > 1) {
            m.checkdelaunay();
        }
    }

    if (!b->quiet) {
        m.statistics();
    }
}

#ifndef TETLIBRARY

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// main()    The command line interface of TetGen.                           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

int main(int argc, char* argv[])

#else // with TETLIBRARY

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// tetrahedralize()    The library interface of TetGen.                      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

void tetrahedralize(char* switches, tetgenio* in, tetgenio* out, tetgenio* addin, tetgenio* bgmin)

#endif // not TETLIBRARY

{
    tetgenbehavior b;

#ifndef TETLIBRARY

    tetgenio in, addin, bgmin;

    if (!b.parse_commandline(argc, argv)) {
        terminatetetgen(NULL, 10);
    }

    // Read input files.
    if (b.refine) { // -r
        if (!in.load_tetmesh(b.infilename, (int)b.object)) {
            terminatetetgen(NULL, 10);
        }
    } else { // -p
        if (!in.load_plc(b.infilename, (int)b.object)) {
            terminatetetgen(NULL, 10);
        }
    }
    if (b.insertaddpoints) { // -i
        // Try to read a .a.node file.
        addin.load_node(b.addinfilename);
    }
    if (b.metric) { // -m
        // Try to read a background mesh in files .b.node, .b.ele.
        bgmin.load_tetmesh(b.bgmeshfilename, (int)b.object);
    }

    tetrahedralize(&b, &in, NULL, &addin, &bgmin);

    return 0;

#else // with TETLIBRARY

    if (!b.parse_commandline(switches)) {
        terminatetetgen(NULL, 10);
    }
    tetrahedralize(&b, in, out, addin, bgmin);

#endif // not TETLIBRARY
}

////                                                                       ////
////                                                                       ////
//// main_cxx /////////////////////////////////////////////////////////////////