973 lines
30 KiB
C
973 lines
30 KiB
C
|
// Copyright (c) 2015 Geometry Factory
|
||
|
|
// All rights reserved.
|
||
|
|
//
|
||
|
|
// This file is part of CGAL (www.cgal.org)
|
||
|
|
//
|
||
|
|
// $URL: https://github.com/CGAL/cgal/blob/v5.1/Stream_support/include/CGAL/IO/PLY.h $
|
||
|
|
// $Id: PLY.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_H
|
||
|
|
#define CGAL_IO_PLY_H
|
||
|
|
|
||
|
|
#include <CGAL/Kernel_traits.h>
|
||
|
|
#include <CGAL/IO/io.h>
|
||
|
|
#include <CGAL/property_map.h>
|
||
|
|
|
||
|
|
#include <boost/cstdint.hpp>
|
||
|
|
|
||
|
|
#include <iostream>
|
||
|
|
#include <sstream>
|
||
|
|
#include <string>
|
||
|
|
#include <tuple>
|
||
|
|
#include <utility>
|
||
|
|
#include <vector>
|
||
|
|
|
||
|
|
#define TRY_TO_GENERATE_PROPERTY(STD_TYPE, T_TYPE, TYPE) \
|
||
|
|
if (type == STD_TYPE || type == T_TYPE) \
|
||
|
|
m_elements.back().add_property (new PLY_read_typed_number< TYPE > (name, format))
|
||
|
|
|
||
|
|
#define TRY_TO_GENERATE_SIZED_LIST_PROPERTY(STD_SIZE_TYPE, T_SIZE_TYPE, SIZE_TYPE, STD_INDEX_TYPE, T_INDEX_TYPE, INDEX_TYPE) \
|
||
|
|
if ((size_type == STD_SIZE_TYPE || size_type == T_SIZE_TYPE) && \
|
||
|
|
(index_type == STD_INDEX_TYPE || index_type == T_INDEX_TYPE)) \
|
||
|
|
m_elements.back().add_property (new PLY_read_typed_list_with_typed_size< SIZE_TYPE , INDEX_TYPE > (name, format))
|
||
|
|
|
||
|
|
#define TRY_TO_GENERATE_LIST_PROPERTY(STD_INDEX_TYPE, T_INDEX_TYPE, INDEX_TYPE) \
|
||
|
|
TRY_TO_GENERATE_SIZED_LIST_PROPERTY("uchar", "uint8", boost::uint8_t, STD_INDEX_TYPE, T_INDEX_TYPE, INDEX_TYPE); \
|
||
|
|
else TRY_TO_GENERATE_SIZED_LIST_PROPERTY("ushort", "uint16", boost::uint16_t, STD_INDEX_TYPE, T_INDEX_TYPE, INDEX_TYPE); \
|
||
|
|
else TRY_TO_GENERATE_SIZED_LIST_PROPERTY("uint", "uint32", boost::uint32_t, STD_INDEX_TYPE, T_INDEX_TYPE, INDEX_TYPE)
|
||
|
|
|
||
|
|
|
||
|
|
/// \cond SKIP_IN_MANUAL
|
||
|
|
|
||
|
|
namespace CGAL {
|
||
|
|
|
||
|
|
// PLY types:
|
||
|
|
// name type number of bytes
|
||
|
|
// ---------------------------------------
|
||
|
|
// char character 1
|
||
|
|
// uchar unsigned character 1
|
||
|
|
// short short integer 2
|
||
|
|
// ushort unsigned short integer 2
|
||
|
|
// int integer 4
|
||
|
|
// uint unsigned integer 4
|
||
|
|
// float single-precision float 4
|
||
|
|
// double double-precision float 8
|
||
|
|
|
||
|
|
template <typename T>
|
||
|
|
struct PLY_property
|
||
|
|
{
|
||
|
|
typedef T type;
|
||
|
|
const char* name;
|
||
|
|
PLY_property (const char* name) : name (name) { }
|
||
|
|
};
|
||
|
|
|
||
|
|
// Use a double property for all kernels...
|
||
|
|
template <typename FT> struct Convert_FT { typedef double type; };
|
||
|
|
// ...except if kernel uses type float
|
||
|
|
template <> struct Convert_FT<float> { typedef float type; };
|
||
|
|
|
||
|
|
template <typename PointOrVectorMap>
|
||
|
|
struct Get_FT_from_map
|
||
|
|
{
|
||
|
|
typedef typename Convert_FT
|
||
|
|
<typename Kernel_traits
|
||
|
|
<typename boost::property_traits
|
||
|
|
<PointOrVectorMap>::value_type>::Kernel::FT>::type type;
|
||
|
|
};
|
||
|
|
|
||
|
|
template <typename PointMap>
|
||
|
|
std::tuple<PointMap,
|
||
|
|
typename Kernel_traits<typename PointMap::value_type>::Kernel::Construct_point_3,
|
||
|
|
PLY_property<typename Get_FT_from_map<PointMap>::type>,
|
||
|
|
PLY_property<typename Get_FT_from_map<PointMap>::type>,
|
||
|
|
PLY_property<typename Get_FT_from_map<PointMap>::type> >
|
||
|
|
make_ply_point_reader(PointMap point_map)
|
||
|
|
{
|
||
|
|
return std::make_tuple (point_map, typename Kernel_traits<typename PointMap::value_type>::Kernel::Construct_point_3(),
|
||
|
|
PLY_property<typename Get_FT_from_map<PointMap>::type>("x"),
|
||
|
|
PLY_property<typename Get_FT_from_map<PointMap>::type>("y"),
|
||
|
|
PLY_property<typename Get_FT_from_map<PointMap>::type>("z"));
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename VectorMap>
|
||
|
|
std::tuple<VectorMap,
|
||
|
|
typename Kernel_traits<typename VectorMap::value_type>::Kernel::Construct_vector_3,
|
||
|
|
PLY_property<typename Get_FT_from_map<VectorMap>::type>,
|
||
|
|
PLY_property<typename Get_FT_from_map<VectorMap>::type>,
|
||
|
|
PLY_property<typename Get_FT_from_map<VectorMap>::type> >
|
||
|
|
make_ply_normal_reader(VectorMap normal_map)
|
||
|
|
{
|
||
|
|
return std::make_tuple (normal_map, typename Kernel_traits<typename VectorMap::value_type>::Kernel::Construct_vector_3(),
|
||
|
|
PLY_property<typename Get_FT_from_map<VectorMap>::type>("nx"),
|
||
|
|
PLY_property<typename Get_FT_from_map<VectorMap>::type>("ny"),
|
||
|
|
PLY_property<typename Get_FT_from_map<VectorMap>::type>("nz"));
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename PointMap>
|
||
|
|
std::tuple<PointMap,
|
||
|
|
PLY_property<typename Get_FT_from_map<PointMap>::type>,
|
||
|
|
PLY_property<typename Get_FT_from_map<PointMap>::type>,
|
||
|
|
PLY_property<typename Get_FT_from_map<PointMap>::type> >
|
||
|
|
make_ply_point_writer(PointMap point_map)
|
||
|
|
{
|
||
|
|
return std::make_tuple (point_map,
|
||
|
|
PLY_property<typename Get_FT_from_map<PointMap>::type>("x"),
|
||
|
|
PLY_property<typename Get_FT_from_map<PointMap>::type>("y"),
|
||
|
|
PLY_property<typename Get_FT_from_map<PointMap>::type>("z"));
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename VectorMap>
|
||
|
|
std::tuple<VectorMap,
|
||
|
|
PLY_property<typename Get_FT_from_map<VectorMap>::type>,
|
||
|
|
PLY_property<typename Get_FT_from_map<VectorMap>::type>,
|
||
|
|
PLY_property<typename Get_FT_from_map<VectorMap>::type> >
|
||
|
|
make_ply_normal_writer(VectorMap normal_map)
|
||
|
|
{
|
||
|
|
return std::make_tuple (normal_map,
|
||
|
|
PLY_property<typename Get_FT_from_map<VectorMap>::type>("nx"),
|
||
|
|
PLY_property<typename Get_FT_from_map<VectorMap>::type>("ny"),
|
||
|
|
PLY_property<typename Get_FT_from_map<VectorMap>::type>("nz"));
|
||
|
|
}
|
||
|
|
|
||
|
|
namespace internal {
|
||
|
|
|
||
|
|
namespace PLY {
|
||
|
|
|
||
|
|
class PLY_read_number
|
||
|
|
{
|
||
|
|
protected:
|
||
|
|
std::string m_name;
|
||
|
|
std::size_t m_format;
|
||
|
|
|
||
|
|
public:
|
||
|
|
PLY_read_number (std::string name, std::size_t format)
|
||
|
|
: m_name (name), m_format (format) { }
|
||
|
|
virtual ~PLY_read_number() { }
|
||
|
|
|
||
|
|
const std::string& name () const { return m_name; }
|
||
|
|
|
||
|
|
virtual void get (std::istream& stream) const = 0;
|
||
|
|
|
||
|
|
// The two following functions prevent the stream to only extract
|
||
|
|
// ONE character (= what the types char imply) by requiring
|
||
|
|
// explicitely an integer object when reading the stream
|
||
|
|
void read_ascii (std::istream& stream, char& c) const
|
||
|
|
{
|
||
|
|
short s;
|
||
|
|
stream >> s;
|
||
|
|
c = static_cast<char>(s);
|
||
|
|
}
|
||
|
|
void read_ascii (std::istream& stream, signed char& c) const
|
||
|
|
{
|
||
|
|
short s;
|
||
|
|
stream >> s;
|
||
|
|
c = static_cast<signed char>(s);
|
||
|
|
}
|
||
|
|
void read_ascii (std::istream& stream, unsigned char& c) const
|
||
|
|
{
|
||
|
|
unsigned short s;
|
||
|
|
stream >> s;
|
||
|
|
c = static_cast<unsigned char>(s);
|
||
|
|
}
|
||
|
|
|
||
|
|
void read_ascii (std::istream& stream, float& t) const
|
||
|
|
{
|
||
|
|
stream >> iformat(t);
|
||
|
|
}
|
||
|
|
|
||
|
|
void read_ascii (std::istream& stream, double& t) const
|
||
|
|
{
|
||
|
|
stream >> iformat(t);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Default template when Type is not a char type
|
||
|
|
template <typename Type>
|
||
|
|
void read_ascii (std::istream& stream, Type& t) const
|
||
|
|
{
|
||
|
|
stream >> t;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
template <typename Type>
|
||
|
|
Type read (std::istream& stream) const
|
||
|
|
{
|
||
|
|
if (m_format == 0) // Ascii
|
||
|
|
{
|
||
|
|
Type t;
|
||
|
|
read_ascii (stream, t);
|
||
|
|
return t;
|
||
|
|
}
|
||
|
|
else // Binary (2 = little endian)
|
||
|
|
{
|
||
|
|
union
|
||
|
|
{
|
||
|
|
char uChar[sizeof (Type)];
|
||
|
|
Type type;
|
||
|
|
} buffer;
|
||
|
|
|
||
|
|
std::size_t size = sizeof (Type);
|
||
|
|
|
||
|
|
stream.read(buffer.uChar, size);
|
||
|
|
|
||
|
|
if (m_format == 2) // Big endian
|
||
|
|
{
|
||
|
|
for (std::size_t i = 0; i < size / 2; ++ i)
|
||
|
|
{
|
||
|
|
unsigned char tmp = buffer.uChar[i];
|
||
|
|
buffer.uChar[i] = buffer.uChar[size - 1 - i];
|
||
|
|
buffer.uChar[size - 1 - i] = tmp;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return buffer.type;
|
||
|
|
}
|
||
|
|
return Type();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
template <typename Type>
|
||
|
|
class PLY_read_typed_number : public PLY_read_number
|
||
|
|
{
|
||
|
|
mutable Type m_buffer;
|
||
|
|
public:
|
||
|
|
PLY_read_typed_number (std::string name, std::size_t format)
|
||
|
|
: PLY_read_number (name, format)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
void get (std::istream& stream) const
|
||
|
|
{
|
||
|
|
m_buffer = (this->read<Type> (stream));
|
||
|
|
}
|
||
|
|
const Type& buffer() const
|
||
|
|
{
|
||
|
|
return m_buffer;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
template <typename Type>
|
||
|
|
class PLY_read_typed_list : public PLY_read_number
|
||
|
|
{
|
||
|
|
protected:
|
||
|
|
mutable std::vector<Type> m_buffer;
|
||
|
|
public:
|
||
|
|
PLY_read_typed_list (std::string name, std::size_t format)
|
||
|
|
: PLY_read_number (name, format)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
virtual void get (std::istream& stream) const = 0;
|
||
|
|
|
||
|
|
const std::vector<Type>& buffer() const
|
||
|
|
{
|
||
|
|
return m_buffer;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
template <typename SizeType, typename IndexType>
|
||
|
|
class PLY_read_typed_list_with_typed_size
|
||
|
|
: public PLY_read_typed_list<IndexType>
|
||
|
|
{
|
||
|
|
|
||
|
|
public:
|
||
|
|
PLY_read_typed_list_with_typed_size (std::string name, std::size_t format)
|
||
|
|
: PLY_read_typed_list<IndexType> (name, format)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
void get (std::istream& stream) const
|
||
|
|
{
|
||
|
|
std::size_t size = static_cast<std::size_t>(this->template read<SizeType>(stream));
|
||
|
|
this->m_buffer.resize (size);
|
||
|
|
for (std::size_t i = 0; i < size; ++ i)
|
||
|
|
this->m_buffer[i] = this->template read<IndexType> (stream);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
class PLY_element
|
||
|
|
{
|
||
|
|
std::string m_name;
|
||
|
|
std::size_t m_number;
|
||
|
|
|
||
|
|
std::vector<PLY_read_number*> m_properties;
|
||
|
|
public:
|
||
|
|
|
||
|
|
PLY_element (const std::string& name, std::size_t number)
|
||
|
|
: m_name (name), m_number (number)
|
||
|
|
{ }
|
||
|
|
|
||
|
|
PLY_element (const PLY_element& other)
|
||
|
|
: m_name (other.m_name), m_number (other.m_number), m_properties (other.m_properties)
|
||
|
|
{
|
||
|
|
const_cast<PLY_element&>(other).m_properties.clear();
|
||
|
|
}
|
||
|
|
|
||
|
|
PLY_element& operator= (const PLY_element& other)
|
||
|
|
{
|
||
|
|
m_name = other.m_name;
|
||
|
|
m_number = other.m_number;
|
||
|
|
m_properties = other.m_properties;
|
||
|
|
const_cast<PLY_element&>(other).m_properties.clear();
|
||
|
|
return *this;
|
||
|
|
}
|
||
|
|
|
||
|
|
~PLY_element()
|
||
|
|
{
|
||
|
|
for (std::size_t i = 0; i < m_properties.size(); ++ i)
|
||
|
|
delete m_properties[i];
|
||
|
|
}
|
||
|
|
|
||
|
|
const std::string& name() const { return m_name; }
|
||
|
|
std::size_t number_of_items() const { return m_number; }
|
||
|
|
std::size_t number_of_properties() const { return m_properties.size(); }
|
||
|
|
|
||
|
|
PLY_read_number* property (std::size_t idx) { return m_properties[idx]; }
|
||
|
|
|
||
|
|
void add_property (PLY_read_number* read_number)
|
||
|
|
{
|
||
|
|
m_properties.push_back (read_number);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename Type>
|
||
|
|
bool has_property (const char* tag)
|
||
|
|
{
|
||
|
|
return has_property (tag, Type());
|
||
|
|
}
|
||
|
|
template <typename Type>
|
||
|
|
bool has_property (const char* tag, const std::vector<Type>&)
|
||
|
|
{
|
||
|
|
for (std::size_t i = 0; i < number_of_properties(); ++ i)
|
||
|
|
if (m_properties[i]->name () == tag)
|
||
|
|
return (dynamic_cast<PLY_read_typed_list<Type>*>(m_properties[i]) != nullptr);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename Type>
|
||
|
|
bool has_property (const char* tag, Type)
|
||
|
|
{
|
||
|
|
for (std::size_t i = 0; i < number_of_properties(); ++ i)
|
||
|
|
if (m_properties[i]->name () == tag)
|
||
|
|
return (dynamic_cast<PLY_read_typed_number<Type>*>(m_properties[i]) != nullptr);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
bool has_property (const char* tag, double)
|
||
|
|
{
|
||
|
|
for (std::size_t i = 0; i < number_of_properties(); ++ i)
|
||
|
|
if (m_properties[i]->name () == tag)
|
||
|
|
return (dynamic_cast<PLY_read_typed_number<double>*>(m_properties[i]) != nullptr
|
||
|
|
|| dynamic_cast<PLY_read_typed_number<float>*>(m_properties[i]) != nullptr);
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename Type>
|
||
|
|
void assign (Type& t, const char* tag)
|
||
|
|
{
|
||
|
|
for (std::size_t i = 0; i < number_of_properties (); ++ i)
|
||
|
|
if (m_properties[i]->name () == tag)
|
||
|
|
{
|
||
|
|
PLY_read_typed_number<Type>*
|
||
|
|
property = dynamic_cast<PLY_read_typed_number<Type>*>(m_properties[i]);
|
||
|
|
CGAL_assertion (property != nullptr);
|
||
|
|
t = property->buffer();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
t = {};
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename Type>
|
||
|
|
void assign (std::vector<Type>& t, const char* tag)
|
||
|
|
{
|
||
|
|
for (std::size_t i = 0; i < number_of_properties (); ++ i)
|
||
|
|
if (m_properties[i]->name () == tag)
|
||
|
|
{
|
||
|
|
PLY_read_typed_list<Type>*
|
||
|
|
property = dynamic_cast<PLY_read_typed_list<Type>*>(m_properties[i]);
|
||
|
|
CGAL_assertion (property != nullptr);
|
||
|
|
t = property->buffer();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
t = {};
|
||
|
|
}
|
||
|
|
|
||
|
|
void assign (double& t, const char* tag)
|
||
|
|
{
|
||
|
|
for (std::size_t i = 0; i < number_of_properties (); ++ i)
|
||
|
|
if (m_properties[i]->name () == tag)
|
||
|
|
{
|
||
|
|
PLY_read_typed_number<double>*
|
||
|
|
property_double = dynamic_cast<PLY_read_typed_number<double>*>(m_properties[i]);
|
||
|
|
if (property_double == nullptr)
|
||
|
|
{
|
||
|
|
PLY_read_typed_number<float>*
|
||
|
|
property_float = dynamic_cast<PLY_read_typed_number<float>*>(m_properties[i]);
|
||
|
|
CGAL_assertion (property_float != nullptr);
|
||
|
|
t = property_float->buffer();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
t = property_double->buffer();
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
t = {};
|
||
|
|
}
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
class PLY_reader
|
||
|
|
{
|
||
|
|
std::vector<PLY_element> m_elements;
|
||
|
|
std::string m_comments;
|
||
|
|
|
||
|
|
public:
|
||
|
|
PLY_reader () { }
|
||
|
|
|
||
|
|
std::size_t number_of_elements() const { return m_elements.size(); }
|
||
|
|
PLY_element& element (std::size_t idx)
|
||
|
|
{
|
||
|
|
return m_elements[idx];
|
||
|
|
}
|
||
|
|
|
||
|
|
const std::string& comments() const { return m_comments; }
|
||
|
|
|
||
|
|
template <typename Stream>
|
||
|
|
bool init (Stream& stream)
|
||
|
|
{
|
||
|
|
std::size_t lineNumber = 0; // current line number
|
||
|
|
enum Format { ASCII = 0, BINARY_LITTLE_ENDIAN = 1, BINARY_BIG_ENDIAN = 2};
|
||
|
|
Format format = ASCII;
|
||
|
|
|
||
|
|
std::string line;
|
||
|
|
std::istringstream iss;
|
||
|
|
|
||
|
|
while (getline (stream,line))
|
||
|
|
{
|
||
|
|
iss.clear();
|
||
|
|
iss.str (line);
|
||
|
|
++ lineNumber;
|
||
|
|
|
||
|
|
// Reads file signature on first line
|
||
|
|
if (lineNumber == 1)
|
||
|
|
{
|
||
|
|
std::string signature;
|
||
|
|
if (!(iss >> signature) || (signature != "ply"))
|
||
|
|
{
|
||
|
|
// if wrong file format
|
||
|
|
std::cerr << "Error: incorrect file format line " << lineNumber << " of file" << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Reads format on 2nd line
|
||
|
|
else if (lineNumber == 2)
|
||
|
|
{
|
||
|
|
std::string tag, format_string, version;
|
||
|
|
if ( !(iss >> tag >> format_string >> version) )
|
||
|
|
{
|
||
|
|
std::cerr << "Error line " << lineNumber << " of file" << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (format_string == "ascii") format = ASCII;
|
||
|
|
else if (format_string == "binary_little_endian") format = BINARY_LITTLE_ENDIAN;
|
||
|
|
else if (format_string == "binary_big_endian") format = BINARY_BIG_ENDIAN;
|
||
|
|
else
|
||
|
|
{
|
||
|
|
std::cerr << "Error: unknown file format \"" << format_string << "\" line " << lineNumber << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Comments and vertex properties
|
||
|
|
else
|
||
|
|
{
|
||
|
|
std::string keyword;
|
||
|
|
if (!(iss >> keyword))
|
||
|
|
{
|
||
|
|
std::cerr << "Error line " << lineNumber << " of file" << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (keyword == "property")
|
||
|
|
{
|
||
|
|
std::string type, name;
|
||
|
|
if (!(iss >> type >> name))
|
||
|
|
{
|
||
|
|
std::cerr << "Error line " << lineNumber << " of file" << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
if (type == "list") // Special case
|
||
|
|
{
|
||
|
|
std::string size_type = name;
|
||
|
|
std::string index_type;
|
||
|
|
name.clear();
|
||
|
|
if (!(iss >> index_type >> name))
|
||
|
|
{
|
||
|
|
std::cerr << "Error line " << lineNumber << " of file" << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
TRY_TO_GENERATE_LIST_PROPERTY ("char", "int8", boost::int8_t);
|
||
|
|
else TRY_TO_GENERATE_LIST_PROPERTY ("uchar", "uint8", boost::uint8_t);
|
||
|
|
else TRY_TO_GENERATE_LIST_PROPERTY ("short", "int16", boost::int16_t);
|
||
|
|
else TRY_TO_GENERATE_LIST_PROPERTY ("ushort", "uint16", boost::uint16_t);
|
||
|
|
else TRY_TO_GENERATE_LIST_PROPERTY ("int", "int32", boost::int32_t);
|
||
|
|
else TRY_TO_GENERATE_LIST_PROPERTY ("uint", "uint32", boost::uint32_t);
|
||
|
|
else TRY_TO_GENERATE_LIST_PROPERTY ("float", "float32", float);
|
||
|
|
else TRY_TO_GENERATE_LIST_PROPERTY ("double", "float64", double);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
TRY_TO_GENERATE_PROPERTY ("char", "int8", boost::int8_t);
|
||
|
|
else TRY_TO_GENERATE_PROPERTY ("uchar", "uint8", boost::uint8_t);
|
||
|
|
else TRY_TO_GENERATE_PROPERTY ("short", "int16", boost::int16_t);
|
||
|
|
else TRY_TO_GENERATE_PROPERTY ("ushort", "uint16", boost::uint16_t);
|
||
|
|
else TRY_TO_GENERATE_PROPERTY ("int", "int32", boost::int32_t);
|
||
|
|
else TRY_TO_GENERATE_PROPERTY ("uint", "uint32", boost::uint32_t);
|
||
|
|
else TRY_TO_GENERATE_PROPERTY ("float", "float32", float);
|
||
|
|
else TRY_TO_GENERATE_PROPERTY ("double", "float64", double);
|
||
|
|
}
|
||
|
|
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
else if (keyword == "comment")
|
||
|
|
{
|
||
|
|
std::string str = iss.str();
|
||
|
|
if (str.size() > 8)
|
||
|
|
{
|
||
|
|
std::copy (str.begin() + 8, str.end(), std::back_inserter (m_comments));
|
||
|
|
m_comments += "\n";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (keyword == "element")
|
||
|
|
{
|
||
|
|
std::string type;
|
||
|
|
std::size_t number;
|
||
|
|
if (!(iss >> type >> number))
|
||
|
|
{
|
||
|
|
std::cerr << "Error line " << lineNumber << " of file" << std::endl;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_elements.push_back (PLY_element(type, number));
|
||
|
|
}
|
||
|
|
// When end_header is reached, stop loop and begin reading points
|
||
|
|
else if (keyword == "end_header")
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
~PLY_reader ()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
template <class Reader, class T>
|
||
|
|
void get_value(Reader& r, T& v, PLY_property<T>& wrapper)
|
||
|
|
{
|
||
|
|
return r.assign(v, wrapper.name);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
template <std::size_t N>
|
||
|
|
struct Filler
|
||
|
|
{
|
||
|
|
template <class Reader, class Value_tuple, class PLY_property_tuple>
|
||
|
|
static void fill(Reader& r, Value_tuple& values, PLY_property_tuple wrappers)
|
||
|
|
{
|
||
|
|
get_value(r, std::get<N>(values), std::get<N+2>(wrappers));
|
||
|
|
Filler<N-1>::fill(r, values, wrappers);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
template<int ...>
|
||
|
|
struct seq { };
|
||
|
|
|
||
|
|
template<int N, int ...S>
|
||
|
|
struct gens : gens<N-1, N-1, S...> { };
|
||
|
|
|
||
|
|
template<int ...S>
|
||
|
|
struct gens<0, S...> {
|
||
|
|
typedef seq<S...> type;
|
||
|
|
};
|
||
|
|
|
||
|
|
template<class ValueType, class Functor, class Tuple, int ...S>
|
||
|
|
ValueType call_functor(Functor f, Tuple t, seq<S...>) {
|
||
|
|
return f(std::get<S>(t) ...);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class ValueType, class Functor, typename ... T>
|
||
|
|
ValueType call_functor(Functor f, std::tuple<T...>& t)
|
||
|
|
{
|
||
|
|
return call_functor<ValueType>(f, t, typename gens<sizeof...(T)>::type());
|
||
|
|
}
|
||
|
|
|
||
|
|
template<>
|
||
|
|
struct Filler<0>
|
||
|
|
{
|
||
|
|
template <class Reader, class Value_tuple, class PLY_property_tuple>
|
||
|
|
static void fill(Reader& r, Value_tuple& values, PLY_property_tuple wrappers)
|
||
|
|
{
|
||
|
|
get_value(r, std::get<0>(values), std::get<2>(wrappers));
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
template <typename OutputValueType,
|
||
|
|
typename PropertyMap,
|
||
|
|
typename Constructor,
|
||
|
|
typename ... T>
|
||
|
|
void process_properties (PLY_element& element, OutputValueType& new_element,
|
||
|
|
std::tuple<PropertyMap, Constructor, PLY_property<T>...>&& current)
|
||
|
|
{
|
||
|
|
typedef typename PropertyMap::value_type PmapValueType;
|
||
|
|
std::tuple<T...> values;
|
||
|
|
Filler<sizeof...(T)-1>::fill(element, values, current);
|
||
|
|
PmapValueType new_value = call_functor<PmapValueType>(std::get<1>(current), values);
|
||
|
|
put (std::get<0>(current), new_element, new_value);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename OutputValueType,
|
||
|
|
typename PropertyMap,
|
||
|
|
typename Constructor,
|
||
|
|
typename ... T,
|
||
|
|
typename NextPropertyBinder,
|
||
|
|
typename ... PropertyMapBinders>
|
||
|
|
void process_properties (PLY_element& element, OutputValueType& new_element,
|
||
|
|
std::tuple<PropertyMap, Constructor, PLY_property<T>...>&& current,
|
||
|
|
NextPropertyBinder&& next,
|
||
|
|
PropertyMapBinders&& ... properties)
|
||
|
|
{
|
||
|
|
typedef typename PropertyMap::value_type PmapValueType;
|
||
|
|
std::tuple<T...> values;
|
||
|
|
Filler<sizeof...(T)-1>::fill(element, values, current);
|
||
|
|
PmapValueType new_value = call_functor<PmapValueType>(std::get<1>(current), values);
|
||
|
|
put (std::get<0>(current), new_element, new_value);
|
||
|
|
|
||
|
|
process_properties (element, new_element, std::forward<NextPropertyBinder>(next),
|
||
|
|
std::forward<PropertyMapBinders>(properties)...);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
template <typename OutputValueType, typename PropertyMap, typename T>
|
||
|
|
void process_properties (PLY_element& element, OutputValueType& new_element,
|
||
|
|
std::pair<PropertyMap, PLY_property<T> >&& current)
|
||
|
|
{
|
||
|
|
T new_value = T();
|
||
|
|
element.assign (new_value, current.second.name);
|
||
|
|
put (current.first, new_element, new_value);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename OutputValueType, typename PropertyMap, typename T,
|
||
|
|
typename NextPropertyBinder, typename ... PropertyMapBinders>
|
||
|
|
void process_properties (PLY_element& element, OutputValueType& new_element,
|
||
|
|
std::pair<PropertyMap, PLY_property<T> >&& current,
|
||
|
|
NextPropertyBinder&& next,
|
||
|
|
PropertyMapBinders&& ... properties)
|
||
|
|
{
|
||
|
|
T new_value = T();
|
||
|
|
element.assign (new_value, current.second.name);
|
||
|
|
put (current.first, new_element, new_value);
|
||
|
|
process_properties (element, new_element, std::forward<NextPropertyBinder>(next),
|
||
|
|
std::forward<PropertyMapBinders>(properties)...);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename T> inline void property_header_type (std::ostream& stream)
|
||
|
|
{
|
||
|
|
CGAL_assertion_msg (false, "Unknown PLY type");
|
||
|
|
stream << "undefined_type";
|
||
|
|
}
|
||
|
|
|
||
|
|
template <> inline void property_header_type<char> (std::ostream& stream) { stream << "char"; }
|
||
|
|
template <> inline void property_header_type<signed char> (std::ostream& stream) { stream << "char"; }
|
||
|
|
template <> inline void property_header_type<unsigned char> (std::ostream& stream) { stream << "uchar"; }
|
||
|
|
template <> inline void property_header_type<short> (std::ostream& stream) { stream << "short"; }
|
||
|
|
template <> inline void property_header_type<unsigned short> (std::ostream& stream) { stream << "ushort"; }
|
||
|
|
template <> inline void property_header_type<int> (std::ostream& stream) { stream << "int"; }
|
||
|
|
template <> inline void property_header_type<unsigned int> (std::ostream& stream) { stream << "uint"; }
|
||
|
|
template <> inline void property_header_type<float> (std::ostream& stream) { stream << "float"; }
|
||
|
|
template <> inline void property_header_type<double> (std::ostream& stream) { stream << "double"; }
|
||
|
|
|
||
|
|
template <typename T>
|
||
|
|
void property_header (std::ostream& stream, const PLY_property<T>& prop)
|
||
|
|
{
|
||
|
|
stream << "property ";
|
||
|
|
property_header_type<T>(stream);
|
||
|
|
stream << " " << prop.name << std::endl;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename T>
|
||
|
|
void property_header (std::ostream& stream, const PLY_property<std::vector<T> >& prop)
|
||
|
|
{
|
||
|
|
stream << "property list uchar ";
|
||
|
|
property_header_type<T>(stream);
|
||
|
|
stream << " " << prop.name << std::endl;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
template <std::size_t N>
|
||
|
|
struct Properties_header
|
||
|
|
{
|
||
|
|
template <class PLY_property_tuple>
|
||
|
|
static void write(std::ostream& stream, PLY_property_tuple& wrappers)
|
||
|
|
{
|
||
|
|
Properties_header<N-1>::write(stream, wrappers);
|
||
|
|
property_header (stream, std::get<N+1>(wrappers));
|
||
|
|
}
|
||
|
|
};
|
||
|
|
template <>
|
||
|
|
struct Properties_header<0>
|
||
|
|
{
|
||
|
|
template <class PLY_property_tuple>
|
||
|
|
static void write(std::ostream& stream, PLY_property_tuple& wrappers)
|
||
|
|
{
|
||
|
|
property_header (stream, std::get<1>(wrappers));
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
template <typename PropertyMap,
|
||
|
|
typename ... T>
|
||
|
|
void output_property_header (std::ostream& stream,
|
||
|
|
std::tuple<PropertyMap, PLY_property<T>... >&& current)
|
||
|
|
{
|
||
|
|
Properties_header<sizeof...(T)-1>::write(stream, current);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
template <typename PropertyMap,
|
||
|
|
typename T>
|
||
|
|
void output_property_header (std::ostream& stream,
|
||
|
|
std::pair<PropertyMap, PLY_property<T> >&& current)
|
||
|
|
{
|
||
|
|
property_header (stream, current.second);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename PropertyMap,
|
||
|
|
typename T,
|
||
|
|
typename NextPropertyHandler,
|
||
|
|
typename ... PropertyHandler>
|
||
|
|
void output_property_header (std::ostream& stream,
|
||
|
|
std::pair<PropertyMap, PLY_property<T> >&& current,
|
||
|
|
NextPropertyHandler&& next,
|
||
|
|
PropertyHandler&& ... properties)
|
||
|
|
{
|
||
|
|
property_header (stream, current.second);
|
||
|
|
output_property_header (stream, std::forward<NextPropertyHandler>(next),
|
||
|
|
std::forward<PropertyHandler>(properties)...);
|
||
|
|
}
|
||
|
|
template <typename PropertyMap,
|
||
|
|
typename ... T,
|
||
|
|
typename NextPropertyHandler,
|
||
|
|
typename ... PropertyHandler>
|
||
|
|
void output_property_header (std::ostream& stream,
|
||
|
|
std::tuple<PropertyMap, PLY_property<T>... >&& current,
|
||
|
|
NextPropertyHandler&& next,
|
||
|
|
PropertyHandler&& ... properties)
|
||
|
|
{
|
||
|
|
Properties_header<sizeof...(T)-1>::write(stream, current);
|
||
|
|
output_property_header (stream, std::forward<NextPropertyHandler>(next),
|
||
|
|
std::forward<PropertyHandler>(properties)...);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
template <typename ForwardIterator,
|
||
|
|
typename PropertyMap>
|
||
|
|
void property_write (std::ostream& stream, ForwardIterator it, PropertyMap map)
|
||
|
|
{
|
||
|
|
stream << CGAL::oformat(get (map, *it));
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename T>
|
||
|
|
inline T no_char_character (const T& t) { return t; }
|
||
|
|
inline int no_char_character (const char& t) { return int(t); }
|
||
|
|
inline int no_char_character (const signed char& t) { return int(t); }
|
||
|
|
inline int no_char_character (const unsigned char& t) { return int(t); }
|
||
|
|
|
||
|
|
template <typename ForwardIterator,
|
||
|
|
typename PropertyMap,
|
||
|
|
typename T>
|
||
|
|
void simple_property_write (std::ostream& stream, ForwardIterator it,
|
||
|
|
std::pair<PropertyMap, PLY_property<T> > map)
|
||
|
|
{
|
||
|
|
if (CGAL::get_mode(stream) == IO::ASCII)
|
||
|
|
stream << no_char_character(get (map.first, *it));
|
||
|
|
else
|
||
|
|
{
|
||
|
|
typename PropertyMap::value_type value = get(map.first, *it);
|
||
|
|
stream.write (reinterpret_cast<char*>(&value), sizeof(value));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename ForwardIterator,
|
||
|
|
typename PropertyMap,
|
||
|
|
typename T>
|
||
|
|
void simple_property_write (std::ostream& stream, ForwardIterator it,
|
||
|
|
std::pair<PropertyMap, PLY_property<std::vector<T> > > map)
|
||
|
|
{
|
||
|
|
const typename PropertyMap::reference value = get(map.first, *it);
|
||
|
|
|
||
|
|
if (CGAL::get_mode(stream) == IO::ASCII)
|
||
|
|
{
|
||
|
|
stream << value.size();
|
||
|
|
for (std::size_t i = 0; i < value.size(); ++ i)
|
||
|
|
stream << " " << no_char_character(value[i]);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
unsigned char size = static_cast<unsigned char>(value.size());
|
||
|
|
stream.write (reinterpret_cast<char*>(&size), sizeof(size));
|
||
|
|
for (std::size_t i = 0; i < value.size(); ++ i)
|
||
|
|
{
|
||
|
|
T t = T(value[i]);
|
||
|
|
stream.write (reinterpret_cast<char*>(&t), sizeof(t));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
template <typename ForwardIterator,
|
||
|
|
typename PropertyMap,
|
||
|
|
typename ... T>
|
||
|
|
void output_properties (std::ostream& stream,
|
||
|
|
ForwardIterator it,
|
||
|
|
std::tuple<PropertyMap, PLY_property<T>... >&& current)
|
||
|
|
{
|
||
|
|
property_write (stream, it, std::get<0>(current));
|
||
|
|
if (get_mode(stream) == IO::ASCII)
|
||
|
|
stream << std::endl;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
template <typename ForwardIterator,
|
||
|
|
typename PropertyMap,
|
||
|
|
typename T>
|
||
|
|
void output_properties (std::ostream& stream,
|
||
|
|
ForwardIterator it,
|
||
|
|
std::pair<PropertyMap, PLY_property<T> >&& current)
|
||
|
|
{
|
||
|
|
simple_property_write (stream, it, std::forward<std::pair<PropertyMap, PLY_property<T> > >(current));
|
||
|
|
if (get_mode(stream) == IO::ASCII)
|
||
|
|
stream << std::endl;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename ForwardIterator,
|
||
|
|
typename PropertyMap,
|
||
|
|
typename T,
|
||
|
|
typename NextPropertyHandler,
|
||
|
|
typename ... PropertyHandler>
|
||
|
|
void output_properties (std::ostream& stream,
|
||
|
|
ForwardIterator it,
|
||
|
|
std::pair<PropertyMap, PLY_property<T> >&& current,
|
||
|
|
NextPropertyHandler&& next,
|
||
|
|
PropertyHandler&& ... properties)
|
||
|
|
{
|
||
|
|
simple_property_write (stream, it, current);
|
||
|
|
if (get_mode(stream) == IO::ASCII)
|
||
|
|
stream << " ";
|
||
|
|
output_properties (stream, it, std::forward<NextPropertyHandler>(next),
|
||
|
|
std::forward<PropertyHandler>(properties)...);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename ForwardIterator,
|
||
|
|
typename PropertyMap,
|
||
|
|
typename ... T,
|
||
|
|
typename NextPropertyHandler,
|
||
|
|
typename ... PropertyHandler>
|
||
|
|
void output_properties (std::ostream& stream,
|
||
|
|
ForwardIterator it,
|
||
|
|
std::tuple<PropertyMap, PLY_property<T>... >&& current,
|
||
|
|
NextPropertyHandler&& next,
|
||
|
|
PropertyHandler&& ... properties)
|
||
|
|
{
|
||
|
|
property_write (stream, it, std::get<0>(current));
|
||
|
|
if (get_mode(stream) == IO::ASCII)
|
||
|
|
stream << " ";
|
||
|
|
output_properties (stream, it, std::forward<NextPropertyHandler>(next),
|
||
|
|
std::forward<PropertyHandler>(properties)...);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// Printer classes used by Point_set_3 and Surface_mesh (translate a
|
||
|
|
// property map to a PLY property)
|
||
|
|
|
||
|
|
template <typename Index>
|
||
|
|
class Abstract_property_printer
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
virtual ~Abstract_property_printer() { }
|
||
|
|
virtual void print (std::ostream& stream, const Index& index) = 0;
|
||
|
|
};
|
||
|
|
|
||
|
|
template <typename Index, typename PropertyMap>
|
||
|
|
class Property_printer : public Abstract_property_printer<Index>
|
||
|
|
{
|
||
|
|
PropertyMap m_pmap;
|
||
|
|
public:
|
||
|
|
Property_printer (const PropertyMap& pmap) : m_pmap (pmap)
|
||
|
|
{
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void print(std::ostream& stream, const Index& index)
|
||
|
|
{
|
||
|
|
stream << get(m_pmap, index);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
template <typename Index, typename PropertyMap,
|
||
|
|
typename Type = typename PropertyMap::value_type>
|
||
|
|
class Simple_property_printer : public Abstract_property_printer<Index>
|
||
|
|
{
|
||
|
|
PropertyMap m_pmap;
|
||
|
|
public:
|
||
|
|
Simple_property_printer (const PropertyMap& pmap) : m_pmap (pmap)
|
||
|
|
{
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void print(std::ostream& stream, const Index& index)
|
||
|
|
{
|
||
|
|
if (get_mode(stream) == IO::ASCII)
|
||
|
|
stream << get(m_pmap, index);
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Type t = Type(get (m_pmap, index));
|
||
|
|
stream.write (reinterpret_cast<char*>(&t), sizeof(t));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
template <typename Index, typename PropertyMap>
|
||
|
|
class Char_property_printer : public Abstract_property_printer<Index>
|
||
|
|
{
|
||
|
|
typedef typename PropertyMap::value_type Type;
|
||
|
|
PropertyMap m_pmap;
|
||
|
|
public:
|
||
|
|
Char_property_printer (const PropertyMap& pmap) : m_pmap (pmap)
|
||
|
|
{
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void print(std::ostream& stream, const Index& index)
|
||
|
|
{
|
||
|
|
if (get_mode(stream) == IO::ASCII)
|
||
|
|
stream << int(get(m_pmap, index));
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Type t = get (m_pmap, index);
|
||
|
|
stream.write (reinterpret_cast<char*>(&t), sizeof(t));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
} // namespace PLY
|
||
|
|
|
||
|
|
} // namespace internal
|
||
|
|
|
||
|
|
} // namespace CGAL
|
||
|
|
|
||
|
|
|
||
|
|
#endif // CGAL_IO_PLY_H
|