Pixyco-XYZ/openmesh
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Changed OpenMesh directory structure

Browse Source 
git-svn-id: http://www.openmesh.org/svnrepo/OpenMesh/trunk@106 fdac6126-5c0c-442c-9429-916003d36597
This commit is contained in:
Jan Möbius
2009-04-30 12:41:50 +00:00
parent 6b48ca6090
commit ea844d6788
310 changed files with 20 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
src/OpenMesh/Core/Utils/ACGMakefile Normal file
View File

@@ -0,0 +1,17 @@
#== SYSTEM PART -- DON'T TOUCH ==============================================
include $(ACGMAKE)/Config
#==============================================================================
SUBDIRS = $(call find-subdirs)
PACKAGES :=
PROJ_LIBS :=
MODULES := cxxlib
#== SYSTEM PART -- DON'T TOUCH ==============================================
include $(ACGMAKE)/Rules
#==============================================================================

115
src/OpenMesh/Core/Utils/AutoPropertyHandleT.hh Normal file
View File

@@ -0,0 +1,115 @@
/*===========================================================================*\
* *
* OpenMesh *
* Copyright (C) 2001-2004 by Computer Graphics Group, RWTH Aachen *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
* *
* License *
* *
* This library is free software; you can redistribute it and/or modify it *
* under the terms of the GNU Lesser General Public License as published *
* by the Free Software Foundation, version 2.1. *
* *
* This library is distributed in the hope that it will be useful, but *
* WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this library; if not, write to the Free Software *
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
* *
\*===========================================================================*/
#ifndef OPENMESH_AutoPropertyHandleT_HH
#define OPENMESH_AutoPropertyHandleT_HH
//== INCLUDES =================================================================
#include <assert.h>
#include <string>
//== NAMESPACES ===============================================================
namespace OpenMesh {
//== CLASS DEFINITION =========================================================
template <class Mesh_, class PropertyHandle_>
class AutoPropertyHandleT : public PropertyHandle_
{
public:
typedef Mesh_ Mesh;
typedef PropertyHandle_ PropertyHandle;
typedef PropertyHandle Base;
typedef typename PropertyHandle::Value Value;
typedef AutoPropertyHandleT<Mesh, PropertyHandle>
Self;
protected:
Mesh* m_;
bool own_property_;//ref counting?
public:
AutoPropertyHandleT()
: m_(NULL), own_property_(false)
{}
AutoPropertyHandleT(const Self& _other)
: Base(_other.idx()), m_(_other.m_), own_property_(false)
{}
explicit AutoPropertyHandleT(Mesh& _m, const std::string& _pp_name = std::string())
{ add_property(_m, _pp_name); }
AutoPropertyHandleT(Mesh& _m, PropertyHandle _pph)
: Base(_pph.idx()), m_(&_m), own_property_(false)
{}
~AutoPropertyHandleT()
{
if (own_property_)
{
m_->remove_property(*this);
}
}
inline void add_property(Mesh& _m, const std::string& _pp_name = std::string())
{
assert(!is_valid());
m_ = &_m;
own_property_ = _pp_name.empty() || !m_->get_property_handle(*this, _pp_name);
if (own_property_)
{
m_->add_property(*this, _pp_name);
}
}
inline void remove_property()
{
assert(own_property_);//only the owner can delete the property
m_->remove_property(*this);
own_property_ = false;
invalidate();
}
template <class _Handle>
inline Value& operator [] (_Handle _hnd)
{ return m_->property(*this, _hnd); }
template <class _Handle>
inline const Value& operator [] (_Handle _hnd) const
{ return m_->property(*this, _hnd); }
inline bool own_property() const
{ return own_property_; }
inline void free_property()
{ own_property_ = false; }
};
//=============================================================================
} // namespace OpenMesh
//=============================================================================
#endif // OPENMESH_AutoPropertyHandleT_HH defined
//=============================================================================

37
src/OpenMesh/Core/Utils/BaseProperty.cc Normal file
View File

@@ -0,0 +1,37 @@
/*===========================================================================*\
* *
* OpenMesh *
* Copyright (C) 2001-2003 by Computer Graphics Group, RWTH Aachen *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
* *
* License *
* *
* This library is free software; you can redistribute it and/or modify it *
* under the terms of the GNU Lesser General Public License as published *
* by the Free Software Foundation, version 2.1. *
* *
* This library is distributed in the hope that it will be useful, but *
* WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this library; if not, write to the Free Software *
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
* *
\*===========================================================================*/
#include <OpenMesh/Core/Utils/BaseProperty.hh>
#include <iostream>
namespace OpenMesh
{
void BaseProperty::stats(std::ostream& _ostr) const
{
_ostr << " " << name() << (persistent() ? ", persistent " : "") << "\n";
}
}

159
src/OpenMesh/Core/Utils/BaseProperty.hh Normal file
View File

