CGAL users discussion list

[Sean Hardesty <>]

Thank you for your help! I am well aware of the difficulty of tracking these things down via e-mail...

I am using a source build of CGAL 4.11 because my Ubuntu distribution comes with 4.7. My program looks like this:

#include <CGAL/Exact_predicates_exact_constructions_kernel.h>
#include <CGAL/Surface_mesh.h>

#include <CGAL/Polygon_mesh_processing/corefinement.h>

typedef CGAL::Exact_predicates_exact_constructions_kernel K;
typedef CGAL::Surface_mesh<K::Point_3> Mesh;

Skip some irrelevant code...

    // create cgal meshes

    std::vector<Mesh> mesh(ne);
    for(uint64_t ie=0;ie<ne;ie++) {
        foo.create_cgal_mesh(mesh[ie]);
    }

If I write them to .off files here, the Polyhedron demo does not say that any of them are polygon soups.

    // remove intersecting pieces

    for(uint64_t ie=0;ie<ne;ie++) {
        for(uint64_t je=ie+1;je<ne;je++) {
           
            bool result =
                CGAL::Polygon_mesh_processing::corefine_and_compute_difference(mesh[je], mesh[ie], mesh[je]);

            if (!result) {
                std::cout << "CGAL call returned false!" << std::endl;
                exit(1);
            }
        }
    }

If I write to a .off file each time through the inner loop and load the results into the polyhedron demo, I see that at some point, several of them become polygon soups (this seems to be the case independent of the precision with which I write the .off files). However, the loop continues well past the point where this first occurs. There is a particular pair of meshes (the ones I sent previously) where the call to corefine_and_compute_difference either results in the assertion error I mentioned in my first message, or runs for an implausibly long time (I think the difference between these two behaviors may have been caused by an update to my system libraries).

Suspecting that the real problem occurred earlier, I went back to find the first place where the results of corefine_and_compute_difference became a polygon soup. My meshes have some (approximate) symmetry, so I end up with two cases that are nearly identical, but one creates the first polygon soup and the other does not. The output for these two cases I have attached to this message. The demo lets me orient the polygon soup (mesh4.off) as a surface mesh and says it's not directly orientable, resulting in duplicated vertices and self-intersections. When I try to run self-intersection test, the demo segfaults.

    Sincerely,

    Sean

On Wed, Dec 13, 2017 at 9:37 AM, Sebastien Loriot (GeometryFactory) <> wrote:

If you have been able to build a Polyhedron or a Surface_mesh it means
that it is not a polygon soup.

I guess you do something different than just loading the two files
posted. If you have a minimal example showing the pb it would help
to tell you exactly what the pb is.

Sebastien.

On 12/13/2017 03:33 PM, Sean Hardesty wrote:

I was able to compile the polyhedron demo and duplicate the results you described. However, I don't understand how I would test for this in my own program. I generated the .off files I sent from CGAL::Surface_mesh - how do I check whether such an object is a polygon soup (as is done in the demo)?

All of the following look okay:

mesh.is_valid() = 1
CGAL::Polygon_mesh_processing::does_bound_a_volume(mesh) = 1
CGAL::Polygon_mesh_processing::does_self_intersect(mesh) = 0
CGAL::Polygon_mesh_processing::is_outward_oriented(mesh) = 1
CGAL::is_closed(mesh) = 1

I wanted to try something from the polygon soup example, like this

CGAL::Polygon_mesh_processing::is_polygon_soup_a_polygon_mesh

but I haven't been able to figure out how to call that on a CGAL::Surface_mesh object.

     Thanks,
     Sean Hardesty

On Wed, Dec 6, 2017 at 2:24 AM, Sebastien Loriot (GeometryFactory) < <mailto:>> wrote:

    When I open you files in the CGAL polyhedron demo, it is telling me that
    your meshes are polygon soups (meaning you have non-manifold edges).
    If I duplicate those edges to make it a self-intersecting surface
    I have the following set of intersecting faces.

    Sebastien.

    On 12/05/2017 05:22 PM, Sean Hardesty wrote:

        I have a collection of meshes that overlap slightly, so I am
        going through a loop removing overlapping pieces. It works for a
        while, but eventually I run into trouble. I am calling
        PMP::corefine_and_compute_difference(CGAL 4.11) on a pair of
        meshes that satisfy

        !CGAL::Polygon_mesh_processing::does_self_intersect
        CGAL::Polygon_mesh_processing::does_bound_a_volume

        and I get the following:

        terminate called after throwing an instance of
        'CGAL::Assertion_exception'
            what(): CGAL ERROR: assertion violation!
        Expr: hedge!=start
        File:
        /usr/local/include/CGAL/Polygon_mesh_processing/internal/Corefinement/Visitor.h
        Line: 663
        Aborted (core dumped)

        They are fairly small, so I wrote them to .off format and
        attached them to this message. I am aware from your
        documentation pages that there can be problems with sequential
        boolean operations, so I am using the kernel with exact
        predicates and exact constructions. Maybe the precision in the
        .off format is inadequate to diagnose the problem. I would be
        grateful for any help that can be provided.

              Sincerely,
              Sean Hardesty


    --     You are currently subscribed to cgal-discuss.
    To unsubscribe or access the archives, go to
    https://sympa.inria.fr/sympa/info/cgal-discuss

    <https://sympa.inria.fr/sympa/info/cgal-discuss>

--
You are currently subscribed to cgal-discuss.
To unsubscribe or access the archives, go to
https://sympa.inria.fr/sympa/info/cgal-discuss

Attachment: mesh3.off
Description: Binary data

Attachment: mesh4.off
Description: Binary data