CGAL users discussion list

[Claus Volko <>]

I used the attached program and got an error message.

Am Mo., 28. Aug. 2023 um 08:48 Uhr schrieb Sebastien Loriot <>:

I did not have any issue opening the shared file.
Could you please share a minimal example I can compile and that shows
the error so that I can run on my side?

Best,

Sebastien.

On 8/28/23 08:28, Claus Volko ( via cgal-discuss
Mailing List) wrote:
> Yes, I uploaded it to:
> http://www.21stcenturyheadlines.com/temp/Scene_obj.zip
> <http://www.21stcenturyheadlines.com/temp/Scene_obj.zip>
>
> Am Mo., 28. Aug. 2023 um 08:06 Uhr schrieb Sebastien Loriot
> < <mailto:>>:
>
>     Could you share such an obj file that CGAL cannot open?
>
>     Thanks,
>
>     Sebastien.
>
>     On 8/27/23 17:03, Claus Volko (
>     <mailto:> via cgal-discuss
>     Mailing List) wrote:
>      > We are trying to make OBJ files saved from Google Maps HD compatible
>      > with CGAL 5.6 for Shape Detection (Region Growing). On opening
>     the OBJ
>      > file I get an error message that does not explain what is wrong, but
>      > after converting to OFF it is more verbose:
>      >
>      > CGAL::Polyhedron_incremental_builder_3<HDS>::
>      > lookup_halfedge(): input error: facet 49 shares a halfedge from
>     vertex
>      > 145 to vertex 146 with facet 48.
>      >
>      > Polyhedron_scan_OFF<Traits>::
>      > operator()(): input error: facet 50 has fewer than 3 vertices.
>      > ERROR: cannot read the input file!
>      >
>      > I wrote a short program in C# that should fix the problem
>     (attached).
>      > However, the result is a file that is somewhat degenerated: the
>     number
>      > of planes is equal to the number of faces. This cannot be used.
>      >
>      > Does anybody have an idea how else this could be fixed?
>      >
>      > --
>      > Dipl.-Ing. Dr. Claus D. Volko, BSc
>      > http://www.cdvolko.net/ <http://www.cdvolko.net/>
>     <http://www.cdvolko.net/ <http://www.cdvolko.net/>>
>      >
>      >
>      >
>      >
>      > --
>      > 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
>     <https://sympa.inria.fr/sympa/info/cgal-discuss>
>
>
>
>
> --
> Dipl.-Ing. Dr. Claus D. Volko, BSc
> http://www.cdvolko.net/ <http://www.cdvolko.net/>
>
>
>
>
> --
> You are currently subscribed to cgal-discuss.
> To unsubscribe or access the archives, go to
> 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

--

Dipl.-Ing. Dr. Claus D. Volko, BSc
http://www.cdvolko.net/

#define USE_POLYHEDRON

#include <CGAL/Polygon_mesh_processing/clip.h>
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/Polyhedron_3.h>
#include <CGAL/Surface_mesh.h>
#include <CGAL/Shape_detection/Region_growing/Region_growing.h>
#include <CGAL/Shape_detection/Region_growing/Polygon_mesh.h>
#include <CGAL/boost/graph/IO/polygon_mesh_io.h>
#include "include/utils.h"

// Typedefs.
using Kernel  = CGAL::Exact_predicates_inexact_constructions_kernel;
using FT      = typename Kernel::FT;
using Point_3 = typename Kernel::Point_3;

#ifdef USE_POLYHEDRON
using Polygon_mesh   = CGAL::Polyhedron_3<Kernel>;
#else
using Polygon_mesh   = CGAL::Surface_mesh<Point_3>;
#endif

using Neighbor_query = 
CGAL::Shape_detection::Polygon_mesh::One_ring_neighbor_query<Polygon_mesh>;
using Region_type    = 
CGAL::Shape_detection::Polygon_mesh::Least_squares_plane_fit_region<Kernel, 
Polygon_mesh>;
using Sorting        = 
CGAL::Shape_detection::Polygon_mesh::Least_squares_plane_fit_sorting<Kernel, 
Polygon_mesh, Neighbor_query>;
using Region_growing = CGAL::Shape_detection::Region_growing<Neighbor_query, 
Region_type>;

int main(int argc, char *argv[]) {

  // Load data either from a local folder or a user-provided file.
  const bool is_default_input = argc > 1 ? false : true;
  const std::string filename = is_default_input ? 
CGAL::data_file_path("meshes/building.off") : argv[1];
  std::ifstream in(filename);
  CGAL::IO::set_ascii_mode(in);

  Polygon_mesh polygon_mesh;
  if (!CGAL::IO::read_polygon_mesh(filename, polygon_mesh)) {
    std::cerr << "ERROR: cannot read the input file!" << std::endl;
    return EXIT_FAILURE;
  }
  const auto& face_range = faces(polygon_mesh);
  std::cout << "* number of input faces: " << face_range.size() << std::endl;
  assert(!is_default_input || face_range.size() == 32245);

  // Testing the usgae of clip and copy_face_graph (Claus Volko)
  /*
#ifdef USE_POLYHEDRON
  const Kernel::Plane_3& plane = Kernel::Plane_3(CGAL::Point_3<Kernel>(0, 0, 
0),
      CGAL::Point_3<Kernel>(0, 1, 0),
      CGAL::Point_3<Kernel>(1, 1, 0));
  CGAL::Polygon_mesh_processing::clip(polygon_mesh, plane, 
CGAL::parameters::default_values());

  CGAL::Surface_mesh<Point_3> surface_mesh;
  copy_face_graph(polygon_mesh, surface_mesh);
#endif
*/

  // Default parameter values for the data file building.off.
  /*
  const FT          max_distance    = FT(1);
  const FT          max_angle       = FT(45);
  const std::size_t min_region_size = 5;
  */
  const FT          max_distance = FT(10);
  const FT          max_angle = FT(90);
  const std::size_t min_region_size = 1;

  // Create instances of the classes Neighbor_query and Region_type.
  Neighbor_query neighbor_query(polygon_mesh);

  Region_type region_type(
    polygon_mesh,
    CGAL::parameters::
    maximum_distance(max_distance).
    maximum_angle(max_angle).
    minimum_region_size(min_region_size));

  // Sort face indices.
  Sorting sorting(
    polygon_mesh, neighbor_query);
  sorting.sort();

  // Create an instance of the region growing class.
  Region_growing region_growing(
    face_range, sorting.ordered(), neighbor_query, region_type);

  // Run the algorithm.
  std::vector<typename Region_growing::Primitive_and_region> regions;
  region_growing.detect(std::back_inserter(regions));
  std::cout << "* number of found planes: " << regions.size() << std::endl;
  assert(!is_default_input || regions.size() == 365);

  const Region_growing::Region_map& map = region_growing.region_map();

  for (std::size_t i = 0; i < regions.size(); i++)
    for (auto& item : regions[i].second) {
      if (i != get(map, item)) {
        std::cout << "Region map incorrect" << std::endl;
      }
    }

  std::vector<typename Region_growing::Item> unassigned;
  region_growing.unassigned_items(face_range, std::back_inserter(unassigned));

  for (auto& item : unassigned) {
    if (std::size_t(-1) != get(map, item)) {
      std::cout << "Region map for unassigned incorrect" << std::endl;
    }
  }

  // Save regions to a file.
  const std::string fullpath = (argc > 2 ? argv[2] : 
"planes_polygon_mesh.ply");
  utils::save_polygon_mesh_regions(polygon_mesh, regions, fullpath);

  return EXIT_SUCCESS;
}