@@ -0,0 +1,159 @@
/*===========================================================================*\
* *
* OpenMesh *
* Copyright (C) 2004 by Computer Graphics Group, RWTH Aachen *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
* *
* License *
* *
* This library is free software; you can redistribute it and/or modify it *
* under the terms of the GNU Lesser General Public License as published *
* by the Free Software Foundation, version 2.1. *
* *
* This library is distributed in the hope that it will be useful, but *
* WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this library; if not, write to the Free Software *
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
* *
\*===========================================================================*/
#ifndef OPENMESH_BASEPROPERTY_HH
#define OPENMESH_BASEPROPERTY_HH
#include <string>
#include <OpenMesh/Core/IO/StoreRestore.hh>
#include <OpenMesh/Core/System/omstream.hh>
namespace OpenMesh {
//== CLASS DEFINITION =========================================================
/** \class BaseProperty Property.hh <OpenMesh/Core/Utils/PropertyT.hh>
Abstract class defining the basic interface of a dynamic property.
**/
class BaseProperty
{
public:
/// Indicates an error when a size is returned by a member.
static const size_t UnknownSize = size_t(-1);
public:
/// \brief Default constructor.
///
/// In %OpenMesh all mesh data is stored in so-called properties.
/// We distinuish between standard properties, which can be defined at
/// compile time using the Attributes in the traits definition and
/// at runtime using the request property functions defined in one of
/// the kernels.
///
/// If the property should be stored along with the default properties
/// in the OM-format one must name the property and enable the persistant
/// flag with set_persistent().
///
/// \param _name Optional textual name for the property.
///
BaseProperty(const std::string& _name = "<unknown>")
: name_(_name), persistent_(false)
{}
/// \brief Copy constructor
BaseProperty(const BaseProperty & _rhs)
: name_( _rhs.name_ ), persistent_( _rhs.persistent_ ) {}
/// Destructor.
virtual ~BaseProperty() {}
public: // synchronized array interface
/// Reserve memory for n elements.
virtual void reserve(size_t _n) = 0;
/// Resize storage to hold n elements.
virtual void resize(size_t _n) = 0;
/// Extend the number of elements by one.
virtual void push_back() = 0;
/// Let two elements swap their storage place.
virtual void swap(size_t _i0, size_t _i1) = 0;
/// Return a deep copy of self.
virtual BaseProperty* clone () const = 0;
public: // named property interface
/// Return the name of the property
const std::string& name() const { return name_; }
virtual void stats(std::ostream& _ostr) const;
public: // I/O support
/// Returns true if the persistent flag is enabled else false.
bool persistent(void) const { return persistent_; }
/// Enable or disable persistency. Self must be a named property to enable
/// persistency.
virtual void set_persistent( bool _yn ) = 0;
/// Number of elements in property
virtual size_t n_elements() const = 0;
/// Size of one element in bytes or UnknownSize if not known.
virtual size_t element_size() const = 0;
/// Return size of property in bytes
virtual size_t size_of() const
{
return size_of( n_elements() );
}
/// Estimated size of property if it has _n_elem elements.
/// The member returns UnknownSize if the size cannot be estimated.
virtual size_t size_of(size_t _n_elem) const
{
return (element_size()!=UnknownSize)
? (_n_elem*element_size())
: UnknownSize;
}
/// Store self as one binary block
virtual size_t store( std::ostream& _ostr, bool _swap ) const = 0;
/** Restore self from a binary block. Uses reserve() to set the
size of self before restoring.
**/
virtual size_t restore( std::istream& _istr, bool _swap ) = 0;
protected:
// To be used in a derived class, when overloading set_persistent()
template < typename T >
void check_and_set_persistent( bool _yn )
{
if ( _yn && !IO::is_streamable<T>() )
omerr() << "Warning! Type of property value is not binary storable!\n";
persistent_ = IO::is_streamable<T>() && _yn;
}
private:
std::string name_;
bool persistent_;
};
}//namespace OpenMesh
#endif //OPENMESH_BASEPROPERTY_HH

70
src/OpenMesh/Core/Utils/Endian.cc Normal file
View File

@@ -0,0 +1,70 @@
//=============================================================================
//
// OpenMesh
// Copyright (C) 2003 by Computer Graphics Group, RWTH Aachen
// www.openmesh.org
//
//-----------------------------------------------------------------------------
//
// License
//
// This library is free software; you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, version 2.1.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//
//-----------------------------------------------------------------------------
//
// $Revision$
// $Date$
//
//=============================================================================
//=============================================================================
//
// Helper Functions for binary reading / writing
//
//=============================================================================
//== INCLUDES =================================================================
#include <iostream>
#include <algorithm>
#include <OpenMesh/Core/Utils/Endian.hh>
//== NAMESPACES ===============================================================
namespace OpenMesh {
//== IMPLEMENTATION ===========================================================
//-----------------------------------------------------------------------------
int Endian::one_ = 1;
const Endian::Type Endian::local_ = *((unsigned char*)&Endian::one_)
? Endian::LSB
: Endian::MSB;
const char * Endian::as_string(Type _t)
{
return _t == LSB ? "LSB" : "MSB";
}
//=============================================================================
} // namespace OpenMesh
//=============================================================================

86
src/OpenMesh/Core/Utils/Endian.hh Normal file
View File

@@ -0,0 +1,86 @@
//=============================================================================
//
// OpenMesh
// Copyright (C) 2003 by Computer Graphics Group, RWTH Aachen
// www.openmesh.org
//
//-----------------------------------------------------------------------------
//
// License
//
// This library is free software; you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, version 2.1.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//
//-----------------------------------------------------------------------------
//
// $Revision$
// $Date$
//
//=============================================================================
//=============================================================================
//
// Helper Functions for binary reading / writing
//
//=============================================================================
#ifndef OPENMESH_UTILS_ENDIAN_HH
#define OPENMESH_UTILS_ENDIAN_HH
//== INCLUDES =================================================================
#include <OpenMesh/Core/System/config.h>
#include <iostream>
//== NAMESPACES ===============================================================
namespace OpenMesh {
//=============================================================================
/** Determine byte order of host system.
*/
class Endian
{
public:
enum Type {
LSB = 1, ///< Little endian (Intel family and clones)
MSB ///< big endian (Motorola's 68x family, DEC Alpha, MIPS)
};
/// Return endian type of host system.
static Type local() { return local_; }
/// Return type _t as string.
static const char * as_string(Type _t);
private:
static int one_;
static const Type local_;
};
//=============================================================================
} // namespace OpenMesh
//=============================================================================
#endif // OPENMESH_MESHREADER_HH defined
//=============================================================================

147
src/OpenMesh/Core/Utils/GenProg.hh Normal file
View File

