mirror of https://github.com/CGAL/cgal
345 lines
11 KiB
C++
345 lines
11 KiB
C++
// Copyright (c) 2015 Geometry Factory
|
|
// 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
|
|
// Andreas Fabri
|
|
// Maxime Gimeno
|
|
|
|
#ifndef CGAL_IO_OBJ_H
|
|
#define CGAL_IO_OBJ_H
|
|
|
|
#include <CGAL/IO/OBJ/File_writer_wavefront.h>
|
|
#include <CGAL/IO/Generic_writer.h>
|
|
|
|
#include <boost/range/value_type.hpp>
|
|
#include <CGAL/IO/io.h>
|
|
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace CGAL {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Read
|
|
|
|
namespace IO {
|
|
namespace internal {
|
|
|
|
template <typename PointRange, typename PolygonRange, typename VertexNormalOutputIterator, typename VertexTextureOutputIterator>
|
|
bool read_OBJ(std::istream& is,
|
|
PointRange& points,
|
|
PolygonRange& faces,
|
|
VertexNormalOutputIterator,
|
|
VertexTextureOutputIterator,
|
|
bool verbose = true)
|
|
{
|
|
if(!is.good())
|
|
{
|
|
if(verbose)
|
|
std::cerr<<"File doesn't exist."<<std::endl;
|
|
return false;
|
|
}
|
|
typedef typename boost::range_value<PointRange>::type Point;
|
|
typedef typename CGAL::Kernel_traits<Point>::Kernel Kernel;
|
|
typedef typename Kernel::Vector_3 Normal;
|
|
|
|
set_ascii_mode(is); // obj is ASCII only
|
|
|
|
int mini(1), maxi(-1);
|
|
bool first_o = true;
|
|
std::string s;
|
|
Point p;
|
|
|
|
std::string line;
|
|
bool tex_found(false), norm_found(false);
|
|
std::size_t offset_idx=0;
|
|
while(getline(is, line))
|
|
{
|
|
if(line.empty())
|
|
continue;
|
|
|
|
std::istringstream iss(line);
|
|
if(!(iss >> s))
|
|
continue; // can't read anything on the line, whitespace only?
|
|
if(s == "o")
|
|
{
|
|
if(!first_o)
|
|
{
|
|
if(maxi == offset_idx -1 && mini == offset_idx + 1)
|
|
{
|
|
if(verbose)
|
|
std::cerr << "No face detected." << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if(maxi > static_cast<int>(points.size()-offset_idx) || mini < -static_cast<int>(points.size()-offset_idx))
|
|
{
|
|
if(verbose)
|
|
std::cerr << "a face index is invalid " << std::endl;
|
|
return false;
|
|
}
|
|
mini = 1;
|
|
maxi = -1;
|
|
}
|
|
else
|
|
{
|
|
first_o = false;
|
|
}
|
|
offset_idx = points.size();
|
|
}
|
|
|
|
if(s == "v")
|
|
{
|
|
if(!(iss >> p))
|
|
{
|
|
if(verbose)
|
|
std::cerr << "error while reading OBJ vertex." << std::endl;
|
|
return false;
|
|
}
|
|
|
|
points.push_back(p);
|
|
}
|
|
else if(s == "vt")
|
|
{
|
|
tex_found = true;
|
|
}
|
|
else if(s == "vn")
|
|
{
|
|
norm_found = true;
|
|
}
|
|
else if(s == "f")
|
|
{
|
|
int i;
|
|
faces.emplace_back();
|
|
while(iss >> i)
|
|
{
|
|
if(i < 1)
|
|
{
|
|
faces.back().push_back(points.size()+offset_idx + i); // negative indices are relative references
|
|
if(i < mini)
|
|
mini = i;
|
|
}
|
|
else
|
|
{
|
|
faces.back().push_back(i+offset_idx-1);
|
|
if(i-1 > maxi)
|
|
maxi = i-1;
|
|
}
|
|
|
|
// the format can be "f v1/vt1/vn1 v2/vt2/vn2 v3/vt3/vn3 ..." and we only read vertex ids for now,
|
|
// so skip to the next vertex
|
|
iss.ignore(256, ' ');
|
|
}
|
|
|
|
if(iss.bad())
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
// std::cerr << "ERROR : Cannnot read line beginning with " << line[0] << std::endl;
|
|
continue;
|
|
}
|
|
}
|
|
if(norm_found && verbose)
|
|
std::cout<<"WARNING: normals were found in this file, but were discarded."<<std::endl;
|
|
if(tex_found && verbose)
|
|
std::cout<<"WARNING: textures were found in this file, but were discarded."<<std::endl;
|
|
if(maxi == offset_idx -1 && mini == offset_idx + 1)
|
|
{
|
|
if(verbose)
|
|
std::cerr << "No face detected." << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if(maxi > static_cast<int>(points.size()-offset_idx) || mini < -static_cast<int>(points.size()-offset_idx))
|
|
{
|
|
if(verbose)
|
|
std::cerr << "a face index is invalid " << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return !is.bad();
|
|
}
|
|
|
|
} // namespace internal
|
|
} // namespace IO
|
|
|
|
template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
|
|
bool read_OBJ(std::istream& is,
|
|
PointRange& points,
|
|
PolygonRange& faces,
|
|
const CGAL_BGL_NP_CLASS&,
|
|
bool verbose = true)
|
|
{
|
|
using parameters::choose_parameter;
|
|
using parameters::get_parameter;
|
|
|
|
return IO::internal::read_OBJ(is, points, faces, CGAL::Emptyset_iterator(),
|
|
CGAL::Emptyset_iterator(), verbose);
|
|
}
|
|
|
|
template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
|
|
bool read_OBJ(const char* fname, PointRange& points, PolygonRange& polygons,
|
|
const CGAL_BGL_NP_CLASS& np, bool verbose = true)
|
|
{
|
|
std::ifstream in(fname);
|
|
return read_OBJ(in, points, polygons, np, verbose);
|
|
}
|
|
|
|
template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
|
|
bool read_OBJ(const std::string& fname, PointRange& points, PolygonRange& polygons,
|
|
const CGAL_BGL_NP_CLASS& np, bool verbose = true)
|
|
{
|
|
return read_OBJ(fname.c_str(), points, polygons, np, verbose);
|
|
}
|
|
|
|
/// \ingroup PkgStreamSupportIoFuncsOBJ
|
|
///
|
|
/// \brief Reads the content of `is` into `points` and `polygons`, using the \ref IOStreamOBJ.
|
|
///
|
|
/// \tparam PointRange a model of the concept `RandomAccessContainer` whose value type is the point type.
|
|
/// \tparam PolygonRange a model of the concept `SequenceContainer`
|
|
/// whose value_type is itself a model of the concept `SequenceContainer`
|
|
/// whose value_type is an integer type.
|
|
///
|
|
/// \param is the input stream
|
|
/// \param points points of the soup of polygons.
|
|
/// \param polygons a `PolygonRange`. Each element in it describes a polygon
|
|
/// using the indices of the points in `points`.
|
|
///
|
|
/// \returns `true` if the reading was successful, `false` otherwise.
|
|
template <typename PointRange, typename PolygonRange>
|
|
bool read_OBJ(std::istream& is, PointRange& points, PolygonRange& polygons)
|
|
{
|
|
return read_OBJ(is, points, polygons, parameters::all_default());
|
|
}
|
|
|
|
/// \ingroup PkgStreamSupportIoFuncsOBJ
|
|
///
|
|
/// \brief Reads the content of the file `fname` into `points` and `polygons`, using the \ref IOStreamOBJ.
|
|
///
|
|
/// \tparam PointRange a model of the concept `RandomAccessContainer` whose value type is the point type.
|
|
/// \tparam PolygonRange a model of the concept `SequenceContainer`
|
|
/// whose value_type is itself a model of the concept `SequenceContainer`
|
|
/// whose value_type is an integer type.
|
|
///
|
|
/// \param fname the path to the input file
|
|
/// \param points points of the soup of polygons.
|
|
/// \param polygons a `PolygonRange`. Each element in it describes a polygon
|
|
/// using the indices of the points in `points`.
|
|
///
|
|
/// \returns `true` if the reading was successful, `false` otherwise.
|
|
template <typename PointRange, typename PolygonRange>
|
|
bool read_OBJ(const char* fname, PointRange& points, PolygonRange& polygons)
|
|
{
|
|
return read_OBJ(fname, points, polygons, parameters::all_default());
|
|
}
|
|
|
|
template <typename PointRange, typename PolygonRange>
|
|
bool read_OBJ(const std::string& fname, PointRange& points, PolygonRange& polygons)
|
|
{
|
|
return read_OBJ(fname, points, polygons, parameters::all_default());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Write
|
|
|
|
template <typename PointRange,
|
|
typename PolygonRange,
|
|
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
|
|
bool write_OBJ(std::ostream& os,
|
|
const PointRange& points,
|
|
const PolygonRange& polygons,
|
|
const CGAL_BGL_NP_CLASS& np)
|
|
{
|
|
set_ascii_mode(os); // obj is ASCII only
|
|
Generic_writer<std::ostream, File_writer_wavefront> writer(os);
|
|
return writer(points, polygons, np);
|
|
}
|
|
|
|
template <typename PointRange,
|
|
typename PolygonRange,
|
|
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
|
|
bool write_OBJ(const char* fname, const PointRange& points, const PolygonRange& polygons,
|
|
const CGAL_BGL_NP_CLASS& np)
|
|
{
|
|
std::ofstream out(fname);
|
|
return write_OBJ(out, points, polygons, np);
|
|
}
|
|
|
|
template <typename PointRange,
|
|
typename PolygonRange,
|
|
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
|
|
bool write_OBJ(const std::string& fname, const PointRange& points, const PolygonRange& polygons,
|
|
const CGAL_BGL_NP_CLASS& np)
|
|
{
|
|
return write_OBJ(fname.c_str(), points, polygons, np);
|
|
}
|
|
|
|
/*!
|
|
* \ingroup PkgStreamSupportIoFuncsOBJ
|
|
*
|
|
* \brief Writes the content of `points` and `polygons` in `os`, using the \ref IOStreamOBJ.
|
|
*
|
|
* \tparam PointRange a model of the concept `RandomAccessContainer` whose value type is the point type.
|
|
* \tparam PolygonRange a model of the concept `SequenceContainer`
|
|
* whose value_type is itself a model of the concept `SequenceContainer`
|
|
* whose value_type is an integer type.
|
|
*
|
|
* \param os the output stream
|
|
* \param points points of the soup of polygons.
|
|
* \param polygons a `PolygonRange`. Each element in it describes a polygon
|
|
* using the indices of the points in `points`.
|
|
*
|
|
* \return `true` if the writing was successful, `false` otherwise.
|
|
*/
|
|
template <typename PointRange, typename PolygonRange>
|
|
bool write_OBJ(std::ostream& os, const PointRange& points, const PolygonRange& polygons)
|
|
{
|
|
return write_OBJ(os, points, polygons, parameters::all_default());
|
|
}
|
|
|
|
/*!
|
|
* \ingroup PkgStreamSupportIoFuncsOBJ
|
|
*
|
|
* \brief Writes the content of `points` and `polygons` in a file named `fname`, using the \ref IOStreamOBJ.
|
|
*
|
|
* \tparam PointRange a model of the concept `RandomAccessContainer` whose value type is the point type.
|
|
* \tparam PolygonRange a model of the concept `SequenceContainer`
|
|
* whose value_type is itself a model of the concept `SequenceContainer`
|
|
* whose value_type is an integer type.
|
|
*
|
|
* \param fname the path to the output file
|
|
* \param points points of the soup of polygons.
|
|
* \param polygons a `PolygonRange`. Each element in it describes a polygon
|
|
* using the indices of the points in `points`.
|
|
*
|
|
* \return `true` if the writing was successful, `false` otherwise.
|
|
*/
|
|
template <typename PointRange, typename PolygonRange>
|
|
bool write_OBJ(const char* fname, const PointRange& points, const PolygonRange& polygons)
|
|
{
|
|
return write_OBJ(fname, points, polygons, parameters::all_default());
|
|
}
|
|
|
|
template <typename PointRange, typename PolygonRange>
|
|
bool write_OBJ(const std::string& fname, const PointRange& points, const PolygonRange& polygons)
|
|
{
|
|
return write_OBJ(fname, points, polygons, parameters::all_default());
|
|
}
|
|
|
|
} // namespace CGAL
|
|
|
|
#endif // CGAL_IO_OBJ_H
|