259 lines
8.3 KiB
C++
259 lines
8.3 KiB
C++
/*
|
|
* Software License Agreement (BSD License)
|
|
*
|
|
* Point Cloud Library (PCL) - www.pointclouds.org
|
|
* Copyright (c) 2009-2012, Willow Garage, Inc.
|
|
* Copyright (c) 2012-, Open Perception, Inc.
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following
|
|
* disclaimer in the documentation and/or other materials provided
|
|
* with the distribution.
|
|
* * Neither the name of the copyright holder(s) nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* $Id$
|
|
*
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <string>
|
|
|
|
namespace pcl {
|
|
namespace geometry {
|
|
/** \brief Read / write the half-edge mesh from / to a file.
|
|
* \tparam MeshT e.g. pcl::geometry::TriangleMesh or pcl::geometry::PolygonMesh
|
|
* \author Martin Saelzle
|
|
* \ingroup geometry
|
|
* \todo
|
|
* - Only writes the topology (not the mesh data).
|
|
* - Supports only ascii.
|
|
* - Does not consider the mesh traits (e.g. manifold or not)
|
|
*/
|
|
template <class MeshT>
|
|
class MeshIO {
|
|
public:
|
|
using Mesh = MeshT;
|
|
|
|
using Vertex = typename Mesh::Vertex;
|
|
using HalfEdge = typename Mesh::HalfEdge;
|
|
using Face = typename Mesh::Face;
|
|
|
|
using Vertices = typename Mesh::Vertices;
|
|
using HalfEdges = typename Mesh::HalfEdges;
|
|
using Faces = typename Mesh::Faces;
|
|
|
|
using VertexIndex = typename Mesh::VertexIndex;
|
|
using HalfEdgeIndex = typename Mesh::HalfEdgeIndex;
|
|
using FaceIndex = typename Mesh::FaceIndex;
|
|
|
|
/** \brief Constructor. */
|
|
MeshIO() {}
|
|
|
|
/** \brief Read the mesh from a file with the given filename.
|
|
* \param[in] filename Path to the file.
|
|
* \param[out] mesh The loaded mesh.
|
|
* \return true if success.
|
|
*/
|
|
bool
|
|
read(const std::string& filename, Mesh& mesh) const
|
|
{
|
|
std::ifstream file(filename.c_str());
|
|
|
|
if (!file.is_open()) {
|
|
std::cerr << "Error in MeshIO::read: Could not open the file '" << filename
|
|
<< "'\n";
|
|
return (false);
|
|
}
|
|
|
|
// Read the header
|
|
std::string line;
|
|
unsigned int line_number = 1;
|
|
int n_v = -1, n_he = -1, n_f = -1;
|
|
|
|
if (!std::getline(file, line) || line != "PCL half-edge mesh") {
|
|
std::cerr << "Error loading '" << filename << "' (line " << line_number
|
|
<< "): Wrong file format.\n";
|
|
return (false);
|
|
}
|
|
++line_number;
|
|
|
|
if (!std::getline(file, line)) {
|
|
std::cerr << "Error loading '" << filename << "'' (line " << line_number
|
|
<< "): Number of vertices / half-edges / faces not found.\n";
|
|
return (false);
|
|
}
|
|
{
|
|
std::istringstream iss(line);
|
|
if (!(iss >> n_v >> n_he >> n_f) || iss.good()) // Don't allow more than 3 en
|
|
{
|
|
std::cerr << "Error loading '" << filename << "'' (line " << line_number
|
|
<< "): Could not read the number of vertices / half-edges / faces.\n";
|
|
return (false);
|
|
}
|
|
}
|
|
if (n_v < 0 || n_he < 0 || n_f < 0) {
|
|
std::cerr << "Error loading '" << filename << "'' (line " << line_number
|
|
<< "): Invalid number of vertices / half-edges / faces.\n";
|
|
return (false);
|
|
}
|
|
++line_number;
|
|
|
|
// Read the vertices.
|
|
{
|
|
mesh.vertices_.reserve(n_v);
|
|
HalfEdgeIndex idx_ohe; // Outgoing half-edge;
|
|
|
|
for (int i = 0; i < n_v; ++i, ++line_number) {
|
|
if (!std::getline(file, line)) {
|
|
std::cerr << "Error loading '" << filename << "'' (line " << line_number
|
|
<< "): Could not read the line.\n";
|
|
return (false);
|
|
}
|
|
|
|
std::istringstream iss(line);
|
|
if (!(iss >> idx_ohe) || iss.good()) {
|
|
std::cerr << "Error loading '" << filename << "'' (line " << line_number
|
|
<< "): Could not read the vertex.\n";
|
|
return (false);
|
|
}
|
|
mesh.vertices_.push_back(Vertex(idx_ohe));
|
|
}
|
|
}
|
|
|
|
// Read the half-edges.
|
|
{
|
|
mesh.half_edges_.reserve(n_he);
|
|
VertexIndex idx_tv; // Terminating vertex.
|
|
HalfEdgeIndex idx_nhe; // Next half-edge;
|
|
HalfEdgeIndex idx_phe; // Previous half-edge.
|
|
FaceIndex idx_f; // Face.
|
|
|
|
for (int i = 0; i < n_he; ++i, ++line_number) {
|
|
if (!std::getline(file, line)) {
|
|
std::cerr << "Error loading '" << filename << "'' (line " << line_number
|
|
<< "): Could not read the line.\n";
|
|
return (false);
|
|
}
|
|
|
|
std::istringstream iss(line);
|
|
if (!(iss >> idx_tv >> idx_nhe >> idx_phe >> idx_f) || iss.good()) {
|
|
std::cerr << "Error loading '" << filename << "'' (line " << line_number
|
|
<< "): Could not read the half-edge.\n";
|
|
return (false);
|
|
}
|
|
mesh.half_edges_.push_back(HalfEdge(idx_tv, idx_nhe, idx_phe, idx_f));
|
|
}
|
|
}
|
|
|
|
// Read the faces.
|
|
{
|
|
mesh.faces_.reserve(n_f);
|
|
HalfEdgeIndex idx_ihe; // Inner half-edge.
|
|
|
|
for (int i = 0; i < n_f; ++i, ++line_number) {
|
|
if (!std::getline(file, line)) {
|
|
std::cerr << "Error loading '" << filename << "'' (line " << line_number
|
|
<< "): Could not read the line.\n";
|
|
return (false);
|
|
}
|
|
|
|
std::istringstream iss(line);
|
|
if (!(iss >> idx_ihe) || iss.good()) {
|
|
std::cerr << "Error loading '" << filename << "'' (line " << line_number
|
|
<< "): Could not read the face.\n";
|
|
return (false);
|
|
}
|
|
mesh.faces_.push_back(Face(idx_ihe));
|
|
}
|
|
}
|
|
|
|
// Set the data
|
|
if (Mesh::HasVertexData::value)
|
|
mesh.vertex_data_cloud_.resize(n_v);
|
|
if (Mesh::HasHalfEdgeData::value)
|
|
mesh.half_edge_data_cloud_.resize(n_he);
|
|
if (Mesh::HasEdgeData::value)
|
|
mesh.edge_data_cloud_.resize(n_he / 2);
|
|
if (Mesh::HasFaceData::value)
|
|
mesh.face_data_cloud_.resize(n_f);
|
|
|
|
return (true);
|
|
}
|
|
|
|
/** \brief Write the mesh to a file with the given filename.
|
|
* \param[in] filename Path to the file.
|
|
* \param[in] mesh The saved mesh.
|
|
* \return true if success
|
|
*/
|
|
bool
|
|
write(const std::string& filename, const Mesh& mesh) const
|
|
{
|
|
std::ofstream file(filename.c_str());
|
|
|
|
// Write the header
|
|
if (!file.is_open()) {
|
|
std::cerr << "Error in MeshIO::write: Could not open the file '" << filename
|
|
<< "'\n";
|
|
return (false);
|
|
}
|
|
|
|
file << "PCL half-edge mesh\n";
|
|
file << mesh.sizeVertices() << " " << mesh.sizeHalfEdges() << " "
|
|
<< mesh.sizeFaces() << "\n";
|
|
|
|
// Write the vertices
|
|
for (typename Vertices::const_iterator it = mesh.vertices_.begin();
|
|
it != mesh.vertices_.end();
|
|
++it) {
|
|
file << it->idx_outgoing_half_edge_ << "\n";
|
|
}
|
|
|
|
// Write the half-edges
|
|
for (typename HalfEdges::const_iterator it = mesh.half_edges_.begin();
|
|
it != mesh.half_edges_.end();
|
|
++it) {
|
|
file << it->idx_terminating_vertex_ << " " << it->idx_next_half_edge_ << " "
|
|
<< it->idx_prev_half_edge_ << " " << it->idx_face_ << "\n";
|
|
}
|
|
|
|
// Write the faces
|
|
for (typename Faces::const_iterator it = mesh.faces_.begin();
|
|
it != mesh.faces_.end();
|
|
++it) {
|
|
file << it->idx_inner_half_edge_ << "\n";
|
|
}
|
|
|
|
return (true);
|
|
}
|
|
};
|
|
|
|
} // End namespace geometry
|
|
} // End namespace pcl
|