@@ -0,0 +1,147 @@
//=============================================================================
//
// OpenMesh
// Copyright (C) 2003 by Computer Graphics Group, RWTH Aachen
// www.openmesh.org
//
//-----------------------------------------------------------------------------
//
// License
//
// This library is free software; you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, version 2.1.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//
//-----------------------------------------------------------------------------
//
// $Revision$
// $Date$
//
//=============================================================================
//=============================================================================
//
// Utils for generic/generative programming
//
//=============================================================================
#ifndef OPENMESH_GENPROG_HH
#define OPENMESH_GENPROG_HH
//== INCLUDES =================================================================
#include <OpenMesh/Core/System/config.h>
//== NAMESPACES ===============================================================
namespace OpenMesh {
namespace GenProg {
#ifndef DOXY_IGNORE_THIS
//== IMPLEMENTATION ===========================================================
/// This type maps \c true or \c false to different types.
template <bool b> struct Bool2Type { enum { my_bool = b }; };
/// This class generates different types from different \c int 's.
template <int i> struct Int2Type { enum { my_int = i }; };
/// Handy typedef for Bool2Type<true> classes
typedef Bool2Type<true> True;
/// Handy typedef for Bool2Type<false> classes
typedef Bool2Type<false> False;
//-----------------------------------------------------------------------------
/// compile time assertions
template <bool Expr> struct AssertCompile;
template <> struct AssertCompile<true> {};
//--- Template "if" w/ partial specialization ---------------------------------
#if OM_PARTIAL_SPECIALIZATION
template <bool condition, class Then, class Else>
struct IF { typedef Then Result; };
/** Template \c IF w/ partial specialization
\code
typedef IF<bool, Then, Else>::Result ResultType;
\endcode
*/
template <class Then, class Else>
struct IF<false, Then, Else> { typedef Else Result; };
//--- Template "if" w/o partial specialization --------------------------------
#else
struct SelectThen
{
template <class Then, class Else> struct Select {
typedef Then Result;
};
};
struct SelectElse
{
template <class Then, class Else> struct Select {
typedef Else Result;
};
};
template <bool condition> struct ChooseSelector {
typedef SelectThen Result;
};
template <> struct ChooseSelector<false> {
typedef SelectElse Result;
};
/** Template \c IF w/o partial specialization. Use it like
\code
typedef IF<bool, Then, Else>::Result ResultType;
\endcode
*/
template <bool condition, class Then, class Else>
class IF
{
typedef typename ChooseSelector<condition>::Result Selector;
public:
typedef typename Selector::template Select<Then, Else>::Result Result;
};
#endif
//=============================================================================
#endif
} // namespace GenProg
} // namespace OpenMesh
#define assert_compile(EXPR) GenProg::AssertCompile<(EXPR)>();
//=============================================================================
#endif // OPENMESH_GENPROG_HH defined
//=============================================================================

76
src/OpenMesh/Core/Utils/Noncopyable.hh Normal file
View File

@@ -0,0 +1,76 @@
//=============================================================================
//
// OpenMesh
// Copyright (C) 2003 by Computer Graphics Group, RWTH Aachen
// www.openmesh.org
//
//-----------------------------------------------------------------------------
//
// License
//
// This library is free software; you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, version 2.1.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//
//-----------------------------------------------------------------------------
//
// $Revision$
// $Date$
//
//=============================================================================
//=============================================================================
//
// Implements the Non-Copyable metapher
//
//=============================================================================
#ifndef OPENMESH_NONCOPYABLE_HH
#define OPENMESH_NONCOPYABLE_HH
//-----------------------------------------------------------------------------
#include <OpenMesh/Core/System/config.h>
//-----------------------------------------------------------------------------
namespace OpenMesh {
namespace Utils {
//-----------------------------------------------------------------------------
/** This class demonstrates the non copyable idiom. In some cases it is
important an object can't be copied. Deriving from Noncopyable makes sure
all relevant constructor and operators are made inaccessable, for public
AND derived classes.
**/
class Noncopyable
{
public:
Noncopyable() { }
private:
/// Prevent access to copy constructor
Noncopyable( const Noncopyable& );
/// Prevent access to assignment operator
const Noncopyable& operator=( const Noncopyable& );
};
//=============================================================================
} // namespace Utils
} // namespace OpenMesh
//=============================================================================
#endif // OPENMESH_NONCOPYABLE_HH
//=============================================================================

512
src/OpenMesh/Core/Utils/Property.hh Normal file
View File

