I'm not able to triangulate a regular point cloud

Question

I easily tessellated two parametric 3D surfaces (both convex surfaces).

These are the two tessellated parametric surfaces:

Now, my intention is to join both in a single solid. But I'm obtaining this:

enter image description here

I'm using Qhull to create the Delaunay triangulation and it seems that works well for the 1st convex surface, but not for back surface. :(

This is my current code (parts taken from ZivS )

#include "Qhull.h"

using namespace orgQhull;

void myQhull::Qhull::runQhull3D(const pcl::PCLPointCloud2& pointCloud, const char* args)
{
    std::cout << "runQhull vertices" << std::endl;
    numVertices = 0;
    std::stringstream verticesSS;
    m_externalPoints = new PointCoordinates(3,"");  //3 = dimension
    pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);
    pcl::fromPCLPointCloud2(pointCloud, *cloud);
    std::vector<double> allPoints;

    for (unsigned int i = 0; i < cloud->size(); i++) {
        allPoints.push_back(cloud->at(i).x);
        allPoints.push_back(cloud->at(i).y);
        allPoints.push_back(cloud->at(i).z);
        verticesSS << cloud->at(i).x << " " << cloud->at(i).y << " " << cloud->at(i).z << "\n";
        numVertices++;
    }
    vertices += verticesSS.str();


    m_externalPoints->append(allPoints); //convert to vector<double>
    runQhull(*m_externalPoints, args);
}


void myQhull::Qhull::runQhull(const PointCoordinates &points, const char *qhullCommand2)
{
    std::string triangles;
    std::stringstream ss;
    numSimplices = 0;
    int numFaces = 0;

    std::cout << numVertices << std::endl;
    std::cout << "runQhull facets" << std::endl;

    orgQhull::Qhull qHull(points.comment().c_str(), points.dimension(), points.count(), &*points.coordinates(), qhullCommand2);
    QhullFacetList facets = qHull.facetList();
    for (QhullFacetList::iterator it = facets.begin(); it != facets.end(); ++it)
    {
        if (!(*it).isGood()) continue;
        QhullFacet f = *it;
        QhullVertexSet vSet = f.vertices();
        auto coord = f.hyperplane().coordinates();

        numFaces = vSet.size();

        ss << numFaces;
        for (QhullVertexSet::iterator vIt = vSet.begin(); vIt != vSet.end(); ++vIt)
        {
            QhullVertex v = *vIt;
            QhullPoint p = v.point();
            double * coords = p.coordinates();
            ss <<  " " << p.id() << " ";
        }
        ss << "\n";
        numSimplices++;


    }

    simplices +=  ss.str();
    std::cout << numSimplices << std::endl;

}

void myQhull::Qhull::saveOff(std::string file)
{
    std::cout << "Saving qhull.off" << std::endl;
    std::ofstream offFile;
    offFile.open(file);

    offFile << "OFF\n";
    offFile << numVertices << " " << numSimplices << " 0";
    offFile << vertices;
    offFile << simplices;
    offFile.close();

}


void myQhull::Qhull::run(const pcl::PCLPointCloud2& pointCloud)
{
    Qhull qhull;
    qhull.runQhull3D(pointCloud, "Qt");
    qhull.saveOff("qhull.off");

}

Also, I used greedy_projection from OpenCV but without any success. It is able only to perform the two surfaces tessellation without joining them.

Any idea why this is happening?

Answer 1

Finally I found the solution. Adding "d" to qhull.runQhull3D(pointCloud, "d Qt") generates the correct Delaunay triangulation for upper and lower surface. Therefore, as they are regular meshes I, manually, create the edge connecting vertices from the two surfaces. Thank you.