CGAL users discussion list

["Sebastien Loriot (GeometryFactory)" <>]

OK let's try the following:

after
bool result = 
CGAL::Polygon_mesh_processing::corefine_and_compute_difference(mesh[je], 
mesh[ie], mesh[je]);

Add:
{
std::ofstream otmp("/tmp/out.off");
otmp << std::setprecision(17) << mesh[je];
otmp.close();
std::ifstream itmp("/tmp/out.off");
std::vector<Point_3> pts;
std::vector< CGAL::cpp11::array<int, 3> > polygons;
CGAL::read_OFF(itmp, pts,  polygons);
if 
(!CGAL::Polygon_mesh_processing::is_polygon_soup_a_polygon_mesh(polygons))
{
  std::cout << "BOOM!\n";
  exit(1);
}
}

Then send me with precision 17 mesh[je] and mesh[ie] before the call to 
the function.

Sebastien.

PS: I haven't try to compile it so it's up to typos...


On 12/14/2017 04:09 AM, Sean Hardesty wrote:
> 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) 
> < <mailto:>> 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:>
>  
> <mailto:
>         
> <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>
>              <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
>     <https://sympa.inria.fr/sympa/info/cgal-discuss>