@@ -0,0 +1,512 @@
/*===========================================================================*\
* *
* OpenMesh *
* Copyright (C) 2001-2003 by Computer Graphics Group, RWTH Aachen *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
* *
* License *
* *
* This library is free software; you can redistribute it and/or modify it *
* under the terms of the GNU Lesser General Public License as published *
* by the Free Software Foundation, version 2.1. *
* *
* This library is distributed in the hope that it will be useful, but *
* WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this library; if not, write to the Free Software *
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
* *
\*===========================================================================*/
#ifndef OPENMESH_PROPERTY_HH
#define OPENMESH_PROPERTY_HH
//== INCLUDES =================================================================
#include <OpenMesh/Core/System/config.h>
#include <OpenMesh/Core/Mesh/Handles.hh>
#include <OpenMesh/Core/Utils/BaseProperty.hh>
#include <vector>
#include <string>
#include <algorithm>
//== NAMESPACES ===============================================================
namespace OpenMesh {
//== CLASS DEFINITION =========================================================
/** \class PropertyT Property.hh <OpenMesh/Core/Utils/PropertyT.hh>
*
* \brief Default property class for any type T.
*
* The default property class for any type T.
*
* The property supports persistency if T is a "fundamental" type:
* - integer fundamental types except bool:
* char, short, int, long, long long (__int64 for MS VC++) and
* their unsigned companions.
* - float fundamentals except <tt>long double</tt>:
* float, double
* - %OpenMesh vector types
*
* Persistency of non-fundamental types is supported if and only if a
* specialization of struct IO::binary<> exists for the wanted type.
*/
// TODO: it might be possible to define Property using kind of a runtime info
// structure holding the size of T. Then reserve, swap, resize, etc can be written
// in pure malloc() style w/o virtual overhead. Template member function proved per
// element access to the properties, asserting dynamic_casts in debug
template <class T>
class PropertyT : public BaseProperty
{
public:
typedef T Value;
typedef std::vector<T> vector_type;
typedef T value_type;
typedef typename vector_type::reference reference;
typedef typename vector_type::const_reference const_reference;
public:
/// Default constructor
PropertyT(const std::string& _name = "<unknown>")
: BaseProperty(_name)
{}
/// Copy constructor
PropertyT(const PropertyT & _rhs)
: BaseProperty( _rhs ), data_( _rhs.data_ ) {}
public: // inherited from BaseProperty
virtual void reserve(size_t _n) { data_.reserve(_n); }
virtual void resize(size_t _n) { data_.resize(_n); }
virtual void push_back() { data_.push_back(T()); }
virtual void swap(size_t _i0, size_t _i1)
{ std::swap(data_[_i0], data_[_i1]); }
public:
virtual void set_persistent( bool _yn )
{ check_and_set_persistent<T>( _yn ); }
virtual size_t n_elements() const { return data_.size(); }
virtual size_t element_size() const { return IO::size_of<T>(); }
#ifndef DOXY_IGNORE_THIS
struct plus {
size_t operator () ( size_t _b, const T& _v )
{ return _b + IO::size_of<T>(_v); }
};
#endif
virtual size_t size_of(void) const
{
if (element_size() != IO::UnknownSize)
return this->BaseProperty::size_of(n_elements());
return std::accumulate(data_.begin(), data_.end(), 0, plus());
}
virtual size_t size_of(size_t _n_elem) const
{ return this->BaseProperty::size_of(_n_elem); }
virtual size_t store( std::ostream& _ostr, bool _swap ) const
{
if ( IO::is_streamable<vector_type>() )
return IO::store(_ostr, data_, _swap );
size_t bytes = 0;
for (size_t i=0; i<n_elements(); ++i)
bytes += IO::store( _ostr, data_[i], _swap );
return bytes;
}
virtual size_t restore( std::istream& _istr, bool _swap )
{
if ( IO::is_streamable<vector_type>() )
return IO::restore(_istr, data_, _swap );
size_t bytes = 0;
for (size_t i=0; i<n_elements(); ++i)
bytes += IO::restore( _istr, data_[i], _swap );
return bytes;
}
public: // data access interface
/// Get pointer to array (does not work for T==bool)
const T* data() const {
if( data_.empty() )
return 0;
return &data_[0];
}
/// Access the i'th element. No range check is performed!
reference operator[](int _idx)
{
assert( size_t(_idx) < data_.size() );
return data_[_idx];
}
/// Const access to the i'th element. No range check is performed!
const_reference operator[](int _idx) const
{
assert( size_t(_idx) < data_.size());
return data_[_idx];
}
/// Make a copy of self.
PropertyT<T>* clone() const
{
PropertyT<T>* p = new PropertyT<T>( *this );
return p;
}
private:
vector_type data_;
};
//-----------------------------------------------------------------------------
/** \class PropertyT<bool> Property.hh <OpenMesh/Core/Utils/PropertyT.hh>
Property specialization for bool type. The data will be stored as
a bitset.
*/
template <>
class PropertyT<bool> : public BaseProperty
{
public:
typedef std::vector<bool> vector_type;
typedef bool value_type;
typedef vector_type::reference reference;
typedef vector_type::const_reference const_reference;
public:
PropertyT(const std::string& _name = "<unknown>")
: BaseProperty(_name)
{ }
public: // inherited from BaseProperty
virtual void reserve(size_t _n) { data_.reserve(_n); }
virtual void resize(size_t _n) { data_.resize(_n); }
virtual void push_back() { data_.push_back(bool()); }
virtual void swap(size_t _i0, size_t _i1)
{ bool t(data_[_i0]); data_[_i0]=data_[_i1]; data_[_i1]=t; }
public:
virtual void set_persistent( bool _yn )
{
check_and_set_persistent<bool>( _yn );
}
virtual size_t n_elements() const { return data_.size(); }
virtual size_t element_size() const { return UnknownSize; }
virtual size_t size_of() const { return size_of( n_elements() ); }
virtual size_t size_of(size_t _n_elem) const
{
return _n_elem / 8 + ((_n_elem % 8)!=0);
}
size_t store( std::ostream& _ostr, bool /* _swap */ ) const
{
size_t bytes = 0;
size_t N = data_.size() / 8;
size_t R = data_.size() % 8;
size_t idx; // element index
size_t bidx;
unsigned char bits; // bitset
for (bidx=idx=0; idx < N; ++idx, bidx+=8)
{
bits = !!data_[bidx]
| (!!data_[bidx+1] << 1)
| (!!data_[bidx+2] << 2)
| (!!data_[bidx+3] << 3)
| (!!data_[bidx+4] << 4)
| (!!data_[bidx+5] << 5)
| (!!data_[bidx+6] << 6)
| (!!data_[bidx+7] << 7);
_ostr << bits;
}
bytes = N;
if (R)
{
bits = 0;
for (idx=0; idx < R; ++idx)
bits |= !!data_[bidx+idx] << idx;
_ostr << bits;
++bytes;
}
std::cout << std::endl;
assert( bytes == size_of() );
return bytes;
}
size_t restore( std::istream& _istr, bool /* _swap */ )
{
size_t bytes = 0;
size_t N = data_.size() / 8;
size_t R = data_.size() % 8;
size_t idx; // element index
size_t bidx; //
unsigned char bits; // bitset
for (bidx=idx=0; idx < N; ++idx, bidx+=8)
{
_istr >> bits;
data_[bidx+0] = !!(bits & 0x01);
data_[bidx+1] = !!(bits & 0x02);
data_[bidx+2] = !!(bits & 0x04);
data_[bidx+3] = !!(bits & 0x08);
data_[bidx+4] = !!(bits & 0x10);
data_[bidx+5] = !!(bits & 0x20);
data_[bidx+6] = !!(bits & 0x40);
data_[bidx+7] = !!(bits & 0x80);
}
bytes = N;
if (R)
{
_istr >> bits;
for (idx=0; idx < R; ++idx)
data_[bidx+idx] = !!(bits & (1<<idx));
++bytes;
}
std::cout << std::endl;
return bytes;
}
public:
/// Access the i'th element. No range check is performed!
reference operator[](int _idx)
{
assert( size_t(_idx) < data_.size() );
return data_[_idx];
}
/// Const access to the i'th element. No range check is performed!
const_reference operator[](int _idx) const
{
assert( size_t(_idx) < data_.size());
return data_[_idx];
}
/// Make a copy of self.
PropertyT<bool>* clone() const
{
PropertyT<bool>* p = new PropertyT<bool>( *this );
return p;
}
private:
vector_type data_;
};
//-----------------------------------------------------------------------------
/** \class PropertyT<std::string> Property.hh <OpenMesh/Core/Utils/PropertyT.hh>
Property specialization for std::string type.
*/
template <>
class PropertyT<std::string> : public BaseProperty
{
public:
typedef std::string Value;
typedef std::vector<std::string> vector_type;
typedef std::string value_type;
typedef vector_type::reference reference;
typedef vector_type::const_reference const_reference;
public:
PropertyT(const std::string& _name = "<unknown>")
: BaseProperty(_name)
{ }
public: // inherited from BaseProperty
virtual void reserve(size_t _n) { data_.reserve(_n); }
virtual void resize(size_t _n) { data_.resize(_n); }
virtual void push_back() { data_.push_back(std::string()); }
virtual void swap(size_t _i0, size_t _i1) {
std::swap(data_[_i0], data_[_i1]);
}
public:
virtual void set_persistent( bool _yn )
{ check_and_set_persistent<std::string>( _yn ); }
virtual size_t n_elements() const { return data_.size(); }
virtual size_t element_size() const { return UnknownSize; }
virtual size_t size_of() const
{ return IO::size_of( data_ ); }
virtual size_t size_of(size_t /* _n_elem */) const
{ return UnknownSize; }
/// Store self as one binary block. Max. length of a string is 65535 bytes.
size_t store( std::ostream& _ostr, bool _swap ) const
{ return IO::store( _ostr, data_, _swap ); }
size_t restore( std::istream& _istr, bool _swap )
{ return IO::restore( _istr, data_, _swap ); }
public:
const value_type* data() const {
if( data_.empty() )
return 0;
return (value_type*) &data_[0];
}
/// Access the i'th element. No range check is performed!
reference operator[](int _idx) {
assert( size_t(_idx) < data_.size());
return ((value_type*) &data_[0])[_idx];
}
/// Const access the i'th element. No range check is performed!
const_reference operator[](int _idx) const {
assert( size_t(_idx) < data_.size());
return ((value_type*) &data_[0])[_idx];
}
PropertyT<value_type>* clone() const {
PropertyT<value_type>* p = new PropertyT<value_type>( *this );
return p;
}
private:
vector_type data_;
};
/// Base property handle.
template <class T>
struct BasePropHandleT : public BaseHandle
{
typedef T Value;
typedef std::vector<T> vector_type;
typedef T value_type;
typedef typename vector_type::reference reference;
typedef typename vector_type::const_reference const_reference;
explicit BasePropHandleT(int _idx=-1) : BaseHandle(_idx) {}
};
/** \ingroup mesh_property_handle_group
* Handle representing a vertex property
*/
template <class T>
struct VPropHandleT : public BasePropHandleT<T>
{
typedef T Value;
typedef T value_type;
explicit VPropHandleT(int _idx=-1) : BasePropHandleT<T>(_idx) {}
explicit VPropHandleT(const BasePropHandleT<T>& _b) : BasePropHandleT<T>(_b) {}
};
/** \ingroup mesh_property_handle_group
* Handle representing a halfedge property
*/
template <class T>
struct HPropHandleT : public BasePropHandleT<T>
{
typedef T Value;
typedef T value_type;
explicit HPropHandleT(int _idx=-1) : BasePropHandleT<T>(_idx) {}
explicit HPropHandleT(const BasePropHandleT<T>& _b) : BasePropHandleT<T>(_b) {}
};
/** \ingroup mesh_property_handle_group
* Handle representing an edge property
*/
template <class T>
struct EPropHandleT : public BasePropHandleT<T>
{
typedef T Value;
typedef T value_type;
explicit EPropHandleT(int _idx=-1) : BasePropHandleT<T>(_idx) {}
explicit EPropHandleT(const BasePropHandleT<T>& _b) : BasePropHandleT<T>(_b) {}
};
/** \ingroup mesh_property_handle_group
* Handle representing a face property
*/
template <class T>
struct FPropHandleT : public BasePropHandleT<T>
{
typedef T Value;
typedef T value_type;
explicit FPropHandleT(int _idx=-1) : BasePropHandleT<T>(_idx) {}
explicit FPropHandleT(const BasePropHandleT<T>& _b) : BasePropHandleT<T>(_b) {}
};
/** \ingroup mesh_property_handle_group
* Handle representing a mesh property
*/
template <class T>
struct MPropHandleT : public BasePropHandleT<T>
{
typedef T Value;
typedef T value_type;
explicit MPropHandleT(int _idx=-1) : BasePropHandleT<T>(_idx) {}
explicit MPropHandleT(const BasePropHandleT<T>& _b) : BasePropHandleT<T>(_b) {}
};
} // namespace OpenMesh
//=============================================================================
#endif // OPENMESH_PROPERTY_HH defined
//=============================================================================

