mirror of https://github.com/CGAL/cgal
Integrate File_scanner_OFF_impl into the header
This commit is contained in:
Mael Rouxel-Labbé
parent
b4862c2361
commit
1edf1e066c
|
|
@ -14,18 +14,20 @@
|
|||
//
|
||||
// Author(s) : Lutz Kettner <kettner@mpi-sb.mpg.de>
|
||||
|
||||
|
||||
#ifndef CGAL_IO_OFF_FILE_HEADER_OFF_H
|
||||
#define CGAL_IO_OFF_FILE_HEADER_OFF_H 1
|
||||
#define CGAL_IO_OFF_FILE_HEADER_OFF_H
|
||||
|
||||
#include <CGAL/IO/OFF/File_header_extended_OFF.h>
|
||||
|
||||
#include <iostream>
|
||||
|
||||
namespace CGAL {
|
||||
|
||||
// Info structure for OFF file headers
|
||||
// ===================================
|
||||
class CGAL_EXPORT File_header_OFF : public File_header_extended_OFF {
|
||||
class CGAL_EXPORT File_header_OFF
|
||||
: public File_header_extended_OFF
|
||||
{
|
||||
private:
|
||||
// Publicly accessible file informations.
|
||||
std::size_t n_vertices;
|
||||
|
|
@ -43,29 +45,28 @@ private:
|
|||
bool m_tag4; // 4OFF detected.
|
||||
bool m_tagDim; // nOFF detected (will not be supported).
|
||||
int m_dim; // dimension for nOFF (will not be supported).
|
||||
|
||||
public:
|
||||
typedef File_header_OFF Self;
|
||||
typedef File_header_extended_OFF Base;
|
||||
|
||||
explicit File_header_OFF( bool verbose = false);
|
||||
File_header_OFF( bool binary, bool noc, bool skel,
|
||||
bool verbose = false);
|
||||
//File_header_OFF( int v, int h, int f, bool verbose = false);
|
||||
File_header_OFF( std::size_t v, std::size_t h, std::size_t f,
|
||||
bool binary, bool noc, bool skel,
|
||||
bool verbose = false);
|
||||
File_header_OFF( const File_header_extended_OFF& ext_header);
|
||||
File_header_OFF( const File_header_extended_OFF& ext_header,
|
||||
explicit File_header_OFF(bool verbose = false);
|
||||
File_header_OFF(bool binary, bool noc, bool skel, bool verbose = false);
|
||||
//File_header_OFF(int v, int h, int f, bool verbose = false);
|
||||
File_header_OFF(std::size_t v, std::size_t h, std::size_t f,
|
||||
bool binary, bool noc, bool skel, bool verbose = false);
|
||||
|
||||
File_header_OFF(const File_header_extended_OFF& ext_header);
|
||||
File_header_OFF(const File_header_extended_OFF& ext_header,
|
||||
bool binary, bool noc, bool skel);
|
||||
File_header_OFF( std::size_t v, std::size_t h, std::size_t f,
|
||||
File_header_OFF(std::size_t v, std::size_t h, std::size_t f,
|
||||
const File_header_extended_OFF& ext_header);
|
||||
File_header_OFF( std::size_t v, std::size_t h, std::size_t f,
|
||||
File_header_OFF(std::size_t v, std::size_t h, std::size_t f,
|
||||
const File_header_extended_OFF& ext_header,
|
||||
bool binary, bool noc, bool skel);
|
||||
|
||||
Self& operator= ( const Base& base) { (Base&)(*this) = base;
|
||||
return *this;
|
||||
}
|
||||
Self& operator= (const Base& base) { (Base&)(*this) = base; return *this; }
|
||||
|
||||
std::size_t size_of_vertices() const { return n_vertices; }
|
||||
std::size_t size_of_facets() const { return n_facets; }
|
||||
|
||||
|
|
@ -80,32 +81,33 @@ public:
|
|||
bool has_colors() const { return m_colors; } // COFF detected.
|
||||
bool has_normals() const { return m_normals;} // NOFF format.
|
||||
bool is_homogeneous() const { return m_tag4; } // 4OFF detected.
|
||||
|
||||
// nOFF detected. (will not be supported).
|
||||
bool n_dimensional() const { return m_tagDim; }
|
||||
// dimension for nOFF (will not be supported).
|
||||
int dimension() const { return m_dim; }
|
||||
|
||||
void set_vertices( std::size_t n) { n_vertices = n; }
|
||||
void set_facets( std::size_t n) { n_facets = n; }
|
||||
void set_vertices(std::size_t n) { n_vertices = n; }
|
||||
void set_facets(std::size_t n) { n_facets = n; }
|
||||
|
||||
void set_skel( bool b) { m_skel = b; }
|
||||
void set_binary( bool b) { m_binary = b; }
|
||||
void set_no_comments( bool b) { m_no_comments = b; }
|
||||
void set_index_offset( std::size_t i) { m_offset = i; }
|
||||
void set_skel(bool b) { m_skel = b; }
|
||||
void set_binary(bool b) { m_binary = b; }
|
||||
void set_no_comments(bool b) { m_no_comments = b; }
|
||||
void set_index_offset(std::size_t i) { m_offset = i; }
|
||||
|
||||
void set_colors( bool b) { m_colors = b; }
|
||||
void set_normals( bool b) { m_normals = b;}
|
||||
void set_homogeneous( bool b) { m_tag4 = b; }
|
||||
void set_dimensional( bool b) { m_tagDim = b; }
|
||||
void set_dimension( int i) { m_dim = i; }
|
||||
Self& operator+=( const Self& header);
|
||||
void set_colors(bool b) { m_colors = b; }
|
||||
void set_normals(bool b) { m_normals = b;}
|
||||
void set_homogeneous(bool b) { m_tag4 = b; }
|
||||
void set_dimensional(bool b) { m_tagDim = b; }
|
||||
void set_dimension(int i) { m_dim = i; }
|
||||
Self& operator+=(const Self& header);
|
||||
};
|
||||
|
||||
// Write header.
|
||||
CGAL_EXPORT std::ostream& operator<<( std::ostream& out, const File_header_OFF& h);
|
||||
CGAL_EXPORT std::ostream& operator<<(std::ostream& out, const File_header_OFF& h);
|
||||
|
||||
// Scan header. Marks streams badbit if not in SKEL format nor in OFF.
|
||||
CGAL_EXPORT std::istream& operator>>( std::istream& in, File_header_OFF& h);
|
||||
CGAL_EXPORT std::istream& operator>>(std::istream& in, File_header_OFF& h);
|
||||
|
||||
} //namespace CGAL
|
||||
|
||||
|
|
|
|||
|
|
@ -15,55 +15,65 @@
|
|||
// Author(s) : Lutz Kettner <kettner@mpi-sb.mpg.de>
|
||||
|
||||
#ifndef CGAL_IO_OFF_FILE_SCANNER_OFF_H
|
||||
#define CGAL_IO_OFF_FILE_SCANNER_OFF_H 1
|
||||
|
||||
#include <CGAL/disable_warnings.h>
|
||||
#define CGAL_IO_OFF_FILE_SCANNER_OFF_H
|
||||
|
||||
#include <CGAL/config.h>
|
||||
#include <cstddef>
|
||||
#include <CGAL/IO/binary_file_io.h>
|
||||
#include <CGAL/IO/OFF/File_header_OFF.h>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
|
||||
#include <CGAL/Point_3.h>
|
||||
#include <CGAL/Vector_3.h>
|
||||
#include <cstddef>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
|
||||
namespace CGAL {
|
||||
|
||||
class CGAL_EXPORT File_scanner_OFF : public File_header_OFF {
|
||||
class File_scanner_OFF
|
||||
: public File_header_OFF
|
||||
{
|
||||
std::istream& m_in;
|
||||
bool normals_read;
|
||||
|
||||
void skip_comment() { m_in >> skip_comment_OFF; }
|
||||
|
||||
public:
|
||||
File_scanner_OFF( std::istream& in, bool verbose = false)
|
||||
: File_header_OFF(verbose), m_in(in), normals_read(false) {
|
||||
in >> static_cast<File_header_OFF&>( *this);
|
||||
File_scanner_OFF(std::istream& in, bool verbose = false)
|
||||
: File_header_OFF(verbose), m_in(in), normals_read(false)
|
||||
{
|
||||
in >> static_cast<File_header_OFF&>(*this);
|
||||
}
|
||||
File_scanner_OFF( std::istream& in, const File_header_OFF& header)
|
||||
: File_header_OFF(header), m_in(in), normals_read(false) {}
|
||||
|
||||
File_scanner_OFF(std::istream& in, const File_header_OFF& header)
|
||||
:
|
||||
File_header_OFF(header), m_in(in), normals_read(false)
|
||||
{ }
|
||||
|
||||
std::istream& in() { return m_in; }
|
||||
|
||||
// The scan_vertex() routine is provided for multiple
|
||||
// coordinate types to support parameterized polytopes.
|
||||
void scan_vertex( float& x, float& y, float& z) {
|
||||
if ( binary()) {
|
||||
I_Binary_read_big_endian_float32( m_in, x);
|
||||
I_Binary_read_big_endian_float32( m_in, y);
|
||||
I_Binary_read_big_endian_float32( m_in, z);
|
||||
if ( is_homogeneous()) {
|
||||
void scan_vertex(float& x, float& y, float& z)
|
||||
{
|
||||
if(binary())
|
||||
{
|
||||
I_Binary_read_big_endian_float32(m_in, x);
|
||||
I_Binary_read_big_endian_float32(m_in, y);
|
||||
I_Binary_read_big_endian_float32(m_in, z);
|
||||
if(is_homogeneous()) {
|
||||
float w;
|
||||
I_Binary_read_big_endian_float32( m_in, w);
|
||||
I_Binary_read_big_endian_float32(m_in, w);
|
||||
x /= w;
|
||||
y /= w;
|
||||
z /= w;
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
skip_comment();
|
||||
m_in >> iformat(x) >> iformat(y) >> iformat(z);
|
||||
if ( is_homogeneous()) {
|
||||
if(is_homogeneous())
|
||||
{
|
||||
float w;
|
||||
m_in >> iformat(w);
|
||||
x /= w;
|
||||
|
|
@ -72,25 +82,32 @@ public:
|
|||
}
|
||||
}
|
||||
}
|
||||
void scan_vertex( double& x, double& y, double& z) {
|
||||
if ( binary()) {
|
||||
|
||||
void scan_vertex(double& x, double& y, double& z)
|
||||
{
|
||||
if(binary())
|
||||
{
|
||||
float f;
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
x = f;
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
y = f;
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
z = f;
|
||||
if ( is_homogeneous()) {
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
if(is_homogeneous())
|
||||
{
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
x /= f;
|
||||
y /= f;
|
||||
z /= f;
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
skip_comment();
|
||||
m_in >> iformat(x) >> iformat(y) >> iformat(z);
|
||||
if ( is_homogeneous()) {
|
||||
if(is_homogeneous())
|
||||
{
|
||||
double w;
|
||||
m_in >> iformat(w);
|
||||
x /= w;
|
||||
|
|
@ -99,32 +116,40 @@ public:
|
|||
}
|
||||
}
|
||||
}
|
||||
void scan_vertex( int& x, int& y, int& z) {
|
||||
if ( binary()) {
|
||||
|
||||
void scan_vertex(int& x, int& y, int& z)
|
||||
{
|
||||
if(binary())
|
||||
{
|
||||
float fx, fy, fz;
|
||||
I_Binary_read_big_endian_float32( m_in, fx);
|
||||
I_Binary_read_big_endian_float32( m_in, fy);
|
||||
I_Binary_read_big_endian_float32( m_in, fz);
|
||||
if ( is_homogeneous()) {
|
||||
I_Binary_read_big_endian_float32(m_in, fx);
|
||||
I_Binary_read_big_endian_float32(m_in, fy);
|
||||
I_Binary_read_big_endian_float32(m_in, fz);
|
||||
if(is_homogeneous()) {
|
||||
float fw;
|
||||
I_Binary_read_big_endian_float32( m_in, fw);
|
||||
x = int( fx / fw);
|
||||
y = int( fy / fw);
|
||||
z = int( fz / fw);
|
||||
I_Binary_read_big_endian_float32(m_in, fw);
|
||||
x = int(fx / fw);
|
||||
y = int(fy / fw);
|
||||
z = int(fz / fw);
|
||||
} else {
|
||||
x = int(fx);
|
||||
y = int(fy);
|
||||
z = int(fz);
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
skip_comment();
|
||||
if ( is_homogeneous()) {
|
||||
if(is_homogeneous())
|
||||
{
|
||||
double fx, fy, fz, fw;
|
||||
m_in >> iformat(fx) >> iformat(fy) >> iformat(fz) >> iformat(fw);
|
||||
x = int( fx / fw);
|
||||
y = int( fy / fw);
|
||||
z = int( fz / fw);
|
||||
} else {
|
||||
x = int(fx / fw);
|
||||
y = int(fy / fw);
|
||||
z = int(fz / fw);
|
||||
}
|
||||
else
|
||||
{
|
||||
double d;
|
||||
m_in >> iformat(d);
|
||||
x = int(d);
|
||||
|
|
@ -136,59 +161,74 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
void scan_vertex( float& x, float& y, float& z, float& w) {
|
||||
void scan_vertex(float& x, float& y, float& z, float& w)
|
||||
{
|
||||
w = 1;
|
||||
if ( binary()) {
|
||||
I_Binary_read_big_endian_float32( m_in, x);
|
||||
I_Binary_read_big_endian_float32( m_in, y);
|
||||
I_Binary_read_big_endian_float32( m_in, z);
|
||||
if ( is_homogeneous())
|
||||
I_Binary_read_big_endian_float32( m_in, w);
|
||||
} else {
|
||||
if(binary())
|
||||
{
|
||||
I_Binary_read_big_endian_float32(m_in, x);
|
||||
I_Binary_read_big_endian_float32(m_in, y);
|
||||
I_Binary_read_big_endian_float32(m_in, z);
|
||||
if(is_homogeneous())
|
||||
I_Binary_read_big_endian_float32(m_in, w);
|
||||
}
|
||||
else
|
||||
{
|
||||
skip_comment();
|
||||
m_in >> iformat(x) >> iformat(y) >> iformat(z);
|
||||
if ( is_homogeneous())
|
||||
if(is_homogeneous())
|
||||
m_in >> iformat(w);
|
||||
}
|
||||
}
|
||||
void scan_vertex( double& x, double& y, double& z, double& w) {
|
||||
void scan_vertex(double& x, double& y, double& z, double& w)
|
||||
{
|
||||
w = 1;
|
||||
if ( binary()) {
|
||||
if(binary())
|
||||
{
|
||||
float f;
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
x = f;
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
y = f;
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
z = f;
|
||||
if ( is_homogeneous()) {
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
if(is_homogeneous())
|
||||
{
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
w = f;
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
skip_comment();
|
||||
m_in >> iformat(x);
|
||||
m_in >> iformat(y);
|
||||
m_in >> iformat(z);
|
||||
if ( is_homogeneous())
|
||||
if(is_homogeneous())
|
||||
m_in >> iformat(w);
|
||||
}
|
||||
}
|
||||
void scan_vertex( int& x, int& y, int& z, int& w) {
|
||||
|
||||
void scan_vertex(int& x, int& y, int& z, int& w)
|
||||
{
|
||||
w = 1;
|
||||
if ( binary()) {
|
||||
if(binary())
|
||||
{
|
||||
float f;
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
x = int(f);
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
y = int(f);
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
z = int(f);
|
||||
if ( is_homogeneous()) {
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
if(is_homogeneous())
|
||||
{
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
w = int(f);
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
skip_comment();
|
||||
double d;
|
||||
m_in >> iformat(d);
|
||||
|
|
@ -197,30 +237,37 @@ public:
|
|||
y = int(d);
|
||||
m_in >> iformat(d);
|
||||
z = int(d);
|
||||
if ( is_homogeneous()) {
|
||||
if(is_homogeneous())
|
||||
{
|
||||
m_in >> iformat(d);
|
||||
w = int(d);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void scan_normal( float& x, float& y, float& z) {
|
||||
if ( has_normals()) {
|
||||
void scan_normal(float& x, float& y, float& z)
|
||||
{
|
||||
if(has_normals())
|
||||
{
|
||||
normals_read = true;
|
||||
if ( binary()) {
|
||||
I_Binary_read_big_endian_float32( m_in, x);
|
||||
I_Binary_read_big_endian_float32( m_in, y);
|
||||
I_Binary_read_big_endian_float32( m_in, z);
|
||||
if ( is_homogeneous()) {
|
||||
if(binary()) {
|
||||
I_Binary_read_big_endian_float32(m_in, x);
|
||||
I_Binary_read_big_endian_float32(m_in, y);
|
||||
I_Binary_read_big_endian_float32(m_in, z);
|
||||
if(is_homogeneous())
|
||||
{
|
||||
float w;
|
||||
I_Binary_read_big_endian_float32( m_in, w);
|
||||
I_Binary_read_big_endian_float32(m_in, w);
|
||||
x /= w;
|
||||
y /= w;
|
||||
z /= w;
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
m_in >> iformat(x) >> iformat(y) >> iformat(z);
|
||||
if ( is_homogeneous()) {
|
||||
if(is_homogeneous())
|
||||
{
|
||||
float w;
|
||||
m_in >> iformat(w);
|
||||
x /= w;
|
||||
|
|
@ -230,64 +277,85 @@ public:
|
|||
}
|
||||
}
|
||||
}
|
||||
void scan_normal( double& x, double& y, double& z) {
|
||||
if ( has_normals()) {
|
||||
|
||||
void scan_normal(double& x, double& y, double& z)
|
||||
{
|
||||
if(has_normals())
|
||||
{
|
||||
normals_read = true;
|
||||
if ( binary()) {
|
||||
if(binary())
|
||||
{
|
||||
float fx, fy, fz;
|
||||
I_Binary_read_big_endian_float32( m_in, fx);
|
||||
I_Binary_read_big_endian_float32( m_in, fy);
|
||||
I_Binary_read_big_endian_float32( m_in, fz);
|
||||
if ( is_homogeneous()) {
|
||||
I_Binary_read_big_endian_float32(m_in, fx);
|
||||
I_Binary_read_big_endian_float32(m_in, fy);
|
||||
I_Binary_read_big_endian_float32(m_in, fz);
|
||||
if(is_homogeneous())
|
||||
{
|
||||
float fw;
|
||||
I_Binary_read_big_endian_float32( m_in, fw);
|
||||
I_Binary_read_big_endian_float32(m_in, fw);
|
||||
x = fx / fw;
|
||||
y = fy / fw;
|
||||
z = fz / fw;
|
||||
} else {
|
||||
} else
|
||||
{
|
||||
x = fx;
|
||||
y = fy;
|
||||
z = fz;
|
||||
}
|
||||
} else {
|
||||
if ( is_homogeneous()) {
|
||||
}
|
||||
else
|
||||
{
|
||||
if(is_homogeneous())
|
||||
{
|
||||
float fx, fy, fz, fw;
|
||||
m_in >> iformat(fx) >> iformat(fy) >> iformat(fz) >> iformat(fw);
|
||||
x = fx / fw;
|
||||
y = fy / fw;
|
||||
z = fz / fw;
|
||||
} else
|
||||
}
|
||||
else
|
||||
{
|
||||
m_in >> iformat(x) >> iformat(y) >> iformat(z);
|
||||
}
|
||||
}
|
||||
}
|
||||
void scan_normal( int& x, int& y, int& z) {
|
||||
if ( has_normals()) {
|
||||
}
|
||||
|
||||
void scan_normal(int& x, int& y, int& z)
|
||||
{
|
||||
if(has_normals())
|
||||
{
|
||||
normals_read = true;
|
||||
if ( binary()) {
|
||||
if(binary())
|
||||
{
|
||||
float fx, fy, fz;
|
||||
I_Binary_read_big_endian_float32( m_in, fx);
|
||||
I_Binary_read_big_endian_float32( m_in, fy);
|
||||
I_Binary_read_big_endian_float32( m_in, fz);
|
||||
if ( is_homogeneous()) {
|
||||
I_Binary_read_big_endian_float32(m_in, fx);
|
||||
I_Binary_read_big_endian_float32(m_in, fy);
|
||||
I_Binary_read_big_endian_float32(m_in, fz);
|
||||
if(is_homogeneous()) {
|
||||
float fw;
|
||||
I_Binary_read_big_endian_float32( m_in, fw);
|
||||
x = int( fx / fw);
|
||||
y = int( fy / fw);
|
||||
z = int( fz / fw);
|
||||
I_Binary_read_big_endian_float32(m_in, fw);
|
||||
x = int(fx / fw);
|
||||
y = int(fy / fw);
|
||||
z = int(fz / fw);
|
||||
} else {
|
||||
x = int(fx);
|
||||
y = int(fy);
|
||||
z = int(fz);
|
||||
}
|
||||
} else {
|
||||
if ( is_homogeneous()) {
|
||||
}
|
||||
else
|
||||
{
|
||||
if(is_homogeneous())
|
||||
{
|
||||
float fx, fy, fz, fw;
|
||||
m_in >> iformat(fx) >> iformat(fy) >> iformat(fz) >> iformat(fw);
|
||||
x = int( fx / fw);
|
||||
y = int( fy / fw);
|
||||
z = int( fz / fw);
|
||||
} else {
|
||||
x = int(fx / fw);
|
||||
y = int(fy / fw);
|
||||
z = int(fz / fw);
|
||||
}
|
||||
else
|
||||
{
|
||||
double d;
|
||||
m_in >> iformat(d);
|
||||
x = int(d);
|
||||
|
|
@ -300,63 +368,81 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
void scan_normal( float& x, float& y, float& z, float& w) {
|
||||
void scan_normal(float& x, float& y, float& z, float& w)
|
||||
{
|
||||
w = 1;
|
||||
if ( has_normals()) {
|
||||
if(has_normals())
|
||||
{
|
||||
normals_read = true;
|
||||
if ( binary()) {
|
||||
I_Binary_read_big_endian_float32( m_in, x);
|
||||
I_Binary_read_big_endian_float32( m_in, y);
|
||||
I_Binary_read_big_endian_float32( m_in, z);
|
||||
if ( is_homogeneous())
|
||||
I_Binary_read_big_endian_float32( m_in, w);
|
||||
} else {
|
||||
if(binary())
|
||||
{
|
||||
I_Binary_read_big_endian_float32(m_in, x);
|
||||
I_Binary_read_big_endian_float32(m_in, y);
|
||||
I_Binary_read_big_endian_float32(m_in, z);
|
||||
if(is_homogeneous())
|
||||
I_Binary_read_big_endian_float32(m_in, w);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_in >> iformat(x) >> iformat(y) >> iformat(z);
|
||||
if ( is_homogeneous())
|
||||
if(is_homogeneous())
|
||||
m_in >> iformat(w);
|
||||
}
|
||||
}
|
||||
}
|
||||
void scan_normal( double& x, double& y, double& z, double& w) {
|
||||
|
||||
void scan_normal(double& x, double& y, double& z, double& w)
|
||||
{
|
||||
w = 1;
|
||||
if ( has_normals()) {
|
||||
if(has_normals())
|
||||
{
|
||||
normals_read = true;
|
||||
if ( binary()) {
|
||||
if(binary())
|
||||
{
|
||||
float f;
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
x = f;
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
y = f;
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
z = f;
|
||||
if ( is_homogeneous()) {
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
if(is_homogeneous())
|
||||
{
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
w = f;
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
m_in >> iformat(x) >> iformat(y) >> iformat(z);
|
||||
if ( is_homogeneous())
|
||||
if(is_homogeneous())
|
||||
m_in >> iformat(w);
|
||||
}
|
||||
}
|
||||
}
|
||||
void scan_normal( int& x, int& y, int& z, int& w) {
|
||||
|
||||
void scan_normal(int& x, int& y, int& z, int& w)
|
||||
{
|
||||
w = 1;
|
||||
if ( has_normals()) {
|
||||
if(has_normals())
|
||||
{
|
||||
normals_read = true;
|
||||
if ( binary()) {
|
||||
if(binary())
|
||||
{
|
||||
float f;
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
x = int(f);
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
y = int(f);
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
z = int(f);
|
||||
if ( is_homogeneous()) {
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
if(is_homogeneous()) {
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
w = int(f);
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
double d;
|
||||
m_in >> iformat(d);
|
||||
x = int(d);
|
||||
|
|
@ -364,7 +450,8 @@ public:
|
|||
y = int(d);
|
||||
m_in >> iformat(d);
|
||||
z = int(d);
|
||||
if ( is_homogeneous()) {
|
||||
if(is_homogeneous())
|
||||
{
|
||||
m_in >> iformat(d);
|
||||
w = int(d);
|
||||
}
|
||||
|
|
@ -530,7 +617,6 @@ public:
|
|||
|
||||
static CGAL::Color get_color_from_line(std::istream &is)
|
||||
{
|
||||
|
||||
std::string color_info;
|
||||
bool is_float = false;
|
||||
|
||||
|
|
@ -548,7 +634,7 @@ public:
|
|||
if(color_info.at(0) == '#')
|
||||
break;
|
||||
//detect if the value is float
|
||||
for(int c = 0; c<static_cast<int>(color_info.length()); c++)
|
||||
for(int c = 0; c<static_cast<int>(color_info.length()); ++c)
|
||||
{
|
||||
if(color_info.at(c) == '.')
|
||||
{
|
||||
|
|
@ -556,37 +642,45 @@ public:
|
|||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//if the value is of float type, convert it into an int
|
||||
if(is_float)
|
||||
rgb[index] = static_cast<unsigned char>(atof(color_info.c_str())*255);
|
||||
//else stores the value
|
||||
else
|
||||
rgb[index] = static_cast<unsigned char>(atoi(color_info.c_str()));
|
||||
index++;
|
||||
|
||||
++index;
|
||||
if(index == 3)
|
||||
break;
|
||||
}
|
||||
|
||||
CGAL::Color color;
|
||||
//if there were only one number, fetch the color in the color map
|
||||
if(index<2)
|
||||
if(index < 2)
|
||||
color = get_indexed_color(rgb[0]);
|
||||
//else create the coor with the 3 values;
|
||||
else
|
||||
color = CGAL::Color(rgb[0], rgb[1], rgb[2]);
|
||||
|
||||
return color;
|
||||
}
|
||||
|
||||
void scan_color( unsigned char& r, unsigned char& g, unsigned char& b) {
|
||||
if ( binary()) {
|
||||
void scan_color(unsigned char& r, unsigned char& g, unsigned char& b)
|
||||
{
|
||||
if(binary())
|
||||
{
|
||||
float fr, fg, fb;
|
||||
I_Binary_read_big_endian_float32( m_in, fr);
|
||||
I_Binary_read_big_endian_float32( m_in, fg);
|
||||
I_Binary_read_big_endian_float32( m_in, fb);
|
||||
I_Binary_read_big_endian_float32(m_in, fr);
|
||||
I_Binary_read_big_endian_float32(m_in, fg);
|
||||
I_Binary_read_big_endian_float32(m_in, fb);
|
||||
r = (unsigned char)(fr);
|
||||
g = (unsigned char)(fg);
|
||||
b = (unsigned char)(fb);
|
||||
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
CGAL::Color color = get_color_from_line(m_in);
|
||||
r = color.red();
|
||||
g = color.green();
|
||||
|
|
@ -594,46 +688,136 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
void skip_to_next_vertex( std::size_t current_vertex);
|
||||
void skip_to_next_vertex(std::size_t current_vertex)
|
||||
{
|
||||
CGAL_assertion(current_vertex < size_of_vertices());
|
||||
if(binary())
|
||||
{
|
||||
float f;
|
||||
if(has_normals() && ! normals_read) {
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
if(is_homogeneous())
|
||||
I_Binary_read_big_endian_float32(m_in, f);
|
||||
}
|
||||
|
||||
void scan_facet( std::size_t& size, std::size_t CGAL_assertion_code(current_facet)) {
|
||||
CGAL_assertion( current_facet < size_of_facets());
|
||||
if ( binary()){
|
||||
boost::int32_t i32;
|
||||
I_Binary_read_big_endian_integer32( m_in, i32);
|
||||
size = i32;
|
||||
if(has_colors())
|
||||
{
|
||||
// It is not well stated in the Geomview manual
|
||||
// how color is coded following a vertex. It is
|
||||
// parsed similar to the optional color for facets.
|
||||
boost::int32_t k;
|
||||
I_Binary_read_big_endian_integer32(m_in, k);
|
||||
if(k<0 || k>4)
|
||||
{
|
||||
m_in.clear(std::ios::badbit);
|
||||
if(verbose())
|
||||
{
|
||||
std::cerr << " " << std::endl;
|
||||
std::cerr << "File_scanner_OFF::" << std::endl;
|
||||
std::cerr << "skip_to_next_vertex(): input error: bad "
|
||||
" number of color indices at vertex "
|
||||
<< current_vertex << "." << std::endl;
|
||||
}
|
||||
|
||||
set_off_header(false);
|
||||
return;
|
||||
}
|
||||
|
||||
while(k--)
|
||||
{
|
||||
float dummy;
|
||||
I_Binary_read_big_endian_float32(m_in, dummy);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(has_normals() && ! normals_read)
|
||||
{
|
||||
double dummy;
|
||||
if(is_homogeneous()) {
|
||||
m_in >> dummy >> dummy >> dummy >> dummy;
|
||||
} else {
|
||||
m_in >> dummy >> dummy >> dummy;
|
||||
}
|
||||
}
|
||||
|
||||
if(has_colors()) // skip color entries (1 to 4)
|
||||
m_in >> skip_until_EOL;
|
||||
}
|
||||
|
||||
if(!m_in)
|
||||
{
|
||||
if(verbose())
|
||||
{
|
||||
std::cerr << " " << std::endl;
|
||||
std::cerr << "File_scanner_OFF::" << std::endl;
|
||||
std::cerr << "skip_to_next_vertex(): input error: cannot read "
|
||||
"OFF file beyond vertex " << current_vertex << "."
|
||||
<< std::endl;
|
||||
}
|
||||
|
||||
set_off_header(false);
|
||||
return;
|
||||
}
|
||||
|
||||
normals_read = false;
|
||||
}
|
||||
|
||||
void scan_facet(std::size_t& size, std::size_t CGAL_assertion_code(current_facet))
|
||||
{
|
||||
CGAL_assertion(current_facet < size_of_facets());
|
||||
if(binary())
|
||||
{
|
||||
boost::int32_t i32;
|
||||
I_Binary_read_big_endian_integer32(m_in, i32);
|
||||
size = i32;
|
||||
}
|
||||
else
|
||||
{
|
||||
skip_comment();
|
||||
m_in >> size;
|
||||
}
|
||||
}
|
||||
|
||||
void scan_facet_vertex_index( std::size_t& index,
|
||||
std::size_t current_facet) {
|
||||
if ( binary()){
|
||||
void scan_facet_vertex_index(std::size_t& index,
|
||||
std::size_t current_facet)
|
||||
{
|
||||
if(binary()){
|
||||
boost::int32_t i32;
|
||||
I_Binary_read_big_endian_integer32( m_in, i32);
|
||||
I_Binary_read_big_endian_integer32(m_in, i32);
|
||||
index = i32;
|
||||
} else
|
||||
}
|
||||
else
|
||||
{
|
||||
m_in >> index;
|
||||
}
|
||||
|
||||
if( m_in.fail()) {
|
||||
if ( verbose()) {
|
||||
if(m_in.fail())
|
||||
{
|
||||
if(verbose())
|
||||
{
|
||||
std::cerr << " " << std::endl;
|
||||
std::cerr << "File_scanner_OFF::" << std::endl;
|
||||
std::cerr << "scan_facet_vertex_index(): input error: "
|
||||
"cannot read OFF file beyond facet "
|
||||
<< current_facet << "." << std::endl;
|
||||
}
|
||||
set_off_header( false);
|
||||
|
||||
set_off_header(false);
|
||||
return;
|
||||
}
|
||||
|
||||
bool error = index < index_offset();
|
||||
index -= index_offset();
|
||||
|
||||
if(error || (index >= size_of_vertices())) {
|
||||
m_in.clear( std::ios::failbit);
|
||||
if ( verbose()) {
|
||||
if(error || (index >= size_of_vertices()))
|
||||
{
|
||||
m_in.clear(std::ios::failbit);
|
||||
if(verbose())
|
||||
{
|
||||
std::cerr << " " << std::endl;
|
||||
std::cerr << "File_scanner_OFF::" << std::endl;
|
||||
std::cerr << "scan_facet_vertex_index(): input error: "
|
||||
|
|
@ -641,58 +825,92 @@ public:
|
|||
<< index + index_offset() << ": is out of range."
|
||||
<< std::endl;
|
||||
}
|
||||
set_off_header( false);
|
||||
|
||||
set_off_header(false);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
void skip_to_next_facet( std::size_t current_facet);
|
||||
void skip_to_next_facet(std::size_t current_facet)
|
||||
{
|
||||
// Take care of trailing informations like color triples.
|
||||
if(binary())
|
||||
{
|
||||
boost::int32_t k;
|
||||
I_Binary_read_big_endian_integer32(m_in, k);
|
||||
if(k<0 || k>4)
|
||||
{
|
||||
m_in.clear(std::ios::badbit);
|
||||
if(verbose())
|
||||
{
|
||||
std::cerr << " " << std::endl;
|
||||
std::cerr << "File_scanner_OFF::" << std::endl;
|
||||
std::cerr << "skip_to_next_facet(): input error: bad "
|
||||
"number of color indices at vertex "
|
||||
<< current_facet << "." << std::endl;
|
||||
}
|
||||
|
||||
set_off_header(false);
|
||||
return;
|
||||
}
|
||||
|
||||
while (k--)
|
||||
{
|
||||
float dummy;
|
||||
I_Binary_read_big_endian_float32(m_in, dummy);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
m_in >> skip_until_EOL;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template < class Point> inline
|
||||
Point&
|
||||
file_scan_vertex( File_scanner_OFF& scanner, Point& p) {
|
||||
Point& file_scan_vertex(File_scanner_OFF& scanner, Point& p)
|
||||
{
|
||||
typedef typename Point::R R;
|
||||
typedef typename R::RT RT;
|
||||
double x, y, z, w;
|
||||
scanner.scan_vertex( x, y, z, w);
|
||||
if ( w == 1)
|
||||
p = Point( RT(x), RT(y), RT(z));
|
||||
|
||||
scanner.scan_vertex(x, y, z, w);
|
||||
|
||||
if(w == 1)
|
||||
p = Point(RT(x), RT(y), RT(z));
|
||||
else
|
||||
p = Point( RT(x), RT(y), RT(z), RT(w));
|
||||
p = Point(RT(x), RT(y), RT(z), RT(w));
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
template < class T_Color> inline
|
||||
T_Color&
|
||||
file_scan_color( File_scanner_OFF& scanner, T_Color& c) {
|
||||
T_Color& file_scan_color(File_scanner_OFF& scanner, T_Color& c)
|
||||
{
|
||||
unsigned char r, g, b;
|
||||
scanner.scan_color(r,g,b);
|
||||
c = T_Color(r,g,b);
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
template < class Vector> inline
|
||||
Vector&
|
||||
file_scan_normal( File_scanner_OFF& scanner, Vector& v) {
|
||||
file_scan_normal(File_scanner_OFF& scanner, Vector& v)
|
||||
{
|
||||
typedef typename Vector::R R;
|
||||
typedef typename R::RT RT;
|
||||
|
||||
double x, y, z, w;
|
||||
scanner.scan_normal( x, y, z, w);
|
||||
if ( w == 1)
|
||||
v = Vector( RT(x), RT(y), RT(z));
|
||||
scanner.scan_normal(x, y, z, w);
|
||||
if(w == 1)
|
||||
v = Vector(RT(x), RT(y), RT(z));
|
||||
else
|
||||
v = Vector( RT(x), RT(y), RT(z), RT(w));
|
||||
v = Vector(RT(x), RT(y), RT(z), RT(w));
|
||||
|
||||
return v;
|
||||
}
|
||||
|
||||
} //namespace CGAL
|
||||
|
||||
#ifdef CGAL_HEADER_ONLY
|
||||
#include <CGAL/IO/OFF/File_scanner_OFF_impl.h>
|
||||
#endif // CGAL_HEADER_ONLY
|
||||
|
||||
#include <CGAL/enable_warnings.h>
|
||||
|
||||
#endif // CGAL_IO_OFF_FILE_SCANNER_OFF_H //
|
||||
// EOF //
|
||||
#endif // CGAL_IO_OFF_FILE_SCANNER_OFF_H
|
||||
|
|
|
|||
|
|
@ -1,125 +0,0 @@
|
|||
// Copyright (c) 1997
|
||||
// Utrecht University (The Netherlands),
|
||||
// ETH Zurich (Switzerland),
|
||||
// INRIA Sophia-Antipolis (France),
|
||||
// Max-Planck-Institute Saarbruecken (Germany),
|
||||
// and Tel-Aviv University (Israel). All rights reserved.
|
||||
//
|
||||
// This file is part of CGAL (www.cgal.org)
|
||||
//
|
||||
// $URL$
|
||||
// $Id$
|
||||
// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial
|
||||
//
|
||||
//
|
||||
// Author(s) : Lutz Kettner <kettner@mpi-sb.mpg.de>
|
||||
|
||||
#ifdef CGAL_HEADER_ONLY
|
||||
#define CGAL_INLINE_FUNCTION inline
|
||||
#else
|
||||
#define CGAL_INLINE_FUNCTION
|
||||
#endif
|
||||
|
||||
#include <CGAL/basic.h>
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
#include <CGAL/IO/binary_file_io.h>
|
||||
#include <CGAL/IO/OFF/File_scanner_OFF.h>
|
||||
|
||||
namespace CGAL {
|
||||
|
||||
CGAL_INLINE_FUNCTION
|
||||
void
|
||||
File_scanner_OFF::
|
||||
skip_to_next_vertex( std::size_t current_vertex) {
|
||||
CGAL_assertion( current_vertex < size_of_vertices());
|
||||
if ( binary()) {
|
||||
float f;
|
||||
if ( has_normals() && ! normals_read) {
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
if ( is_homogeneous())
|
||||
I_Binary_read_big_endian_float32( m_in, f);
|
||||
}
|
||||
if ( has_colors()) {
|
||||
// It is not well stated in the Geomview manual
|
||||
// how color is coded following a vertex. It is
|
||||
// parsed similar to the optional color for facets.
|
||||
boost::int32_t k;
|
||||
I_Binary_read_big_endian_integer32( m_in, k);
|
||||
if (k<0 || k>4) {
|
||||
m_in.clear( std::ios::badbit);
|
||||
if ( verbose()) {
|
||||
std::cerr << " " << std::endl;
|
||||
std::cerr << "File_scanner_OFF::" << std::endl;
|
||||
std::cerr << "skip_to_next_vertex(): input error: bad "
|
||||
" number of color indices at vertex "
|
||||
<< current_vertex << "." << std::endl;
|
||||
}
|
||||
set_off_header( false);
|
||||
return;
|
||||
}
|
||||
while (k--) {
|
||||
float dummy;
|
||||
I_Binary_read_big_endian_float32( m_in, dummy);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if ( has_normals() && ! normals_read) {
|
||||
double dummy;
|
||||
if ( is_homogeneous()) {
|
||||
m_in >> dummy >> dummy >> dummy >> dummy;
|
||||
} else {
|
||||
m_in >> dummy >> dummy >> dummy;
|
||||
}
|
||||
}
|
||||
if ( has_colors()) { // skip color entries (1 to 4)
|
||||
m_in >> skip_until_EOL;
|
||||
}
|
||||
}
|
||||
if( ! m_in) {
|
||||
if ( verbose()) {
|
||||
std::cerr << " " << std::endl;
|
||||
std::cerr << "File_scanner_OFF::" << std::endl;
|
||||
std::cerr << "skip_to_next_vertex(): input error: cannot read "
|
||||
"OFF file beyond vertex " << current_vertex << "."
|
||||
<< std::endl;
|
||||
}
|
||||
set_off_header( false);
|
||||
return;
|
||||
}
|
||||
normals_read = false;
|
||||
}
|
||||
|
||||
CGAL_INLINE_FUNCTION
|
||||
void
|
||||
File_scanner_OFF::
|
||||
skip_to_next_facet( std::size_t current_facet) {
|
||||
// Take care of trailing informations like color triples.
|
||||
if ( binary()) {
|
||||
boost::int32_t k;
|
||||
I_Binary_read_big_endian_integer32( m_in, k);
|
||||
if (k<0 || k>4) {
|
||||
m_in.clear( std::ios::badbit);
|
||||
if ( verbose()) {
|
||||
std::cerr << " " << std::endl;
|
||||
std::cerr << "File_scanner_OFF::" << std::endl;
|
||||
std::cerr << "skip_to_next_facet(): input error: bad "
|
||||
"number of color indices at vertex "
|
||||
<< current_facet << "." << std::endl;
|
||||
}
|
||||
set_off_header( false);
|
||||
return;
|
||||
}
|
||||
while (k--) {
|
||||
float dummy;
|
||||
I_Binary_read_big_endian_float32( m_in, dummy);
|
||||
}
|
||||
} else {
|
||||
m_in >> skip_until_EOL;
|
||||
}
|
||||
}
|
||||
|
||||
} //namespace CGAL
|
||||
// EOF //
|
||||
|
|
@ -38,13 +38,13 @@ public:
|
|||
File_header_OFF& header() { return m_header; }
|
||||
const File_header_OFF& header() const { return m_header; }
|
||||
|
||||
void write_header(std::ostream& out,
|
||||
void write_header(std::ostream& os,
|
||||
std::size_t vertices,
|
||||
std::size_t /*halfedges*/,
|
||||
std::size_t facets,
|
||||
bool normals = false)
|
||||
{
|
||||
m_out = &o;
|
||||
m_out = &os;
|
||||
|
||||
m_header.set_vertices(vertices);
|
||||
m_header.set_facets(facets);
|
||||
|
|
|
|||
|
|
@ -1,24 +0,0 @@
|
|||
// Copyright (c) 1997
|
||||
// Utrecht University (The Netherlands),
|
||||
// ETH Zurich (Switzerland),
|
||||
// INRIA Sophia-Antipolis (France),
|
||||
// Max-Planck-Institute Saarbruecken (Germany),
|
||||
// and Tel-Aviv University (Israel). All rights reserved.
|
||||
//
|
||||
// This file is part of CGAL (www.cgal.org)
|
||||
//
|
||||
// $URL$
|
||||
// $Id$
|
||||
// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial
|
||||
//
|
||||
//
|
||||
// Author(s) : Lutz Kettner <kettner@mpi-sb.mpg.de>
|
||||
|
||||
#ifndef CGAL_HEADER_ONLY
|
||||
|
||||
#include <CGAL/IO/OFF/File_scanner_OFF.h>
|
||||
#include <CGAL/IO/OFF/File_scanner_OFF_impl.h>
|
||||
|
||||
#endif // CGAL_HEADER_ONLY
|
||||
|
||||
// EOF //
|
||||
Loading…
Reference in New Issue