...
 
Commits (17)
......@@ -22,11 +22,16 @@
<li>fix halfedge indices in OpenMeshTrimeshCirculatorHalfedgeLoop CWAndCCWCheck</li>
<li>Fix wrong behaviour of HalfedgeLoopIterators by changing the template parameter</li>
<li>Added 1-4 triangle split funtion(splits all edges at Midpoints)</li>
<li>Boost range support (Thanks to Bastian Pranzas for the patch)</li>
<li>Made the face and edge split operations that copy properties also copy builtin properties</li>
<li>calc_sector_angle: Check for real division by zero not with epsilon that was way to large</li>
</ul>
<b>Utils</b>
<ul>
<li>enable c++11 features of many classes for Visual Studio 2013</li>
<li>Fixed broken version macros (Thanks to Frederik Salomonsson for the fix)</li>
<li>Fixed Build on gcc-7.2 (Thanks to Gero Müller and Martial Tola for the patches)</li>
</ul>
<b>Tools</b>
......@@ -39,21 +44,23 @@
<ul>
<li>QuadricT: implement Q+Q and Q*scalar operators for convenience.</li>
<li>Vector11T: Make converting ctor only accept 2 arguments</li>
<li>Only compute normals for faces that are not deleted</li>
</ul>
<b>IO</b>
<ul>
<li>ImporterT: Modified the add_face function of importerT to always return a valid FaceHandle</li>
<li>ImporterT: Return a valid FaceHandle when adding non-manifold faces.</li>
<li>BaseExporter: Added accessor functions for HalfEdgeHandles and faceTexCoords to base exporter and exporter template.</li>
<li>OBJ Writer: Added functionality to store FaceTexCoords to objwriter</li>
<li>OBJ Writer: Applied fix for bad or missing vertex tex coords (Thanks to Gero Müller for the patch)</li>>
<li>OBJ Loader: range check for vertex colors and normals in OBJ loader</li>
<li>OBJ Loader: fixed handling of negative indices in OBJ loader</li>
<li>OM Writer: Fixed OMWriter when no faces are available (Thanks to Jamie Kydd for the patch)</li>
<li>OM Writer: Added Mark to the format header to identify end of stream correctly (Thanks to Jamie Kydd for the patch)</li>
<li>PLY Reader: Skip reading extra elements after face</li>
<li>PLY Reader: Return error when reaching EOF</li>
</ul>
<b>Unittests</b>
......
......@@ -145,7 +145,7 @@ namespace IO {
}
// helper to store a an integer
// helper to restore a an integer
template< typename T >
size_t
restore( std::istream& _is,
......@@ -171,25 +171,28 @@ namespace IO {
OMFormat::int16 v;
bytes = restore( _is, v, _swap );
_val = static_cast<T>(v);
break;
}
case OMFormat::Chunk::Integer_32:
{
OMFormat::int32 v;
bytes = restore( _is, v, _swap );
_val = static_cast<T>(v);
break;
}
case OMFormat::Chunk::Integer_64:
{
OMFormat::int64 v;
bytes = restore( _is, v, _swap );
_val = static_cast<T>(v);
break;
}
}
return bytes;
}
// helper to store a an unsigned integer
// helper to restore a an unsigned integer
template< typename T >
size_t
restore( std::istream& _is,
......
......@@ -363,7 +363,7 @@ write(std::ostream& _out, BaseExporter& _be, Options _opt, std::streamsize _prec
{
// write vertex texture coordinate index
if (_opt.check(Options::VertexTexCoord))
_out << texMap[_be.texcoord(vh)];
_out << texMap[_be.texcoord(vhandles[j])];
}
// write vertex normal index
......
......@@ -37,146 +37,145 @@
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS *
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
* *
* ========================================================================= */
/*===========================================================================*\
* *
* $Revision$ *
* $Date$ *
* *
\*===========================================================================*/
#include <OpenMesh/Core/Mesh/ArrayKernel.hh>
namespace OpenMesh
{
ArrayKernel::ArrayKernel()
: refcount_vstatus_(0), refcount_hstatus_(0),
refcount_estatus_(0), refcount_fstatus_(0)
{
init_bit_masks(); //Status bit masks initialization
}
ArrayKernel::~ArrayKernel()
{
clear();
}
// ArrayKernel::ArrayKernel(const ArrayKernel& _rhs)
// : BaseKernel(_rhs),
// vertices_(_rhs.vertices_), edges_(_rhs.edges_), faces_(_rhs.faces_),
// vertex_status_(_rhs.vertex_status_), halfedge_status_(_rhs.halfedge_status_),
// edge_status_(_rhs.edge_status_), face_status_(_rhs.face_status_),
// refcount_vstatus_(_rhs.refcount_vstatus_), refcount_hstatus_(_rhs.refcount_hstatus_),
// refcount_estatus_(_rhs.refcount_estatus_), refcount_fstatus_(_rhs.refcount_fstatus_)
// {}
void ArrayKernel::assign_connectivity(const ArrayKernel& _other)
{
vertices_ = _other.vertices_;
edges_ = _other.edges_;
faces_ = _other.faces_;
vprops_resize(n_vertices());
hprops_resize(n_halfedges());
eprops_resize(n_edges());
fprops_resize(n_faces());
#define COPY_STATUS_PROPERTY(ENTITY) \
if (_other.ENTITY##_status_.is_valid()) \
{ \
if (!ENTITY##_status_.is_valid()) \
{ \
request_##ENTITY##_status(); \
} \
property(ENTITY##_status_) = _other.property(_other.ENTITY##_status_); \
}
COPY_STATUS_PROPERTY(vertex)
COPY_STATUS_PROPERTY(halfedge)
COPY_STATUS_PROPERTY(edge)
COPY_STATUS_PROPERTY(face)
#undef COPY_STATUS_PROPERTY
}
// --- handle -> item ---
VertexHandle ArrayKernel::handle(const Vertex& _v) const
{
return VertexHandle( int( &_v - &vertices_.front()));
}
HalfedgeHandle ArrayKernel::handle(const Halfedge& _he) const
{
// Calculate edge belonging to given halfedge
// There are two halfedges stored per edge
// Get memory position inside edge vector and devide by size of an edge
// to get the corresponding edge for the requested halfedge
size_t eh = ( (char*)&_he - (char*)&edges_.front() ) / sizeof(Edge) ;
assert((&_he == &edges_[eh].halfedges_[0]) ||
(&_he == &edges_[eh].halfedges_[1]));
return ((&_he == &edges_[eh].halfedges_[0]) ?
HalfedgeHandle( int(eh)<<1) : HalfedgeHandle((int(eh)<<1)+1));
}
EdgeHandle ArrayKernel::handle(const Edge& _e) const
{
return EdgeHandle( int(&_e - &edges_.front() ) );
}
FaceHandle ArrayKernel::handle(const Face& _f) const
{
return FaceHandle( int(&_f - &faces_.front()) );
}
#define SIGNED(x) signed( (x) )
bool ArrayKernel::is_valid_handle(VertexHandle _vh) const
{
return 0 <= _vh.idx() && _vh.idx() < SIGNED(n_vertices());
}
bool ArrayKernel::is_valid_handle(HalfedgeHandle _heh) const
{
return 0 <= _heh.idx() && _heh.idx() < SIGNED(n_edges()*2);
}
bool ArrayKernel::is_valid_handle(EdgeHandle _eh) const
{
return 0 <= _eh.idx() && _eh.idx() < SIGNED(n_edges());
}
bool ArrayKernel::is_valid_handle(FaceHandle _fh) const
{
return 0 <= _fh.idx() && _fh.idx() < SIGNED(n_faces());
}
#undef SIGNED
unsigned int ArrayKernel::delete_isolated_vertices()
{
assert(has_vertex_status());//this function requires vertex status property
unsigned int n_isolated = 0;
for (KernelVertexIter v_it = vertices_begin(); v_it != vertices_end(); ++v_it)
{
if (is_isolated(handle(*v_it)))
{
status(handle(*v_it)).set_deleted(true);
n_isolated++;
}
}
return n_isolated;
}
void ArrayKernel::garbage_collection(bool _v, bool _e, bool _f)
{
std::vector<VertexHandle*> empty_vh;
std::vector<HalfedgeHandle*> empty_hh;
std::vector<FaceHandle*> empty_fh;
garbage_collection( empty_vh,empty_hh,empty_fh,_v, _e, _f);
}
* ========================================================================= */
/*===========================================================================*\
* *
* $Revision$ *
* $Date$ *
* *
\*===========================================================================*/
#include <OpenMesh/Core/Mesh/ArrayKernel.hh>
namespace OpenMesh
{
ArrayKernel::ArrayKernel()
: refcount_vstatus_(0), refcount_hstatus_(0),
refcount_estatus_(0), refcount_fstatus_(0)
{
init_bit_masks(); //Status bit masks initialization
}
ArrayKernel::~ArrayKernel()
{
clear();
}
// ArrayKernel::ArrayKernel(const ArrayKernel& _rhs)
// : BaseKernel(_rhs),
// vertices_(_rhs.vertices_), edges_(_rhs.edges_), faces_(_rhs.faces_),
// vertex_status_(_rhs.vertex_status_), halfedge_status_(_rhs.halfedge_status_),
// edge_status_(_rhs.edge_status_), face_status_(_rhs.face_status_),
// refcount_vstatus_(_rhs.refcount_vstatus_), refcount_hstatus_(_rhs.refcount_hstatus_),
// refcount_estatus_(_rhs.refcount_estatus_), refcount_fstatus_(_rhs.refcount_fstatus_)
// {}
void ArrayKernel::assign_connectivity(const ArrayKernel& _other)
{
vertices_ = _other.vertices_;
edges_ = _other.edges_;
faces_ = _other.faces_;
vprops_resize(n_vertices());
hprops_resize(n_halfedges());
eprops_resize(n_edges());
fprops_resize(n_faces());
//just copy status properties for now,
//until a proper solution for refcounted
//properties is available
vertex_status_ = _other.vertex_status_;
halfedge_status_ = _other.halfedge_status_;
edge_status_ = _other.edge_status_;
face_status_ = _other.face_status_;
//initialize refcounter to 1 for the new mesh,
//if status is available.
refcount_estatus_ = _other.refcount_estatus_ > 0 ? 1 : 0;
refcount_vstatus_ = _other.refcount_vstatus_ > 0 ? 1 : 0;
refcount_hstatus_ = _other.refcount_hstatus_ > 0 ? 1 : 0;
refcount_fstatus_ = _other.refcount_fstatus_ > 0 ? 1 : 0;
}
// --- handle -> item ---
VertexHandle ArrayKernel::handle(const Vertex& _v) const
{
return VertexHandle( int( &_v - &vertices_.front()));
}
HalfedgeHandle ArrayKernel::handle(const Halfedge& _he) const
{
// Calculate edge belonging to given halfedge
// There are two halfedges stored per edge
// Get memory position inside edge vector and devide by size of an edge
// to get the corresponding edge for the requested halfedge
size_t eh = ( (char*)&_he - (char*)&edges_.front() ) / sizeof(Edge) ;
assert((&_he == &edges_[eh].halfedges_[0]) ||
(&_he == &edges_[eh].halfedges_[1]));
return ((&_he == &edges_[eh].halfedges_[0]) ?
HalfedgeHandle( int(eh)<<1) : HalfedgeHandle((int(eh)<<1)+1));
}
EdgeHandle ArrayKernel::handle(const Edge& _e) const
{
return EdgeHandle( int(&_e - &edges_.front() ) );
}
FaceHandle ArrayKernel::handle(const Face& _f) const
{
return FaceHandle( int(&_f - &faces_.front()) );
}
#define SIGNED(x) signed( (x) )
bool ArrayKernel::is_valid_handle(VertexHandle _vh) const
{
return 0 <= _vh.idx() && _vh.idx() < SIGNED(n_vertices());
}
bool ArrayKernel::is_valid_handle(HalfedgeHandle _heh) const
{
return 0 <= _heh.idx() && _heh.idx() < SIGNED(n_edges()*2);
}
bool ArrayKernel::is_valid_handle(EdgeHandle _eh) const
{
return 0 <= _eh.idx() && _eh.idx() < SIGNED(n_edges());
}
bool ArrayKernel::is_valid_handle(FaceHandle _fh) const
{
return 0 <= _fh.idx() && _fh.idx() < SIGNED(n_faces());
}
#undef SIGNED
unsigned int ArrayKernel::delete_isolated_vertices()
{
assert(has_vertex_status());//this function requires vertex status property
unsigned int n_isolated = 0;
for (KernelVertexIter v_it = vertices_begin(); v_it != vertices_end(); ++v_it)
{
if (is_isolated(handle(*v_it)))
{
status(handle(*v_it)).set_deleted(true);
n_isolated++;
}
}
return n_isolated;
}
void ArrayKernel::garbage_collection(bool _v, bool _e, bool _f)
{
std::vector<VertexHandle*> empty_vh;
std::vector<HalfedgeHandle*> empty_hh;
std::vector<FaceHandle*> empty_fh;
garbage_collection( empty_vh,empty_hh,empty_fh,_v, _e, _f);
}
void ArrayKernel::clean_keep_reservation()
{
vertices_.clear();
......@@ -187,74 +186,74 @@ void ArrayKernel::clean_keep_reservation()
}
void ArrayKernel::clean()
{
vertices_.clear();
VertexContainer().swap( vertices_ );
edges_.clear();
EdgeContainer().swap( edges_ );
faces_.clear();
FaceContainer().swap( faces_ );
}
void ArrayKernel::clear()
{
vprops_clear();
eprops_clear();
hprops_clear();
fprops_clear();
clean();
}
void ArrayKernel::resize( size_t _n_vertices, size_t _n_edges, size_t _n_faces )
{
vertices_.resize(_n_vertices);
edges_.resize(_n_edges);
faces_.resize(_n_faces);
vprops_resize(n_vertices());
hprops_resize(n_halfedges());
eprops_resize(n_edges());
fprops_resize(n_faces());
}
void ArrayKernel::reserve(size_t _n_vertices, size_t _n_edges, size_t _n_faces )
{
vertices_.reserve(_n_vertices);
edges_.reserve(_n_edges);
faces_.reserve(_n_faces);
vprops_reserve(_n_vertices);
hprops_reserve(_n_edges*2);
eprops_reserve(_n_edges);
fprops_reserve(_n_faces);
}
// Status Sets API
void ArrayKernel::init_bit_masks(BitMaskContainer& _bmc)
{
for (unsigned int i = Attributes::UNUSED; i != 0; i <<= 1)
{
_bmc.push_back(i);
}
}
void ArrayKernel::init_bit_masks()
{
init_bit_masks(vertex_bit_masks_);
edge_bit_masks_ = vertex_bit_masks_;//init_bit_masks(edge_bit_masks_);
face_bit_masks_ = vertex_bit_masks_;//init_bit_masks(face_bit_masks_);
halfedge_bit_masks_= vertex_bit_masks_;//init_bit_masks(halfedge_bit_masks_);
}
};
void ArrayKernel::clean()
{
vertices_.clear();
VertexContainer().swap( vertices_ );
edges_.clear();
EdgeContainer().swap( edges_ );
faces_.clear();
FaceContainer().swap( faces_ );
}
void ArrayKernel::clear()
{
vprops_clear();
eprops_clear();
hprops_clear();
fprops_clear();
clean();
}
void ArrayKernel::resize( size_t _n_vertices, size_t _n_edges, size_t _n_faces )
{
vertices_.resize(_n_vertices);
edges_.resize(_n_edges);
faces_.resize(_n_faces);
vprops_resize(n_vertices());
hprops_resize(n_halfedges());
eprops_resize(n_edges());
fprops_resize(n_faces());
}
void ArrayKernel::reserve(size_t _n_vertices, size_t _n_edges, size_t _n_faces )
{
vertices_.reserve(_n_vertices);
edges_.reserve(_n_edges);
faces_.reserve(_n_faces);
vprops_reserve(_n_vertices);
hprops_reserve(_n_edges*2);
eprops_reserve(_n_edges);
fprops_reserve(_n_faces);
}
// Status Sets API
void ArrayKernel::init_bit_masks(BitMaskContainer& _bmc)
{
for (unsigned int i = Attributes::UNUSED; i != 0; i <<= 1)
{
_bmc.push_back(i);
}
}
void ArrayKernel::init_bit_masks()
{
init_bit_masks(vertex_bit_masks_);
edge_bit_masks_ = vertex_bit_masks_;//init_bit_masks(edge_bit_masks_);
face_bit_masks_ = vertex_bit_masks_;//init_bit_masks(face_bit_masks_);
halfedge_bit_masks_= vertex_bit_masks_;//init_bit_masks(halfedge_bit_masks_);
}
};
......@@ -879,10 +879,7 @@ private:
void init_bit_masks(BitMaskContainer& _bmc);
void init_bit_masks();
private:
VertexContainer vertices_;
EdgeContainer edges_;
FaceContainer faces_;
protected:
VertexStatusPropertyHandle vertex_status_;
HalfedgeStatusPropertyHandle halfedge_status_;
......@@ -894,6 +891,11 @@ private:
unsigned int refcount_estatus_;
unsigned int refcount_fstatus_;
private:
VertexContainer vertices_;
EdgeContainer edges_;
FaceContainer faces_;
BitMaskContainer halfedge_bit_masks_;
BitMaskContainer edge_bit_masks_;
BitMaskContainer vertex_bit_masks_;
......
......@@ -261,7 +261,7 @@ void
PolyMeshT<Kernel>::
update_face_normals()
{
FaceIter f_it(Kernel::faces_begin()), f_end(Kernel::faces_end());
FaceIter f_it(Kernel::faces_sbegin()), f_end(Kernel::faces_end());
for (; f_it != f_end; ++f_it)
this->set_normal(*f_it, calc_face_normal(*f_it));
......
......@@ -445,7 +445,7 @@ public:
Normal v0, v1;
calc_sector_vectors(_in_heh, v0, v1);
Scalar denom = v0.norm()*v1.norm();
if (is_zero(denom))
if ( denom == Scalar(0))
{
return 0;
}
......
......@@ -71,9 +71,9 @@
// only defined, if it is a beta version
//#define OM_VERSION_BETA 4
#define OM_GET_VER ((OM_VERSION && 0xf0000) >> 16)
#define OM_GET_MAJ ((OM_VERSION && 0x0ff00) >> 8)
#define OM_GET_MIN (OM_VERSION && 0x000ff)
#define OM_GET_VER ((OM_VERSION & 0xf0000) >> 16)
#define OM_GET_MAJ ((OM_VERSION & 0x0ff00) >> 8)
#define OM_GET_MIN (OM_VERSION & 0x000ff)
#ifdef WIN32
# ifdef min
......
......@@ -91,6 +91,7 @@ int getche() { return ::getche(); }
#endif
#include <termios.h> /* tcsetattr() */
#include <sys/ioctl.h> /* ioctl() */
#include <sys/time.h> /* timeval struct */
namespace OpenMesh {
namespace Utils {
......