263
src/OpenMesh/Core/Utils/PropertyContainer.hh Normal file
View File

@@ -0,0 +1,263 @@
/*===========================================================================*\
* *
* OpenMesh *
* Copyright (C) 2004 by Computer Graphics Group, RWTH Aachen *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
* *
* License *
* *
* This library is free software; you can redistribute it and/or modify it *
* under the terms of the GNU Lesser General Public License as published *
* by the Free Software Foundation, version 2.1. *
* *
* This library is distributed in the hope that it will be useful, but *
* WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this library; if not, write to the Free Software *
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
* *
\*===========================================================================*/
#ifndef OPENMESH_PROPERTYCONTAINER
#define OPENMESH_PROPERTYCONTAINER
// Use static casts when not debugging
#ifdef NDEBUG
#define OM_FORCE_STATIC_CAST
#endif
#include <OpenMesh/Core/Utils/Property.hh>
//-----------------------------------------------------------------------------
namespace OpenMesh
{
//== FORWARDDECLARATIONS ======================================================
class BaseKernel;
//== CLASS DEFINITION =========================================================
/// A a container for properties.
class PropertyContainer
{
public:
//-------------------------------------------------- constructor / destructor
PropertyContainer() {}
virtual ~PropertyContainer() { clear(); }
//------------------------------------------------------------- info / access
typedef std::vector<BaseProperty*> Properties;
const Properties& properties() const { return properties_; }
size_t size() const { return properties_.size(); }
//--------------------------------------------------------- copy / assignment
PropertyContainer(const PropertyContainer& _rhs) { operator=(_rhs); }
PropertyContainer& operator=(const PropertyContainer& _rhs)
{
clear();
properties_ = _rhs.properties_;
Properties::iterator p_it=properties_.begin(), p_end=properties_.end();
for (; p_it!=p_end; ++p_it)
if (*p_it)
*p_it = (*p_it)->clone();
return *this;
}
//--------------------------------------------------------- manage properties
template <class T>
BasePropHandleT<T> add(const T&, const std::string& _name="<unknown>")
{
Properties::iterator p_it=properties_.begin(), p_end=properties_.end();
int idx=0;
for ( ; p_it!=p_end && *p_it!=NULL; ++p_it, ++idx ) {};
if (p_it==p_end) properties_.push_back(NULL);
properties_[idx] = new PropertyT<T>(_name);
return BasePropHandleT<T>(idx);
}
template <class T>
BasePropHandleT<T> handle(const T&, const std::string& _name) const
{
Properties::const_iterator p_it = properties_.begin();
for (int idx=0; p_it != properties_.end(); ++p_it, ++idx)
{
if (*p_it != NULL &&
(*p_it)->name() == _name //skip deleted properties
// Skip type check
#ifndef OM_FORCE_STATIC_CAST
&& dynamic_cast<PropertyT<T>*>(properties_[idx]) != NULL //check type
#endif
)
{
return BasePropHandleT<T>(idx);
}
}
return BasePropHandleT<T>();
}
BaseProperty* property( const std::string& _name ) const
{
Properties::const_iterator p_it = properties_.begin();
for (int idx=0; p_it != properties_.end(); ++p_it, ++idx)
{
if (*p_it != NULL && (*p_it)->name() == _name) //skip deleted properties
{
return *p_it;
}
}
return NULL;
}
template <class T> PropertyT<T>& property(BasePropHandleT<T> _h)
{
assert(_h.idx() >= 0 && _h.idx() < (int)properties_.size());
assert(properties_[_h.idx()] != NULL);
#ifdef OM_FORCE_STATIC_CAST
return *static_cast <PropertyT<T>*> (properties_[_h.idx()]);
#else
PropertyT<T>* p = dynamic_cast<PropertyT<T>*>(properties_[_h.idx()]);
assert(p != NULL);
return *p;
#endif
}
template <class T> const PropertyT<T>& property(BasePropHandleT<T> _h) const
{
assert(_h.idx() >= 0 && _h.idx() < (int)properties_.size());
assert(properties_[_h.idx()] != NULL);
#ifdef OM_FORCE_STATIC_CAST
return *static_cast<PropertyT<T>*>(properties_[_h.idx()]);
#else
PropertyT<T>* p = dynamic_cast<PropertyT<T>*>(properties_[_h.idx()]);
assert(p != NULL);
return *p;
#endif
}
template <class T> void remove(BasePropHandleT<T> _h)
{
assert(_h.idx() >= 0 && _h.idx() < (int)properties_.size());
delete properties_[_h.idx()];
properties_[_h.idx()] = NULL;
}
void clear()
{
std::for_each(properties_.begin(), properties_.end(), Delete());
}
//---------------------------------------------------- synchronize properties
void reserve(size_t _n) const {
std::for_each(properties_.begin(), properties_.end(), Reserve(_n));
}
void resize(size_t _n) const {
std::for_each(properties_.begin(), properties_.end(), Resize(_n));
}
void swap(size_t _i0, size_t _i1) const {
std::for_each(properties_.begin(), properties_.end(), Swap(_i0, _i1));
}
protected: // generic add/get
size_t _add( BaseProperty* _bp )
{
Properties::iterator p_it=properties_.begin(), p_end=properties_.end();
size_t idx=0;
for (; p_it!=p_end && *p_it!=NULL; ++p_it, ++idx) {};
if (p_it==p_end) properties_.push_back(NULL);
properties_[idx] = _bp;
return idx;
}
BaseProperty& _property( size_t _idx )
{
assert( _idx < properties_.size());
assert( properties_[_idx] != NULL);
BaseProperty *p = properties_[_idx];
assert( p != NULL );
return *p;
}
const BaseProperty& _property( size_t _idx ) const
{
assert( _idx < properties_.size());
assert( properties_[_idx] != NULL);
BaseProperty *p = properties_[_idx];
assert( p != NULL );
return *p;
}
typedef Properties::iterator iterator;
typedef Properties::const_iterator const_iterator;
iterator begin() { return properties_.begin(); }
iterator end() { return properties_.end(); }
const_iterator begin() const { return properties_.begin(); }
const_iterator end() const { return properties_.end(); }
friend class BaseKernel;
private:
//-------------------------------------------------- synchronization functors
#ifndef DOXY_IGNORE_THIS
struct Reserve
{
Reserve(size_t _n) : n_(_n) {}
void operator()(BaseProperty* _p) const { if (_p) _p->reserve(n_); }
size_t n_;
};
struct Resize
{
Resize(size_t _n) : n_(_n) {}
void operator()(BaseProperty* _p) const { if (_p) _p->resize(n_); }
size_t n_;
};
struct Swap
{
Swap(size_t _i0, size_t _i1) : i0_(_i0), i1_(_i1) {}
void operator()(BaseProperty* _p) const { if (_p) _p->swap(i0_, i1_); }
size_t i0_, i1_;
};
struct Delete
{
Delete() {}
void operator()(BaseProperty* _p) const { if (_p) delete _p; _p=NULL; }
};
#endif
Properties properties_;
};
}//namespace OpenMesh
#endif//OPENMESH_PROPERTYCONTAINER

