340 lines
14 KiB
C++
340 lines
14 KiB
C++
// Copyright (c) 2017 GeometryFactory
|
|
//
|
|
// This file is part of CGAL (www.cgal.org)
|
|
//
|
|
// $URL: https://github.com/CGAL/cgal/blob/v5.1/Polyhedron_IO/include/CGAL/IO/PLY_reader.h $
|
|
// $Id: PLY_reader.h 0779373 2020-03-26T13:31:46+01:00 Sébastien Loriot
|
|
// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial
|
|
//
|
|
// Author(s) : Simon Giraudot
|
|
|
|
#ifndef CGAL_IO_PLY_READER_H
|
|
#define CGAL_IO_PLY_READER_H
|
|
|
|
#include <CGAL/IO/PLY.h>
|
|
|
|
namespace CGAL{
|
|
|
|
namespace internal
|
|
{
|
|
template <typename Integer, class Polygon_3, class Color_rgb>
|
|
bool
|
|
read_PLY_faces (std::istream& in,
|
|
internal::PLY::PLY_element& element,
|
|
std::vector< Polygon_3 >& polygons,
|
|
std::vector< Color_rgb >& fcolors,
|
|
const char* vertex_indices_tag)
|
|
{
|
|
bool has_colors = false;
|
|
std::string rtag = "r", gtag = "g", btag = "b";
|
|
if ((element.has_property<boost::uint8_t>("red") || element.has_property<boost::uint8_t>("r")) &&
|
|
(element.has_property<boost::uint8_t>("green") || element.has_property<boost::uint8_t>("g")) &&
|
|
(element.has_property<boost::uint8_t>("blue") || element.has_property<boost::uint8_t>("b")))
|
|
{
|
|
has_colors = true;
|
|
if (element.has_property<boost::uint8_t>("red"))
|
|
{
|
|
rtag = "red"; gtag = "green"; btag = "blue";
|
|
}
|
|
}
|
|
|
|
for (std::size_t j = 0; j < element.number_of_items(); ++ j)
|
|
{
|
|
for (std::size_t k = 0; k < element.number_of_properties(); ++ k)
|
|
{
|
|
internal::PLY::PLY_read_number* property = element.property(k);
|
|
property->get (in);
|
|
|
|
if (in.fail())
|
|
return false;
|
|
}
|
|
|
|
std::tuple<std::vector<Integer>, boost::uint8_t, boost::uint8_t, boost::uint8_t> new_face;
|
|
|
|
if (has_colors)
|
|
{
|
|
PLY::process_properties (element, new_face,
|
|
std::make_pair (CGAL::make_nth_of_tuple_property_map<0>(new_face),
|
|
PLY_property<std::vector<Integer> >(vertex_indices_tag)),
|
|
std::make_pair (CGAL::make_nth_of_tuple_property_map<1>(new_face),
|
|
PLY_property<boost::uint8_t>(rtag.c_str())),
|
|
std::make_pair (CGAL::make_nth_of_tuple_property_map<2>(new_face),
|
|
PLY_property<boost::uint8_t>(gtag.c_str())),
|
|
std::make_pair (CGAL::make_nth_of_tuple_property_map<3>(new_face),
|
|
PLY_property<boost::uint8_t>(btag.c_str())));
|
|
|
|
fcolors.push_back (Color_rgb (get<1>(new_face), get<2>(new_face), get<3>(new_face)));
|
|
}
|
|
else
|
|
PLY::process_properties (element, new_face,
|
|
std::make_pair (CGAL::make_nth_of_tuple_property_map<0>(new_face),
|
|
PLY_property<std::vector<Integer> >(vertex_indices_tag)));
|
|
|
|
polygons.push_back (Polygon_3(get<0>(new_face).size()));
|
|
for (std::size_t i = 0; i < get<0>(new_face).size(); ++ i)
|
|
polygons.back()[i] = std::size_t(get<0>(new_face)[i]);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
template <class Point_3, class Polygon_3>
|
|
bool
|
|
read_PLY( std::istream& in,
|
|
std::vector< Point_3 >& points,
|
|
std::vector< Polygon_3 >& polygons,
|
|
bool /* verbose */ = false)
|
|
{
|
|
if(!in)
|
|
{
|
|
std::cerr << "Error: cannot open file" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
internal::PLY::PLY_reader reader;
|
|
|
|
if (!(reader.init (in)))
|
|
{
|
|
in.setstate(std::ios::failbit);
|
|
return false;
|
|
}
|
|
|
|
for (std::size_t i = 0; i < reader.number_of_elements(); ++ i)
|
|
{
|
|
internal::PLY::PLY_element& element = reader.element(i);
|
|
|
|
if (element.name() == "vertex" || element.name() == "vertices")
|
|
{
|
|
for (std::size_t j = 0; j < element.number_of_items(); ++ j)
|
|
{
|
|
for (std::size_t k = 0; k < element.number_of_properties(); ++ k)
|
|
{
|
|
internal::PLY::PLY_read_number* property = element.property(k);
|
|
property->get (in);
|
|
|
|
if (in.fail())
|
|
return false;
|
|
}
|
|
|
|
Point_3 new_vertex;
|
|
|
|
internal::PLY::process_properties (element, new_vertex,
|
|
make_ply_point_reader (CGAL::Identity_property_map<Point_3>()));
|
|
|
|
points.push_back (get<0>(new_vertex));
|
|
}
|
|
}
|
|
else if (element.name() == "face" || element.name() == "faces")
|
|
{
|
|
std::vector<CGAL::Color> dummy;
|
|
|
|
if (element.has_property<std::vector<boost::int32_t> > ("vertex_indices"))
|
|
internal::read_PLY_faces<boost::int32_t> (in, element, polygons, dummy, "vertex_indices");
|
|
else if (element.has_property<std::vector<boost::uint32_t> > ("vertex_indices"))
|
|
internal::read_PLY_faces<boost::uint32_t> (in, element, polygons, dummy, "vertex_indices");
|
|
else if (element.has_property<std::vector<boost::int32_t> > ("vertex_index"))
|
|
internal::read_PLY_faces<boost::int32_t> (in, element, polygons, dummy, "vertex_index");
|
|
else if (element.has_property<std::vector<boost::uint32_t> > ("vertex_index"))
|
|
internal::read_PLY_faces<boost::uint32_t> (in, element, polygons, dummy, "vertex_index");
|
|
else
|
|
{
|
|
std::cerr << "Error: can't find vertex indices in PLY input" << std::endl;
|
|
return false;
|
|
}
|
|
}
|
|
else // Read other elements and ignore
|
|
{
|
|
for (std::size_t j = 0; j < element.number_of_items(); ++ j)
|
|
{
|
|
for (std::size_t k = 0; k < element.number_of_properties(); ++ k)
|
|
{
|
|
internal::PLY::PLY_read_number* property = element.property(k);
|
|
property->get (in);
|
|
|
|
if (in.fail())
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return !in.bad();
|
|
}
|
|
|
|
template <class Point_3, class Polygon_3, class Color_rgb>
|
|
bool
|
|
read_PLY( std::istream& in,
|
|
std::vector< Point_3 >& points,
|
|
std::vector< Polygon_3 >& polygons,
|
|
std::vector<std::pair<unsigned int, unsigned int> >& hedges,
|
|
std::vector<Color_rgb>& fcolors,
|
|
std::vector<Color_rgb>& vcolors,
|
|
std::vector<std::pair<float, float> >& huvs,
|
|
bool /* verbose */ = false)
|
|
{
|
|
if(!in)
|
|
{
|
|
std::cerr << "Error: cannot open file" << std::endl;
|
|
return false;
|
|
}
|
|
internal::PLY::PLY_reader reader;
|
|
|
|
if (!(reader.init (in)))
|
|
{
|
|
in.setstate(std::ios::failbit);
|
|
return false;
|
|
}
|
|
for (std::size_t i = 0; i < reader.number_of_elements(); ++ i)
|
|
{
|
|
internal::PLY::PLY_element& element = reader.element(i);
|
|
|
|
if (element.name() == "vertex" || element.name() == "vertices")
|
|
{
|
|
bool has_colors = false;
|
|
std::string rtag = "r", gtag = "g", btag = "b";
|
|
if ((element.has_property<boost::uint8_t>("red") || element.has_property<boost::uint8_t>("r")) &&
|
|
(element.has_property<boost::uint8_t>("green") || element.has_property<boost::uint8_t>("g")) &&
|
|
(element.has_property<boost::uint8_t>("blue") || element.has_property<boost::uint8_t>("b")))
|
|
{
|
|
has_colors = true;
|
|
if (element.has_property<boost::uint8_t>("red"))
|
|
{
|
|
rtag = "red"; gtag = "green"; btag = "blue";
|
|
}
|
|
}
|
|
|
|
for (std::size_t j = 0; j < element.number_of_items(); ++ j)
|
|
{
|
|
for (std::size_t k = 0; k < element.number_of_properties(); ++ k)
|
|
{
|
|
internal::PLY::PLY_read_number* property = element.property(k);
|
|
property->get (in);
|
|
|
|
if (in.fail())
|
|
return false;
|
|
}
|
|
|
|
std::tuple<Point_3, boost::uint8_t, boost::uint8_t, boost::uint8_t> new_vertex;
|
|
|
|
if (has_colors)
|
|
{
|
|
internal::PLY::process_properties (element, new_vertex,
|
|
make_ply_point_reader (CGAL::make_nth_of_tuple_property_map<0>(new_vertex)),
|
|
std::make_pair (CGAL::make_nth_of_tuple_property_map<1>(new_vertex),
|
|
PLY_property<boost::uint8_t>(rtag.c_str())),
|
|
std::make_pair (CGAL::make_nth_of_tuple_property_map<2>(new_vertex),
|
|
PLY_property<boost::uint8_t>(gtag.c_str())),
|
|
std::make_pair (CGAL::make_nth_of_tuple_property_map<3>(new_vertex),
|
|
PLY_property<boost::uint8_t>(btag.c_str())));
|
|
|
|
vcolors.push_back (Color_rgb (get<1>(new_vertex), get<2>(new_vertex), get<3>(new_vertex)));
|
|
}
|
|
else
|
|
internal::PLY::process_properties (element, new_vertex,
|
|
make_ply_point_reader (CGAL::make_nth_of_tuple_property_map<0>(new_vertex)));
|
|
|
|
points.push_back (get<0>(new_vertex));
|
|
}
|
|
}
|
|
else if (element.name() == "face" || element.name() == "faces")
|
|
{
|
|
if (element.has_property<std::vector<boost::int32_t> > ("vertex_indices"))
|
|
internal::read_PLY_faces<boost::int32_t> (in, element, polygons, fcolors, "vertex_indices");
|
|
else if (element.has_property<std::vector<boost::uint32_t> > ("vertex_indices"))
|
|
internal::read_PLY_faces<boost::uint32_t> (in, element, polygons, fcolors, "vertex_indices");
|
|
else if (element.has_property<std::vector<boost::int32_t> > ("vertex_index"))
|
|
internal::read_PLY_faces<boost::int32_t> (in, element, polygons, fcolors, "vertex_index");
|
|
else if (element.has_property<std::vector<boost::uint32_t> > ("vertex_index"))
|
|
internal::read_PLY_faces<boost::uint32_t> (in, element, polygons, fcolors, "vertex_index");
|
|
else
|
|
{
|
|
std::cerr << "Error: can't find vertex indices in PLY input" << std::endl;
|
|
return false;
|
|
}
|
|
}
|
|
else if(element.name() == "halfedge" )
|
|
{
|
|
bool has_uv = false;
|
|
std::string stag = "source", ttag = "target", utag = "u", vtag = "v";
|
|
if ( element.has_property<unsigned int>("source") &&
|
|
element.has_property<unsigned int>("target") &&
|
|
element.has_property<float>("u") &&
|
|
element.has_property<float>("v"))
|
|
{
|
|
has_uv = true;
|
|
}
|
|
std::tuple<unsigned int, unsigned int, float, float, float> new_hedge;
|
|
for (std::size_t j = 0; j < element.number_of_items(); ++ j)
|
|
{
|
|
for (std::size_t k = 0; k < element.number_of_properties(); ++ k)
|
|
{
|
|
internal::PLY::PLY_read_number* property = element.property(k);
|
|
property->get (in);
|
|
|
|
if (in.eof())
|
|
return false;
|
|
}
|
|
|
|
if (has_uv)
|
|
{
|
|
internal::PLY::process_properties (element, new_hedge,
|
|
std::make_pair (CGAL::make_nth_of_tuple_property_map<0>(new_hedge),
|
|
PLY_property<unsigned int>(stag.c_str())),
|
|
std::make_pair (CGAL::make_nth_of_tuple_property_map<1>(new_hedge),
|
|
PLY_property<unsigned int>(ttag.c_str())),
|
|
std::make_pair (CGAL::make_nth_of_tuple_property_map<2>(new_hedge),
|
|
PLY_property<float>(utag.c_str())),
|
|
std::make_pair (CGAL::make_nth_of_tuple_property_map<3>(new_hedge),
|
|
PLY_property<float>(vtag.c_str())));
|
|
hedges.push_back (std::make_pair(get<0>(new_hedge), get<1>(new_hedge)));
|
|
huvs.push_back (std::make_pair(get<2>(new_hedge), get<3>(new_hedge)));
|
|
}
|
|
else
|
|
internal::PLY::process_properties (element, new_hedge,
|
|
std::make_pair(CGAL::make_nth_of_tuple_property_map<0>(new_hedge),
|
|
PLY_property<unsigned int>(stag.c_str())),
|
|
std::make_pair(CGAL::make_nth_of_tuple_property_map<1>(new_hedge),
|
|
PLY_property<unsigned int>(ttag.c_str()))
|
|
);
|
|
}
|
|
}
|
|
else // Read other elements and ignore
|
|
{
|
|
for (std::size_t j = 0; j < element.number_of_items(); ++ j)
|
|
{
|
|
for (std::size_t k = 0; k < element.number_of_properties(); ++ k)
|
|
{
|
|
internal::PLY::PLY_read_number* property = element.property(k);
|
|
property->get (in);
|
|
if (in.fail())
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return !in.bad();
|
|
}
|
|
|
|
template <class Point_3, class Polygon_3, class Color_rgb>
|
|
bool
|
|
read_PLY( std::istream& in,
|
|
std::vector< Point_3 >& points,
|
|
std::vector< Polygon_3 >& polygons,
|
|
std::vector<Color_rgb>& fcolors,
|
|
std::vector<Color_rgb>& vcolors,
|
|
bool /* verbose */ = false)
|
|
{
|
|
std::vector<std::pair<unsigned int, unsigned int> > dummy_pui;
|
|
std::vector<std::pair<float, float> > dummy_pf;
|
|
return read_PLY<Point_3, Polygon_3, Color_rgb>(in, points, polygons,
|
|
dummy_pui,
|
|
fcolors, vcolors,
|
|
dummy_pf);
|
|
}
|
|
} // namespace CGAL
|
|
|
|
#endif // CGAL_IO_PLY_READER_H
|