62
src/OpenMesh/Core/Utils/SingletonT.cc Normal file
View File

@@ -0,0 +1,62 @@
/*===========================================================================*\
* *
* OpenMesh *
* Copyright (C) 2003 by Computer Graphics Group, RWTH Aachen *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
* *
* License *
* *
* This library is free software; you can redistribute it and/or modify it *
* under the terms of the GNU Lesser General Public License as published *
* by the Free Software Foundation, version 2.1. *
* *
* This library is distributed in the hope that it will be useful, but *
* WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this library; if not, write to the Free Software *
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
* *
\*===========================================================================*/
//=============================================================================
//
// Implements a simple singleton template
//
//=============================================================================
#define OPENMESH_SINGLETON_C
//== INCLUDES =================================================================
// header
#include <OpenMesh/Core/Utils/SingletonT.hh>
//== NAMESPACES ===============================================================
namespace OpenMesh {
//== SINGLETON'S DATA =========================================================
template <class T>
T* SingletonT<T>::pInstance__ = 0;
template <class T>
bool SingletonT<T>::destroyed__ = false;
//=============================================================================
} // namespace OpenMesh
//=============================================================================

132
src/OpenMesh/Core/Utils/SingletonT.hh Normal file
View File

@@ -0,0 +1,132 @@
/*===========================================================================*\
* *
* OpenMesh *
* Copyright (C) 2003 by Computer Graphics Group, RWTH Aachen *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
* *
* License *
* *
* This library is free software; you can redistribute it and/or modify it *
* under the terms of the GNU Lesser General Public License as published *
* by the Free Software Foundation, version 2.1. *
* *
* This library is distributed in the hope that it will be useful, but *
* WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this library; if not, write to the Free Software *
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
* *
\*===========================================================================*/
//=============================================================================
//
// Implements a simple singleton template
//
//=============================================================================
#ifndef __SINGLETON_HH__
#define __SINGLETON_HH__
//=== INCLUDES ================================================================
// OpenMesh
#include <OpenMesh/Core/System/config.h>
// STL
#include <stdexcept>
#include <iostream>
//== NAMESPACES ===============================================================
namespace OpenMesh {
//=== IMPLEMENTATION ==========================================================
/** A simple singleton template.
Encapsulates an arbitrary class and enforces its uniqueness.
*/
template <typename T>
class SingletonT
{
public:
/** Singleton access function.
Use this function to obtain a reference to the instance of the
encapsulated class. Note that this instance is unique and created
on the first call to Instance().
*/
static T& Instance()
{
if (!pInstance__)
{
// check if singleton alive
if (destroyed__)
{
OnDeadReference();
}
// first time request -> initialize
else
{
Create();
}
}
return *pInstance__;
}
private:
// Disable constructors/assignment to enforce uniqueness
SingletonT();
SingletonT(const SingletonT&);
SingletonT& operator=(const SingletonT&);
// Create a new singleton and store its pointer
static void Create()
{
static T theInstance;
pInstance__ = &theInstance;
}
// Will be called if instance is accessed after its lifetime has expired
static void OnDeadReference()
{
throw std::runtime_error("[Singelton error] - Dead reference detected!\n");
}
virtual ~SingletonT()
{
pInstance__ = 0;
destroyed__ = true;
}
static T* pInstance__;
static bool destroyed__;
};
//=============================================================================
} // namespace OpenMesh
//=============================================================================
#if defined(OM_INCLUDE_TEMPLATES) && !defined(OPENMESH_SINGLETON_C)
# define OPENMESH_SINGLETON_TEMPLATES
# include "SingletonT.cc"
#endif
//=============================================================================
#endif // __SINGLETON_HH__
//=============================================================================

235
src/OpenMesh/Core/Utils/color_cast.hh Normal file
View File

@@ -0,0 +1,235 @@
//=============================================================================
//
// OpenMesh
// Copyright (C) 2003 by Computer Graphics Group, RWTH Aachen
// www.openmesh.org
//
//-----------------------------------------------------------------------------
//
// License
//
// This library is free software; you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, version 2.1.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//
//-----------------------------------------------------------------------------
//
// $Revision$
// $Date$
//
//=============================================================================
//=============================================================================
//
// Helper Functions for binary reading / writing
//
//=============================================================================
#ifndef OPENMESH_COLOR_CAST_HH
#define OPENMESH_COLOR_CAST_HH
//== INCLUDES =================================================================
#include <OpenMesh/Core/System/config.h>
#include <OpenMesh/Core/Utils/vector_cast.hh>
//== NAMESPACES ===============================================================
namespace OpenMesh {
//=============================================================================
/** \name Cast vector type to another vector type.
*/
//@{
//-----------------------------------------------------------------------------
#ifndef DOXY_IGNORE_THIS
/// Cast one color vector to another.
template <typename dst_t, typename src_t>
struct color_caster
{
typedef dst_t return_type;
inline static return_type cast(const src_t& _src)
{
dst_t dst;
vector_copy(_src, dst, GenProg::Int2Type<vector_traits<dst_t>::size_>());
return dst;
}
};
template <>
struct color_caster<Vec3uc,Vec3f>
{
typedef Vec3uc return_type;
inline static return_type cast(const Vec3f& _src)
{
return Vec3uc( (unsigned char)(_src[0]* 255.0f + 0.5f),
(unsigned char)(_src[1]* 255.0f + 0.5f),
(unsigned char)(_src[2]* 255.0f + 0.5f) );
}
};
template <>
struct color_caster<Vec3uc,Vec4f>
{
typedef Vec3uc return_type;
inline static return_type cast(const Vec4f& _src)
{
return Vec3uc( (unsigned char)(_src[0]* 255.0f + 0.5f),
(unsigned char)(_src[1]* 255.0f + 0.5f),
(unsigned char)(_src[2]* 255.0f + 0.5f) );
}
};
template <>
struct color_caster<Vec4uc,Vec3f>
{
typedef Vec4uc return_type;
inline static return_type cast(const Vec3f& _src)
{
return Vec4uc( (unsigned char)(_src[0]* 255.0f + 0.5f),
(unsigned char)(_src[1]* 255.0f + 0.5f),
(unsigned char)(_src[2]* 255.0f + 0.5f),
(unsigned char)(255) );
}
};
template <>
struct color_caster<Vec4uc,Vec4f>
{
typedef Vec4uc return_type;
inline static return_type cast(const Vec4f& _src)
{
return Vec4uc( (unsigned char)(_src[0]* 255.0f + 0.5f),
(unsigned char)(_src[1]* 255.0f + 0.5f),
(unsigned char)(_src[2]* 255.0f + 0.5f),
(unsigned char)(_src[3]* 255.0f + 0.5f) );
}
};
template <>
struct color_caster<Vec4uc,Vec3uc>
{
typedef Vec4uc return_type;
inline static return_type cast(const Vec3uc& _src)
{
return Vec4uc( _src[0], _src[1], _src[2], 255 );
}
};
template <>
struct color_caster<Vec3f, Vec3uc>
{
typedef Vec3f return_type;
inline static return_type cast(const Vec3uc& _src)
{
const float f = 1.0f / 255.0f;
return Vec3f(_src[0] * f, _src[1] * f, _src[2] * f );
}
};
template <>
struct color_caster<Vec3f, Vec4uc>
{
typedef Vec3f return_type;
inline static return_type cast(const Vec4uc& _src)
{
const float f = 1.0f / 255.0f;
return Vec3f(_src[0] * f, _src[1] * f, _src[2] * f );
}
};
template <>
struct color_caster<Vec4f, Vec3uc>
{
typedef Vec4f return_type;
inline static return_type cast(const Vec3uc& _src)
{
const float f = 1.0f / 255.0f;
return Vec4f(_src[0] * f, _src[1] * f, _src[2] * f, 1.0f );
}
};
template <>
struct color_caster<Vec4f, Vec4uc>
{
typedef Vec4f return_type;
inline static return_type cast(const Vec4uc& _src)
{
const float f = 1.0f / 255.0f;
return Vec4f(_src[0] * f, _src[1] * f, _src[2] * f, _src[3] * f );
}
};
// ----------------------------------------------------------------------------
#ifndef DOXY_IGNORE_THIS
#if !defined(OM_CC_MSVC)
template <typename dst_t>
struct color_caster<dst_t,dst_t>
{
typedef const dst_t& return_type;
inline static return_type cast(const dst_t& _src)
{
return _src;
}
};
#endif
#endif
//-----------------------------------------------------------------------------
template <typename dst_t, typename src_t>
inline
typename color_caster<dst_t, src_t>::return_type
color_cast(const src_t& _src )
{
return color_caster<dst_t, src_t>::cast(_src);
}
#endif
//-----------------------------------------------------------------------------
//@}
//=============================================================================
} // namespace OpenMesh
//=============================================================================
#endif // OPENMESH_COLOR_CAST_HH defined
//=============================================================================

172
src/OpenMesh/Core/Utils/vector_cast.hh Normal file
View File

@@ -0,0 +1,172 @@
//=============================================================================
//
// OpenMesh
// Copyright (C) 2003 by Computer Graphics Group, RWTH Aachen
// www.openmesh.org
//
//-----------------------------------------------------------------------------
//
// License
//
// This library is free software; you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, version 2.1.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//
//-----------------------------------------------------------------------------
//
// $Revision$
// $Date$
//
//=============================================================================
//=============================================================================
//
// Helper Functions for binary reading / writing
//
//=============================================================================
#ifndef OPENMESH_VECTORCAST_HH
#define OPENMESH_VECTORCAST_HH
//== INCLUDES =================================================================
#include <OpenMesh/Core/System/config.h>
#include <OpenMesh/Core/Utils/vector_traits.hh>
#include <OpenMesh/Core/Utils/GenProg.hh>
#include <iostream>
#include <algorithm>
#include <OpenMesh/Core/Geometry/VectorT.hh>
//== NAMESPACES ===============================================================
namespace OpenMesh {
//=============================================================================
/** \name Cast vector type to another vector type.
*/
//@{
//-----------------------------------------------------------------------------
template <typename src_t, typename dst_t>
inline void vector_copy( const src_t &_src, dst_t &_dst, GenProg::Int2Type<1> )
{
_dst[0] = _src[0];
}
template <typename src_t, typename dst_t>
inline void vector_copy( const src_t &_src, dst_t &_dst, GenProg::Int2Type<2> )
{
_dst[0] = _src[0];
_dst[1] = _src[1];
}
template <typename src_t, typename dst_t>
inline void vector_copy( const src_t &_src, dst_t &_dst, GenProg::Int2Type<3> )
{
_dst[0] = _src[0];
_dst[1] = _src[1];
_dst[2] = _src[2];
}
template <typename src_t, typename dst_t>
inline void vector_copy( const src_t &_src, dst_t &_dst, GenProg::Int2Type<4> )
{
_dst[0] = _src[0];
_dst[1] = _src[1];
_dst[2] = _src[2];
_dst[3] = _src[3];
}
template <typename src_t, typename dst_t>
inline void vector_copy( const src_t &_src, dst_t &_dst, GenProg::Int2Type<5> )
{
_dst[0] = _src[0];
_dst[1] = _src[1];
_dst[2] = _src[2];
_dst[3] = _src[3];
_dst[4] = _src[4];
}
template <typename src_t, typename dst_t>
inline void vector_copy( const src_t &_src, dst_t &_dst, GenProg::Int2Type<6> )
{
_dst[0] = _src[0];
_dst[1] = _src[1];
_dst[2] = _src[2];
_dst[3] = _src[3];
_dst[4] = _src[4];
_dst[5] = _src[5];
}
//-----------------------------------------------------------------------------
#ifndef DOXY_IGNORE_THIS
template <typename dst_t, typename src_t>
struct vector_caster
{
typedef dst_t return_type;
inline static return_type cast(const src_t& _src)
{
dst_t dst;
vector_copy(_src, dst, GenProg::Int2Type<vector_traits<dst_t>::size_>());
return dst;
}
};
#if !defined(OM_CC_MSVC)
template <typename dst_t>
struct vector_caster<dst_t,dst_t>
{
typedef const dst_t& return_type;
inline static return_type cast(const dst_t& _src)
{
return _src;
}
};
#endif
#endif
//-----------------------------------------------------------------------------
/// Cast vector type to another vector type by copying the vector elements
template <typename dst_t, typename src_t>
inline
typename vector_caster<dst_t, src_t>::return_type
vector_cast(const src_t& _src )
{
return vector_caster<dst_t, src_t>::cast(_src);
}
//@}
//=============================================================================
} // namespace OpenMesh
//=============================================================================
#endif // OPENMESH_MESHREADER_HH defined
//=============================================================================

97
src/OpenMesh/Core/Utils/vector_traits.hh Normal file
View File

@@ -0,0 +1,97 @@
//=============================================================================
//
// OpenMesh
// Copyright (C) 2003 by Computer Graphics Group, RWTH Aachen
// www.openmesh.org
//
//-----------------------------------------------------------------------------
//
// License
//
// This library is free software; you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, version 2.1.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//
//-----------------------------------------------------------------------------
//
// $Revision$
// $Date$
//
//=============================================================================
//=============================================================================
//
// Helper Functions for binary reading / writing
//
//=============================================================================
#ifndef OPENMESH_VECTOR_TRAITS_HH
#define OPENMESH_VECTOR_TRAITS_HH
//== INCLUDES =================================================================
#include <OpenMesh/Core/System/config.h>
#include <OpenMesh/Core/Utils/GenProg.hh>
#if defined(OM_CC_MIPS)
# include <stdlib.h>
#else
# include <cstdlib>
#endif
//== NAMESPACES ===============================================================
namespace OpenMesh {
//=============================================================================
/** \name Provide a standardized access to relevant information about a
vector type.
*/
//@{
//-----------------------------------------------------------------------------
/** Helper class providing information about a vector type.
*
* If want to use a different vector type than the one provided %OpenMesh
* you need to supply a specialization of this class for the new vector type.
*/
template <typename T>
struct vector_traits
{
/// Type of the vector class
typedef typename T::vector_type vector_type;
/// Type of the scalar value
typedef typename T::value_type value_type;
/// size/dimension of the vector
static const size_t size_ = T::size_;
/// size/dimension of the vector
static size_t size() { return size_; }
};
//@}
//=============================================================================
} // namespace OpenMesh
//=============================================================================
#endif // OPENMESH_MESHREADER_HH defined
//=============================================================================