| vcg::_Edge | |
| vcg::_Face | |
| vcg::_HEdge | |
| vcg::tri::_SphFace | |
| vcg::tri::_SphMesh | |
| _SphUsedTypes | |
| vcg::tri::_SphUsedTypes | |
| vcg::tri::_SphVertex | |
| vcg::_UsedTypes | |
| vcg::_Vertex | |
| vcg::AABBBinaryTree< OBJTYPE, SCALARTYPE, NODEAUXDATATYPE > | |
| vcg::AABBBinaryTreeClosest< TREETYPE > | |
| vcg::AABBBinaryTreeFrustumCull< TREETYPE > | |
| vcg::AABBBinaryTreeIndex< OBJTYPE, SCALARTYPE, NODEAUXDATA > | |
| vcg::AABBBinaryTreeKClosest< TREETYPE > | |
| vcg::AABBBinaryTree< OBJTYPE, SCALARTYPE, NODEAUXDATATYPE >::AABBBinaryTreeNode | |
| vcg::AABBBinaryTreeRay< TREETYPE > | |
| Eigen::internal::abs2_impl< Scalar > | |
| Eigen::internal::abs2_impl< std::complex< RealScalar > > | |
| Eigen::internal::abs2_retval< Scalar > | |
| Eigen::internal::accessors_level< Derived > | |
| Collada::Tags::AccessorTag | |
| vcg::ActiveCoordinateFrame | The ActiveCoordinateFrame class |
| Eigen::GeneralProduct< Lhs, Rhs, OuterProduct >::add | |
| Eigen::internal::add_const< T > | |
| Eigen::internal::add_const< T & > | |
| Eigen::internal::add_const_on_value_type< T > | |
| Eigen::internal::add_const_on_value_type< T & > | |
| Eigen::internal::add_const_on_value_type< T * > | |
| Eigen::internal::add_const_on_value_type< T *const > | |
| Eigen::internal::add_const_on_value_type< T const *const > | |
| Eigen::internal::add_const_on_value_type_if_arithmetic< T > | |
| vcg::Add_Ons | |
| AdditionalInfo | |
| Eigen::GeneralProduct< Lhs, Rhs, OuterProduct >::adds | |
| vcg::face::vector_ocf< VALUE_TYPE >::AdjTypePack | |
| vcg::tri::UpdateCurvature< MeshType >::AdjVertex | |
| vcg::tri::AdvancingFront< MESH > | |
| vcg::tri::AdvancingTest< MESH > | |
| vcg::AllTypes::AEdgeType | |
| AFace | |
| vcg::AllTypes::AFaceType | |
| vcg::AllTypes::AHEdgeType | |
| Eigen::aligned_allocator< T > | STL compatible allocator to use with with 16 byte aligned types |
| Eigen::aligned_allocator_indirection< T > | |
| Eigen::internal::aligned_stack_memory_handler< T > | |
| Eigen::AlignedBox< _Scalar, _AmbientDim > | An axis aligned box |
| Eigen::internal::all_unroller< Derived, UnrollCount > | |
| Eigen::internal::all_unroller< Derived, 0 > | |
| Eigen::internal::all_unroller< Derived, Dynamic > | |
| vcg::tri::Allocator< MeshType > | Class to safely add and delete elements in a mesh |
| vcg::AllTypes | |
| Eigen::internal::always_void< T > | |
| Collada::Tags::AmbientTag | |
| Eigen::internal::AmbiVector< _Scalar, _Index > | |
| Eigen::AMDOrdering< Index > | |
| AMesh | |
| Eigen::AngleAxis< _Scalar > | Represents a 3D rotation as a rotation angle around an arbitrary 3D axis |
| vcg::tri::AnisotropicDistance< MeshType > | |
| Eigen::internal::any_unroller< Derived, UnrollCount > | |
| Eigen::internal::any_unroller< Derived, 0 > | |
| Eigen::internal::any_unroller< Derived, Dynamic > | |
| vcg::tri::Append< MeshLeft, ConstMeshRight > | Class to safely duplicate and append (portion of) meshes |
| vcg::vertex::ApproximateGeodesicDistanceFunctor< VertexType > | |
| vcg::tri::UpdateCurvature< MeshType >::AreaData | |
| vcg::AreaMode | The area constrained manipulator |
| vcg::tri::AreaPreservingTextureOptimizer< MESH_TYPE > | |
| vcg::Arity1< Base, A > | |
| vcg::Arity10< Base, A, B, C, D, E, F, G, H, I, J > | |
| vcg::Arity11< Base, A, B, C, D, E, F, G, H, I, J, K > | |
| vcg::Arity12< Base, A, B, C, D, E, F, G, H, I, J, K, L > | |
| vcg::Arity2< Base, A, B > | |
| vcg::Arity3< Base, A, B, C > | |
| vcg::Arity4< Base, A, B, C, D > | |
| vcg::Arity5< Base, A, B, C, D, E > | |
| vcg::Arity6< Base, A, B, C, D, E, F > | |
| vcg::Arity7< Base, A, B, C, D, E, F, G > | |
| vcg::Arity8< Base, A, B, C, D, E, F, G, H > | |
| vcg::Arity9< Base, A, B, C, D, E, F, G, H, I > | |
| Eigen::internal::arpack_wrapper< Scalar, RealScalar > | |
| Eigen::internal::arpack_wrapper< double, double > | |
| Eigen::internal::arpack_wrapper< float, float > | |
| Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD > | |
| Eigen::Array< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > | General-purpose arrays with easy API for coefficient-wise operations |
| nanoflann::array_or_vector_selector< DIM, T > | |
| nanoflann::array_or_vector_selector<-1, T > | |
| Eigen::ArrayBase< Derived > | Base class for all 1D and 2D array, and related expressions |
| Collada::Tags::ArraySourceTag | |
| Eigen::ArrayWrapper< ExpressionType > | Expression of a mathematical vector or matrix as an array object |
| Eigen::ArrayXpr | |
| vcg::tri::AttributeSeam::ASCompare< dst_trimesh_t > | |
| vcg::Use< A >::AsEdgeType< T > | |
| vcg::tri::AttributeSeam::ASExtract< src_trimesh_t, dst_trimesh_t > | |
| vcg::Use< A >::AsFaceType< T > | |
| AsFaceType< Arity5< DummyTypes, Use< Vertex< UsedTypes< Use< _SphVertex >::AsVertexType, Use< _SphFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< Use< _SphVertex >::AsVertexType, Use< _SphFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< Use< _SphVertex >::AsVertexType, Use< _SphFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< Use< _SphVertex >::AsVertexType, Use< _SphFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, Use< _SphVertex >::AsVertexType > > | |
| AsFaceType< Arity5< DummyTypes, Use< Vertex< UsedTypes< Use< CVertex >::AsVertexType, Use< CFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< Use< CVertex >::AsVertexType, Use< CFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< Use< CVertex >::AsVertexType, Use< CFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< Use< CVertex >::AsVertexType, Use< CFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, Use< CVertex >::AsVertexType > > | |
| AsFaceType< Arity5< DummyTypes, Use< Vertex< UsedTypes< Use< CVertexO >::AsVertexType, Use< CFaceO >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< Use< CVertexO >::AsVertexType, Use< CFaceO >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< Use< CVertexO >::AsVertexType, Use< CFaceO >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< Use< CVertexO >::AsVertexType, Use< CFaceO >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, Use< CVertexO >::AsVertexType > > | |
| AsFaceType< Arity5< DummyTypes, Use< Vertex< UsedTypes< Use< MyPolyVertex >::AsVertexType, Use< MyPolyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< Use< MyPolyVertex >::AsVertexType, Use< MyPolyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< Use< MyPolyVertex >::AsVertexType, Use< MyPolyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< Use< MyPolyVertex >::AsVertexType, Use< MyPolyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, Use< MyPolyVertex >::AsVertexType > > | |
| AsFaceType< Arity5< DummyTypes, Use< Vertex< UsedTypes< Use< MyVertex >::AsVertexType, Use< MyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< Use< MyVertex >::AsVertexType, Use< MyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< Use< MyVertex >::AsVertexType, Use< MyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< Use< MyVertex >::AsVertexType, Use< MyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, Use< MyVertex >::AsVertexType > > | |
| AsFaceType< Arity5< DummyTypes, Use< Vertex< UsedTypes< Use< SrcVertex >::AsVertexType, Use< SrcFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< Use< SrcVertex >::AsVertexType, Use< SrcFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< Use< SrcVertex >::AsVertexType, Use< SrcFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< Use< SrcVertex >::AsVertexType, Use< SrcFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, Use< SrcVertex >::AsVertexType > > | |
| AsFaceType< Arity5< DummyTypes, Use< Vertex< UsedTypes< vcg::Use< AVertex >::AsVertexType, vcg::Use< AFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< vcg::Use< AVertex >::AsVertexType, vcg::Use< AFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< vcg::Use< AVertex >::AsVertexType, vcg::Use< AFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< vcg::Use< AVertex >::AsVertexType, vcg::Use< AFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, vcg::Use< AVertex >::AsVertexType > > | |
| AsFaceType< Arity5< DummyTypes, Use< Vertex< UsedTypes< vcg::Use< CVertex >::AsVertexType, vcg::Use< CFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< vcg::Use< CVertex >::AsVertexType, vcg::Use< CFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< vcg::Use< CVertex >::AsVertexType, vcg::Use< CFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< vcg::Use< CVertex >::AsVertexType, vcg::Use< CFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, vcg::Use< CVertex >::AsVertexType > > | |
| AsFaceType< Arity5< DummyTypes, Use< Vertex< UsedTypes< vcg::Use< MyVertex >::AsVertexType, vcg::Use< MyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< vcg::Use< MyVertex >::AsVertexType, vcg::Use< MyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< vcg::Use< MyVertex >::AsVertexType, vcg::Use< MyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< vcg::Use< MyVertex >::AsVertexType, vcg::Use< MyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, vcg::Use< MyVertex >::AsVertexType > > | |
| AsFaceType< Arity5< DummyTypes, Use< Vertex< UsedTypes< vcg::Use< MyVertexOcf >::AsVertexType, vcg::Use< MyFaceOcf >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< vcg::Use< MyVertexOcf >::AsVertexType, vcg::Use< MyFaceOcf >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< vcg::Use< MyVertexOcf >::AsVertexType, vcg::Use< MyFaceOcf >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< vcg::Use< MyVertexOcf >::AsVertexType, vcg::Use< MyFaceOcf >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, vcg::Use< MyVertexOcf >::AsVertexType > > | |
| AsFaceType< Arity5< DummyTypes, Use< Vertex< UsedTypes< vcg::Use< PolyVertex >::AsVertexType, vcg::Use< PolyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< vcg::Use< PolyVertex >::AsVertexType, vcg::Use< PolyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< vcg::Use< PolyVertex >::AsVertexType, vcg::Use< PolyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< vcg::Use< PolyVertex >::AsVertexType, vcg::Use< PolyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, vcg::Use< PolyVertex >::AsVertexType > > | |
| AsFaceType< Arity5< DummyTypes, Use< Vertex< UsedTypes< vcg::Use< TVertex >::AsVertexType, vcg::Use< TFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< vcg::Use< TVertex >::AsVertexType, vcg::Use< TFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< vcg::Use< TVertex >::AsVertexType, vcg::Use< TFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< vcg::Use< TVertex >::AsVertexType, vcg::Use< TFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, vcg::Use< TVertex >::AsVertexType > > | |
| AsFaceType< Arity6< DummyTypes, Use< Vertex< UsedTypes< Use< EmVertex >::AsVertexType, Use< EmEdge >::AsEdgeType, Use< EmFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< Use< EmVertex >::AsVertexType, Use< EmEdge >::AsEdgeType, Use< EmFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< Use< EmVertex >::AsVertexType, Use< EmEdge >::AsEdgeType, Use< EmFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< Use< EmVertex >::AsVertexType, Use< EmEdge >::AsEdgeType, Use< EmFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, Use< EmVertex >::AsVertexType, Use< EmEdge >::AsEdgeType > > | |
| AsFaceType< Arity6< DummyTypes, Use< Vertex< UsedTypes< Use< MyVertex >::AsVertexType, Use< MyEdge >::AsEdgeType, Use< MyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< Use< MyVertex >::AsVertexType, Use< MyEdge >::AsEdgeType, Use< MyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< Use< MyVertex >::AsVertexType, Use< MyEdge >::AsEdgeType, Use< MyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< Use< MyVertex >::AsVertexType, Use< MyEdge >::AsEdgeType, Use< MyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, Use< MyVertex >::AsVertexType, Use< MyEdge >::AsEdgeType > > | |
| AsFaceType< Arity6< DummyTypes, Use< Vertex< UsedTypes< vcg::Use< BaseVertex >::AsVertexType, vcg::Use< BaseEdge >::AsEdgeType, vcg::Use< BaseFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< vcg::Use< BaseVertex >::AsVertexType, vcg::Use< BaseEdge >::AsEdgeType, vcg::Use< BaseFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< vcg::Use< BaseVertex >::AsVertexType, vcg::Use< BaseEdge >::AsEdgeType, vcg::Use< BaseFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< vcg::Use< BaseVertex >::AsVertexType, vcg::Use< BaseEdge >::AsEdgeType, vcg::Use< BaseFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, vcg::Use< BaseVertex >::AsVertexType, vcg::Use< BaseEdge >::AsEdgeType > > | |
| AsFaceType< Arity6< DummyTypes, Use< Vertex< UsedTypes< vcg::Use< MyVertex >::AsVertexType, vcg::Use< MyEdge >::AsEdgeType, vcg::Use< MyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< vcg::Use< MyVertex >::AsVertexType, vcg::Use< MyEdge >::AsEdgeType, vcg::Use< MyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< vcg::Use< MyVertex >::AsVertexType, vcg::Use< MyEdge >::AsEdgeType, vcg::Use< MyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< vcg::Use< MyVertex >::AsVertexType, vcg::Use< MyEdge >::AsEdgeType, vcg::Use< MyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, vcg::Use< MyVertex >::AsVertexType, vcg::Use< MyEdge >::AsEdgeType > > | |
| AsFaceType< Arity6< DummyTypes, Use< Vertex< UsedTypes< vcg::Use< OcfVertex >::AsVertexType, vcg::Use< OcfEdge >::AsEdgeType, vcg::Use< OcfFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< vcg::Use< OcfVertex >::AsVertexType, vcg::Use< OcfEdge >::AsEdgeType, vcg::Use< OcfFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< vcg::Use< OcfVertex >::AsVertexType, vcg::Use< OcfEdge >::AsEdgeType, vcg::Use< OcfFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< vcg::Use< OcfVertex >::AsVertexType, vcg::Use< OcfEdge >::AsEdgeType, vcg::Use< OcfFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, vcg::Use< OcfVertex >::AsVertexType, vcg::Use< OcfEdge >::AsEdgeType > > | |
| AsFaceType< Arity6< DummyTypes, Use< Vertex< UsedTypes< vcg::Use< RTVertex >::AsVertexType, vcg::Use< RTEdge >::AsEdgeType, vcg::Use< RTFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< vcg::Use< RTVertex >::AsVertexType, vcg::Use< RTEdge >::AsEdgeType, vcg::Use< RTFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< vcg::Use< RTVertex >::AsVertexType, vcg::Use< RTEdge >::AsEdgeType, vcg::Use< RTFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< vcg::Use< RTVertex >::AsVertexType, vcg::Use< RTEdge >::AsEdgeType, vcg::Use< RTFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, vcg::Use< RTVertex >::AsVertexType, vcg::Use< RTEdge >::AsEdgeType > > | |
| AsFaceType< Arity7< DummyTypes, Use< Vertex< UsedTypes< vcg::Use< MyPolyVertex >::AsVertexType, vcg::Use< CEdge >::AsEdgeType, vcg::Use< CHEdge >::AsHEdgeType, vcg::Use< MyPolyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< vcg::Use< MyPolyVertex >::AsVertexType, vcg::Use< CEdge >::AsEdgeType, vcg::Use< CHEdge >::AsHEdgeType, vcg::Use< MyPolyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< vcg::Use< MyPolyVertex >::AsVertexType, vcg::Use< CEdge >::AsEdgeType, vcg::Use< CHEdge >::AsHEdgeType, vcg::Use< MyPolyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< vcg::Use< MyPolyVertex >::AsVertexType, vcg::Use< CEdge >::AsEdgeType, vcg::Use< CHEdge >::AsHEdgeType, vcg::Use< MyPolyFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, vcg::Use< MyPolyVertex >::AsVertexType, vcg::Use< CEdge >::AsEdgeType, vcg::Use< CHEdge >::AsHEdgeType > > | |
| AsFaceType< Arity7< DummyTypes, Use< Vertex< UsedTypes< vcg::Use< PVertex >::AsVertexType, vcg::Use< PEdge >::AsEdgeType, vcg::Use< PHEdge >::AsHEdgeType, vcg::Use< PFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< vcg::Use< PVertex >::AsVertexType, vcg::Use< PEdge >::AsEdgeType, vcg::Use< PHEdge >::AsHEdgeType, vcg::Use< PFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< vcg::Use< PVertex >::AsVertexType, vcg::Use< PEdge >::AsEdgeType, vcg::Use< PHEdge >::AsHEdgeType, vcg::Use< PFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< vcg::Use< PVertex >::AsVertexType, vcg::Use< PEdge >::AsEdgeType, vcg::Use< PHEdge >::AsHEdgeType, vcg::Use< PFace >::AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, vcg::Use< PVertex >::AsVertexType, vcg::Use< PEdge >::AsEdgeType, vcg::Use< PHEdge >::AsHEdgeType > > | |
| vcg::Use< A >::AsHEdgeType< T > | |
| AsHEdgeType< Arity7< DummyTypes, Use< Vertex< UsedTypes< Use< _Vertex >::AsVertexType, Use< _Edge >::AsEdgeType, Use< _Face >::AsFaceType, Use< _HEdge >::AsHEdgeType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< Use< _Vertex >::AsVertexType, Use< _Edge >::AsEdgeType, Use< _Face >::AsFaceType, Use< _HEdge >::AsHEdgeType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< Use< _Vertex >::AsVertexType, Use< _Edge >::AsEdgeType, Use< _Face >::AsFaceType, Use< _HEdge >::AsHEdgeType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< Use< _Vertex >::AsVertexType, Use< _Edge >::AsEdgeType, Use< _Face >::AsFaceType, Use< _HEdge >::AsHEdgeType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, Use< _Vertex >::AsVertexType, Use< _Edge >::AsEdgeType, Use< _Face >::AsFaceType > > | |
| Collada::Tags::AssetTag | |
| Eigen::internal::assign_DefaultTraversal_CompleteUnrolling< Derived1, Derived2, Index, Stop > | |
| Eigen::internal::assign_DefaultTraversal_CompleteUnrolling< Derived1, Derived2, Stop, Stop > | |
| Eigen::internal::assign_DefaultTraversal_InnerUnrolling< Derived1, Derived2, Index, Stop > | |
| Eigen::internal::assign_DefaultTraversal_InnerUnrolling< Derived1, Derived2, Stop, Stop > | |
| Eigen::internal::assign_impl< Derived1, Derived2, DefaultTraversal, CompleteUnrolling, Version > | |
| Eigen::internal::assign_impl< Derived1, Derived2, DefaultTraversal, InnerUnrolling, Version > | |
| Eigen::internal::assign_impl< Derived1, Derived2, DefaultTraversal, NoUnrolling, Version > | |
| Eigen::internal::assign_impl< Derived1, Derived2, InnerVectorizedTraversal, CompleteUnrolling, Version > | |
| Eigen::internal::assign_impl< Derived1, Derived2, InnerVectorizedTraversal, InnerUnrolling, Version > | |
| Eigen::internal::assign_impl< Derived1, Derived2, InnerVectorizedTraversal, NoUnrolling, Version > | |
| Eigen::internal::assign_impl< Derived1, Derived2, InvalidTraversal, Unrolling, Version > | |
| Eigen::internal::assign_impl< Derived1, Derived2, LinearTraversal, CompleteUnrolling, Version > | |
| Eigen::internal::assign_impl< Derived1, Derived2, LinearTraversal, NoUnrolling, Version > | |
| Eigen::internal::assign_impl< Derived1, Derived2, LinearVectorizedTraversal, CompleteUnrolling, Version > | |
| Eigen::internal::assign_impl< Derived1, Derived2, LinearVectorizedTraversal, NoUnrolling, Version > | |
| Eigen::internal::assign_impl< Derived1, Derived2, SliceVectorizedTraversal, NoUnrolling, Version > | |
| Eigen::internal::assign_innervec_CompleteUnrolling< Derived1, Derived2, Index, Stop > | |
| Eigen::internal::assign_innervec_CompleteUnrolling< Derived1, Derived2, Stop, Stop > | |
| Eigen::internal::assign_innervec_InnerUnrolling< Derived1, Derived2, Index, Stop > | |
| Eigen::internal::assign_innervec_InnerUnrolling< Derived1, Derived2, Stop, Stop > | |
| Eigen::internal::assign_LinearTraversal_CompleteUnrolling< Derived1, Derived2, Index, Stop > | |
| Eigen::internal::assign_LinearTraversal_CompleteUnrolling< Derived1, Derived2, Stop, Stop > | |
| Eigen::internal::assign_selector< Derived, OtherDerived, false, false > | |
| Eigen::internal::assign_selector< Derived, OtherDerived, false, true > | |
| Eigen::internal::assign_selector< Derived, OtherDerived, true, false > | |
| Eigen::internal::assign_selector< Derived, OtherDerived, true, true > | |
| Eigen::internal::assign_traits< Derived, OtherDerived > | |
| vcg::Use< A >::AsTetraType< T > | |
| vcg::Use< A >::AsVertexType< T > | |
| AsVertexType< Arity5< DummyTypes, Use< Vertex< UsedTypes< vcg::Use< CFace >::AsFaceType, vcg::Use< CVertex >::AsVertexType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< vcg::Use< CFace >::AsFaceType, vcg::Use< CVertex >::AsVertexType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< vcg::Use< CFace >::AsFaceType, vcg::Use< CVertex >::AsVertexType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< vcg::Use< CFace >::AsFaceType, vcg::Use< CVertex >::AsVertexType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, vcg::Use< CFace >::AsFaceType > > | |
| Eigen::internal::atanh2_default_impl< Scalar, IsInteger > | |
| Eigen::internal::atanh2_default_impl< Scalar, true > | |
| Eigen::internal::atanh2_impl< Scalar > | |
| Eigen::internal::atanh2_retval< Scalar > | |
| mt::atomicInt | |
| vcg::tri::io::AttrAll< MeshType, A0, A1, A2, A3, A4 > | |
| vcg::Attribute< ATTR_TYPE > | |
| vcg::tri::TriMesh< Container0, Container1, Container2, Container3 >::AttributeHandle< ATTR_TYPE, CONT > | |
| vcg::tri::AttributeSeam | |
| Collada::Tags::AuthoringToolTag | |
| Collada::Tags::AuthorTag | |
| Eigen::internal::auto_diff_special_op< _DerType, false > | |
| Eigen::internal::auto_diff_special_op< _DerType, true > | |
| Eigen::AutoDiffJacobian< Functor > | |
| Eigen::AutoDiffScalar< _DerType > | A scalar type replacement with automatic differentation capability |
| Eigen::AutoDiffVector< ValueType, JacobianType > | |
| vcg::tri::AverageColorCell< MeshType > | |
| AVertex | |
| vcg::AllTypes::AVertexType | |
| vcg::AxisMode | The one-directional manipulator |
| Ball< Dim > | |
| vcg::tri::BallPivoting< MESH > | |
| BallPointStuff< Dim > | |
| Eigen::internal::BandMatrix< _Scalar, Rows, Cols, Supers, Subs, Options > | Represents a rectangular matrix with a banded storage |
| Eigen::internal::BandMatrixBase< Derived > | |
| Eigen::internal::BandMatrixWrapper< _CoefficientsType, _Rows, _Cols, _Supers, _Subs, _Options > | |
| BaseEdge | |
| BaseFace | |
| vcg::BaseFeature< MeshType > | |
| vcg::BaseFeatureSet< MeshType > | |
| vcg::tri::BaseInterpolator< MeshType > | |
| BaseMesh | |
| vcg::tri::BaseMeshTypeHolder< TYPESPOOL > | |
| glw::detail::BaseOf< T > | |
| glw::detail::BaseOf< BoundBuffer > | |
| glw::detail::BaseOf< BoundDrawFramebuffer > | |
| glw::detail::BaseOf< BoundFeedbackBuffer > | |
| glw::detail::BaseOf< BoundFragmentShader > | |
| glw::detail::BaseOf< BoundFramebuffer > | |
| glw::detail::BaseOf< BoundGeometryShader > | |
| glw::detail::BaseOf< BoundIndexBuffer > | |
| glw::detail::BaseOf< BoundObject > | |
| glw::detail::BaseOf< BoundPixelPackBuffer > | |
| glw::detail::BaseOf< BoundPixelUnpackBuffer > | |
| glw::detail::BaseOf< BoundProgram > | |
| glw::detail::BaseOf< BoundReadDrawFramebuffer > | |
| glw::detail::BaseOf< BoundReadFramebuffer > | |
| glw::detail::BaseOf< BoundRenderable > | |
| glw::detail::BaseOf< BoundRenderbuffer > | |
| glw::detail::BaseOf< BoundShader > | |
| glw::detail::BaseOf< BoundTexture > | |
| glw::detail::BaseOf< BoundTexture2D > | |
| glw::detail::BaseOf< BoundTextureCube > | |
| glw::detail::BaseOf< BoundUniformBuffer > | |
| glw::detail::BaseOf< BoundVertexBuffer > | |
| glw::detail::BaseOf< BoundVertexShader > | |
| glw::detail::BaseOf< Buffer > | |
| glw::detail::BaseOf< FragmentShader > | |
| glw::detail::BaseOf< Framebuffer > | |
| glw::detail::BaseOf< GeometryShader > | |
| glw::detail::BaseOf< Object > | |
| glw::detail::BaseOf< Program > | |
| glw::detail::BaseOf< Renderable > | |
| glw::detail::BaseOf< Renderbuffer > | |
| glw::detail::BaseOf< SafeBuffer > | |
| glw::detail::BaseOf< SafeFragmentShader > | |
| glw::detail::BaseOf< SafeFramebuffer > | |
| glw::detail::BaseOf< SafeGeometryShader > | |
| glw::detail::BaseOf< SafeObject > | |
| glw::detail::BaseOf< SafeProgram > | |
| glw::detail::BaseOf< SafeRenderable > | |
| glw::detail::BaseOf< SafeRenderbuffer > | |
| glw::detail::BaseOf< SafeShader > | |
| glw::detail::BaseOf< SafeTexture > | |
| glw::detail::BaseOf< SafeTexture2D > | |
| glw::detail::BaseOf< SafeTextureCube > | |
| glw::detail::BaseOf< SafeVertexShader > | |
| glw::detail::BaseOf< Shader > | |
| glw::detail::BaseOf< Texture > | |
| glw::detail::BaseOf< Texture2D > | |
| glw::detail::BaseOf< TextureCube > | |
| glw::detail::BaseOf< VertexShader > | |
| vcg::BaseParameterClass | |
| BaseUsedTypes | |
| BaseVertex | |
| vcg::tri::BasicCrossFunctor< MeshType > | |
| vcg::BasicGrid< SCALARTYPE > | |
| vcg::BasicGrid2D< SCALARTYPE > | |
| vcg::tri::BasicVertexPair< VERTEX_TYPE > | |
| Eigen::BDCSVD< _MatrixType > | Class Bidiagonal Divide and Conquer SVD |
| Bennett5_functor | |
| Eigen::BiCGSTAB< _MatrixType, _Preconditioner > | A bi conjugate gradient stabilized solver for sparse square problems |
| vcg::tri::Fitmaps< MeshType >::Bicubic | |
| Eigen::internal::binary_result_of_select< Func, ArgType0, ArgType1, SizeOf > | |
| Eigen::internal::binary_result_of_select< Func, ArgType0, ArgType1, sizeof(has_std_result_type)> | |
| Eigen::internal::binary_result_of_select< Func, ArgType0, ArgType1, sizeof(has_tr1_result)> | |
| vcg::PerfectSpatialHashing< OBJECT_TYPE, SCALAR_TYPE >::BinaryImage | |
| Bindable | |
| glw::Context::BindingHandleFromBinding< TBinding > | |
| glw::Context::BindingHandleFromObject< TObject > | |
| Collada::Tags::BindMaterialTag | |
| Collada::Tags::BindVertexInputTag | |
| vcg::hedge::BitFlags< T > | |
| vcg::edge::BitFlags< T > | Component: Per edge Flags |
| vcg::face::BitFlags< T > | Component: Per face Flags |
| vcg::tetra::BitFlags< T > | |
| vcg::vertex::BitFlags< T > | Component: Per vertex Flags |
| vcg::tri::BitQuad< _MeshType, Interpolator > | |
| vcg::tri::BitQuadCreation< _MeshType, Interpolator > | |
| vcg::tri::BitQuadOptimization< BQ > | |
| Eigen::internal::blas_data_mapper< Scalar, Index, StorageOrder > | |
| Eigen::internal::blas_traits< XprType > | |
| Eigen::internal::blas_traits< const T > | |
| Eigen::internal::blas_traits< CwiseUnaryOp< scalar_conjugate_op< Scalar >, NestedXpr > > | |
| Eigen::internal::blas_traits< CwiseUnaryOp< scalar_multiple_op< Scalar >, NestedXpr > > | |
| Eigen::internal::blas_traits< CwiseUnaryOp< scalar_opposite_op< Scalar >, NestedXpr > > | |
| Eigen::internal::blas_traits< SelfCwiseBinaryOp< BinOp, NestedXpr, Rhs > > | |
| Eigen::internal::blas_traits< Transpose< NestedXpr > > | |
| Collada::Tags::BlinnTag | |
| Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel > | Expression of a fixed-size or dynamic-size block |
| BlockImpl | |
| Eigen::BlockImpl< const SparseMatrix< _Scalar, _Options, _Index >, BlockRows, BlockCols, true, Sparse > | |
| Eigen::BlockImpl< SparseMatrix< _Scalar, _Options, _Index >, BlockRows, BlockCols, true, Sparse > | |
| Eigen::BlockImpl< XprType, BlockRows, BlockCols, InnerPanel, Dense > | |
| Eigen::BlockImpl< XprType, BlockRows, BlockCols, InnerPanel, Sparse > | |
| Eigen::BlockImpl< XprType, BlockRows, BlockCols, true, Sparse > | |
| Eigen::internal::BlockImpl_dense< XprType, BlockRows, BlockCols, InnerPanel, HasDirectAccess > | |
| Eigen::internal::BlockImpl_dense< XprType, BlockRows, BlockCols, InnerPanel, true > | |
| vcg::Bmt | |
| vcg::BmtBuilder | |
| glw::BoundBuffer | |
| glw::BoundDrawFramebuffer | |
| glw::BoundFeedbackBuffer | |
| glw::BoundFragmentShader | |
| glw::BoundFramebuffer | |
| glw::BoundGeometryShader | |
| glw::BoundIndexBuffer | |
| glw::BoundObject | |
| glw::BoundPixelPackBuffer | |
| glw::BoundPixelUnpackBuffer | |
| glw::BoundProgram | |
| glw::BoundReadDrawFramebuffer | |
| glw::BoundReadFramebuffer | |
| glw::BoundRenderable | |
| glw::BoundRenderbuffer | |
| glw::BoundShader | |
| glw::BoundTexture | |
| glw::BoundTexture2D | |
| glw::BoundTextureCube | |
| glw::BoundUniformBuffer | |
| glw::BoundVertexBuffer | |
| glw::BoundVertexShader | |
| vcg::Box< N, S > | |
| vcg::Box2< BoxScalarType > | |
| vcg::Box3< BoxScalarType > | |
| BoxBOD_functor | |
| nanoflann::KDTreeSingleIndexAdaptor< Distance, DatasetAdaptor, DIM, IndexType >::BranchStruct< T, DistanceType > | |
| glw::Buffer | |
| glw::BufferArguments | |
| glw::BufferBindingParams | |
| BufferRenderTarget | |
| vcg::tri::io::C0< MeshType, A0, B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12 > | |
| vcg::tri::io::C1< MeshType, A0, A1 > | |
| vcg::tri::io::C2< MeshType, A0, A1, A2 > | |
| vcg::tri::io::C3< MeshType, A0, A1, A2, A3 > | |
| vcg::Cache< Token > | |
| vcg::Camera< S > | |
| vcg::tri::io::u3dparametersclasses::Movie15Parameters< SaveMeshType >::CameraParameters | |
| vcg::tri::FourPCS< MeshType >::Candidate | |
| vcg::RansacFramework< MeshType, FeatureSetType >::Candidate | |
| nanoflann::CArray< T, N > | |
| Eigen::internal::cast_impl< OldType, NewType > | |
| Eigen::internal::cast_return_type< XprType, CastType > | |
| vcg::CAT< STL_CONT, ATTR_TYPE > | |
| vcg::CATBase< STL_CONT > | |
| vcg::CATBaseBase | |
| vcg::CATEntry< STL_CONT, ENTRY_TYPE > | |
| CEdge | |
| vcg::Bmt::Cell | Cell structure for the mt representation |
| vcg::SpatialHashTable< ObjType, FLT >::CellIterator | |
| vcg::SpatialHashTable2D< ObjType, FLT >::CellIterator | |
| vcg::tri::CenterPointBarycenter< TRIMESH_TYPE > | |
| vcg::tri::Centroid< MESH_TYPE, LSCALAR_TYPE > | Allow to compute classical Loop subdivision surface with the same code than LS3 |
| CFace | |
| CFaceO | |
| Eigen::internal::check_rows_cols_for_overflow< MaxSizeAtCompileTime > | |
| Eigen::internal::check_rows_cols_for_overflow< Dynamic > | |
| Eigen::internal::check_transpose_aliasing_compile_time_selector< DestIsTransposed, OtherDerived > | |
| Eigen::internal::check_transpose_aliasing_compile_time_selector< DestIsTransposed, CwiseBinaryOp< BinOp, DerivedA, DerivedB > > | |
| Eigen::internal::check_transpose_aliasing_run_time_selector< Scalar, DestIsTransposed, OtherDerived > | |
| Eigen::internal::check_transpose_aliasing_run_time_selector< Scalar, DestIsTransposed, CwiseBinaryOp< BinOp, DerivedA, DerivedB > > | |
| checkGLError | |
| Eigen::internal::checkTransposeAliasing_impl< Derived, OtherDerived, MightHaveTransposeAliasing > | |
| Eigen::internal::checkTransposeAliasing_impl< Derived, OtherDerived, false > | |
| CHEdge | |
| Eigen::CholmodBase< _MatrixType, _UpLo, Derived > | The base class for the direct Cholesky factorization of Cholmod |
| Eigen::CholmodDecomposition< _MatrixType, _UpLo > | A general Cholesky factorization and solver based on Cholmod |
| Eigen::CholmodSimplicialLDLT< _MatrixType, _UpLo > | A simplicial direct Cholesky (LDLT) factorization and solver based on Cholmod |
| Eigen::CholmodSimplicialLLT< _MatrixType, _UpLo > | A simplicial direct Cholesky (LLT) factorization and solver based on Cholmod |
| Eigen::CholmodSupernodalLLT< _MatrixType, _UpLo > | A supernodal Cholesky (LLT) factorization and solver based on Cholmod |
| chwirut2_functor | |
| ClassesNode | |
| ClassNode | |
| vcg::tri::Clean< CleanMeshType > | Class of static functions to clean//restore meshs |
| vcg::tetra::GlTetramesh< CONT_TETRA >::ClipPlane | |
| mt::Clock | Clock used to measure performance of algoritms. Behaves similarly to QTime (QT) |
| vcg::tri::ClosestFaceEPIterator< GRID, MESH > | |
| vcg::ClosestIterator< Spatial_Idexing, DISTFUNCTOR, TMARKER > | |
| vcg::AABBBinaryTreeKClosest< TREETYPE >::ClosestObjType | |
| vcg::tri::ClosestVertexIterator< GRID, MESH > | |
| vcg::tri::Clustering< MeshType, CellType > | |
| CMesh | |
| CMeshO | |
| Eigen::internal::coeff_visitor< Derived > | |
| Eigen::CoeffBasedProduct< LhsNested, RhsNested, NestingFlags > | |
| internal::colamd_col< Index > | |
| Eigen::internal::colamd_col< Index > | |
| Eigen::internal::Colamd_Row< Index > | |
| internal::Colamd_Row< Index > | |
| Eigen::COLAMDOrdering< Index > | |
| vcg::tri::io::ImporterDAE< OpenMeshType >::ColladaFace | |
| vcg::tri::io::ImporterDAE< OpenMeshType >::ColladaMesh | |
| Collada::Tags::ColladaTag | |
| ColladaTypes | |
| vcg::tri::io::ImporterDAE< OpenMeshType >::ColladaTypes | |
| vcg::tri::io::ImporterDAE< OpenMeshType >::ColladaVertex | |
| vcg::edge::Color< A, T > | Component: Per edge Color |
| vcg::face::Color< A, T > | |
| vcg::vertex::Color< A, T > | Component: Per vertex Color |
| vcg::Color4< T > | |
| vcg::edge::Color4b< TT > | |
| vcg::face::Color4b< T > | |
| vcg::vertex::Color4b< TT > | |
| vcg::face::Color4bOcc< T > | |
| vcg::vertex::Color4bOcc< T > | |
| vcg::face::Color4bOcf< T > | |
| vcg::vertex::Color4bOcf< T > | |
| vcg::tri::UpdateColor< MeshType >::ColorAvgInfo | |
| vcg::ColorConverter | |
| vcg::face::ColorOcc< A, T > | *-------------------------- COLOR ----------------------------------------*/ |
| vcg::vertex::ColorOcc< A, T > | *-------------------------- COLOR ----------------------------------*/ |
| vcg::face::ColorOcf< A, T > | *-------------------------- COLOR ----------------------------------*/ |
| vcg::vertex::ColorOcf< A, T > | *-------------------------- COLOR ----------------------------------*/ |
| ColorRenderBuffer | |
| ColorRenderTarget | |
| ColorRenderTexture | |
| vcg::tri::Smooth< SmoothMeshType >::ColorSmoothInfo | |
| vcg::ColorSpace< T > | |
| Collada::Tags::ColorTag | |
| ColorTexture | |
| ColorTexture1D | |
| ColorTexture2D | |
| ColorTexture3D | |
| Eigen::ColPivHouseholderQR< _MatrixType > | Householder rank-revealing QR decomposition of a matrix with column-pivoting |
| Eigen::internal::column_dfs_traits< IndexVector, ScalarVector > | |
| vcg::tri::CoM< MeshType > | A class for managing curves on a 2manifold |
| Eigen::CommaInitializer< XprType > | Helper class used by the comma initializer operator |
| Eigen::internal::companion< _Scalar, _Deg > | |
| vcg::tri::Clean< CleanMeshType >::CompareAreaFP | |
| vcg::AABBBinaryTreeKClosest< TREETYPE >::CompareClosest | |
| vcg::ComparisonFunctor< ScalarType > | |
| vcg::RectPacker< SCALAR_TYPE >::ComparisonFunctor | |
| Eigen::internal::complex_schur_reduce_to_hessenberg< MatrixType, IsComplex > | |
| Eigen::internal::complex_schur_reduce_to_hessenberg< MatrixType, false > | |
| Eigen::ComplexEigenSolver< _MatrixType > | Computes eigenvalues and eigenvectors of general complex matrices |
| Eigen::ComplexSchur< _MatrixType > | Performs a complex Schur decomposition of a real or complex square matrix |
| Eigen::internal::CompressedStorage< _Scalar, _Index > | |
| Eigen::internal::compute_inverse< MatrixType, ResultType, Size > | |
| Eigen::internal::compute_inverse< MatrixType, ResultType, 1 > | |
| Eigen::internal::compute_inverse< MatrixType, ResultType, 2 > | |
| Eigen::internal::compute_inverse< MatrixType, ResultType, 3 > | |
| Eigen::internal::compute_inverse< MatrixType, ResultType, 4 > | |
| Eigen::internal::compute_inverse_and_det_with_check< MatrixType, ResultType, Size > | |
| Eigen::internal::compute_inverse_and_det_with_check< MatrixType, ResultType, 1 > | |
| Eigen::internal::compute_inverse_and_det_with_check< MatrixType, ResultType, 2 > | |
| Eigen::internal::compute_inverse_and_det_with_check< MatrixType, ResultType, 3 > | |
| Eigen::internal::compute_inverse_and_det_with_check< MatrixType, ResultType, 4 > | |
| Eigen::internal::compute_inverse_size4< Arch, Scalar, MatrixType, ResultType > | |
| Eigen::internal::compute_inverse_size4< Architecture::SSE, double, MatrixType, ResultType > | |
| Eigen::internal::compute_inverse_size4< Architecture::SSE, float, MatrixType, ResultType > | |
| Eigen::internal::compute_matrix_flags< Scalar, Rows, Cols, Options, MaxRows, MaxCols > | |
| mt::condition | |
| Eigen::internal::conditional< Condition, Then, Else > | |
| Eigen::internal::conditional< false, Then, Else > | |
| Eigen::internal::conj_expr_if< Cond, T > | |
| Eigen::internal::conj_helper< Packet1cd, Packet1cd, false, true > | |
| Eigen::internal::conj_helper< Packet1cd, Packet1cd, true, false > | |
| Eigen::internal::conj_helper< Packet1cd, Packet1cd, true, true > | |
| Eigen::internal::conj_helper< Packet1cd, Packet2d, false, false > | |
| Eigen::internal::conj_helper< Packet2cf, Packet2cf, false, true > | |
| Eigen::internal::conj_helper< Packet2cf, Packet2cf, true, false > | |
| Eigen::internal::conj_helper< Packet2cf, Packet2cf, true, true > | |
| Eigen::internal::conj_helper< Packet2cf, Packet4f, false, false > | |
| Eigen::internal::conj_helper< Packet2d, Packet1cd, false, false > | |
| Eigen::internal::conj_helper< Packet4f, Packet2cf, false, false > | |
| Eigen::internal::conj_helper< RealScalar, std::complex< RealScalar >, false, Conj > | |
| Eigen::internal::conj_helper< Scalar, Scalar, false, false > | |
| Eigen::internal::conj_helper< std::complex< RealScalar >, RealScalar, Conj, false > | |
| Eigen::internal::conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, false, true > | |
| Eigen::internal::conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, true, false > | |
| Eigen::internal::conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, true, true > | |
| Eigen::internal::conj_if< false > | |
| Eigen::internal::conj_if< true > | |
| Eigen::internal::conj_impl< Scalar, IsComplex > | |
| Eigen::internal::conj_impl< Scalar, true > | |
| Eigen::internal::conj_retval< Scalar > | |
| Eigen::ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > | A conjugate gradient solver for sparse self-adjoint problems |
| vcg::tri::ConnectedComponentIterator< ConnectedMeshType > | |
| Eigen::internal::conservative_resize_like_impl< Derived, OtherDerived, IsVector > | |
| Eigen::internal::conservative_resize_like_impl< Derived, OtherDerived, true > | |
| Eigen::internal::conservative_sparse_sparse_product_selector< Lhs, Rhs, ResultType, ColMajor, ColMajor, ColMajor > | |
| Eigen::internal::conservative_sparse_sparse_product_selector< Lhs, Rhs, ResultType, ColMajor, ColMajor, RowMajor > | |
| Eigen::internal::conservative_sparse_sparse_product_selector< Lhs, Rhs, ResultType, ColMajor, RowMajor, ColMajor > | |
| Eigen::internal::conservative_sparse_sparse_product_selector< Lhs, Rhs, ResultType, ColMajor, RowMajor, RowMajor > | |
| Eigen::internal::conservative_sparse_sparse_product_selector< Lhs, Rhs, ResultType, RowMajor, ColMajor, ColMajor > | |
| Eigen::internal::conservative_sparse_sparse_product_selector< Lhs, Rhs, ResultType, RowMajor, ColMajor, RowMajor > | |
| Eigen::internal::conservative_sparse_sparse_product_selector< Lhs, Rhs, ResultType, RowMajor, RowMajor, ColMajor > | |
| Eigen::internal::conservative_sparse_sparse_product_selector< Lhs, Rhs, ResultType, RowMajor, RowMajor, RowMajor > | |
| Eigen::internal::const_blas_data_mapper< Scalar, Index, StorageOrder > | |
| vcg::ConstDataWrapper< _DataType > | |
| Eigen::MatrixBase< Derived >::ConstDiagonalIndexReturnType< Index > | |
| Eigen::SparseMatrixBase< Derived >::ConstFixedSegmentReturnType< Size > | |
| Eigen::DenseBase< Derived >::ConstFixedSegmentReturnType< Size > | |
| ConstFixedSegmentReturnType< Size > | |
| Eigen::SparseMatrixBase< Derived >::ConstNColsBlockXpr< N > | |
| Eigen::DenseBase< Derived >::ConstNColsBlockXpr< N > | |
| ConstNColsBlockXpr< N > | |
| Eigen::SparseMatrixBase< Derived >::ConstNRowsBlockXpr< N > | |
| Eigen::DenseBase< Derived >::ConstNRowsBlockXpr< N > | |
| ConstNRowsBlockXpr< N > | |
| Eigen::Transform< _Scalar, _Dim >::construct_from_matrix< OtherDerived, BigMatrix > | |
| Eigen::Transform< _Scalar, _Dim >::construct_from_matrix< OtherDerived, true > | |
| Eigen::internal::constructor_without_unaligned_array_assert | |
| Eigen::MatrixBase< Derived >::ConstSelfAdjointViewReturnType< UpLo > | |
| Eigen::MatrixBase< Derived >::ConstTriangularViewReturnType< Mode > | |
| Container< T, N > | |
| glw::Context | |
| vcg::tri::ContinuityLoopWeight< SCALAR_TYPE > | |
| Collada::Tags::ContributorTag | |
| vcg::Controller< Token > | |
| mpfr::conversion_overflow | |
| vcg::tri::ConvexHull< InputMesh, CHMesh > | |
| vcg::vertex::Coord< A, T > | Generic Component: Geometric Position of the vertex Templated on the coordinate class. In practice you use one of the two specialized class Coord3f and Coord3d You can access to the coordinate of a vertex by mean of the P(),cP() member functions |
| vcg::vertex::Coord3d< T > | Specialized Coord Component in double point precision |
| vcg::vertex::Coord3dOcc< T > | |
| vcg::vertex::Coord3f< T > | Specialized Coord Component in floating point precision |
| vcg::vertex::Coord3fOcc< T > | |
| vcg::CoordinateFrame | The CoordinateFrame class |
| CoordNumber< POINTTYPE > | |
| CoordNumber< vcg::Color4b > | |
| CoordNumber< vcg::Point2f > | |
| CoordNumber< vcg::Point3f > | |
| CoordNumber< vcg::Point4f > | |
| vcg::vertex::CoordOcc< A, T > | |
| vcg::tri::io::Correspondence | |
| Eigen::internal::member_redux< BinaryOp, Scalar >::Cost< _Scalar, Size > | |
| vcg::tri::FourPCS< MeshType >::Couple | |
| Collada::Tags::CreatedTag | |
| Eigen::internal::cross3_impl< Arch, VectorLhs, VectorRhs, Scalar, Vectorizable > | |
| Eigen::internal::cross3_impl< Architecture::SSE, VectorLhs, VectorRhs, float, true > | |
| Eigen::MatrixBase< Derived >::cross_product_return_type< OtherDerived > | |
| vcg::tri::CrossField< MeshType > | |
| vcg::vertex::Curvature< A, TT > | Component: Per vertex basic curvature This component keeps the mean an gaussian curvature for a vertex. Used by some of the algorithms of vcg::tri::UpdateCurvature to store the computed curvatures |
| vcg::vertex::Curvatured< T > | |
| vcg::face::CurvatureDir< A, TT > | |
| vcg::vertex::CurvatureDir< A, TT > | Component: Per vertex curvature directions This component keep the principal curvature directions. Used by some of the algorithms of vcg::tri::UpdateCurvature to store the computed curvatures |
| vcg::face::CurvatureDirBaseType< S > | |
| vcg::vertex::CurvatureDirBaseType< S > | |
| vcg::face::CurvatureDird< T > | |
| vcg::vertex::CurvatureDird< T > | |
| vcg::vertex::CurvatureDirdOcc< T > | |
| vcg::face::CurvatureDirdOcf< T > | |
| vcg::vertex::CurvatureDirdOcf< T > | |
| vcg::face::CurvatureDirf< T > | |
| vcg::vertex::CurvatureDirf< T > | |
| vcg::vertex::CurvatureDirfOcc< T > | |
| vcg::face::CurvatureDirfOcf< T > | |
| vcg::vertex::CurvatureDirfOcf< T > | |
| vcg::vertex::CurvatureDirOcc< A, TT > | |
| vcg::face::CurvatureDirOcf< A, T > | |
| vcg::vertex::CurvatureDirOcf< A, TT > | |
| vcg::face::CurvatureDirOcfBaseType< S > | |
| vcg::vertex::CurvatureDirTypeOcc< S > | |
| vcg::vertex::CurvatureDirTypeOcf< S > | *-------------------------- CURVATURE DIR ----------------------------------*/ |
| vcg::vertex::CurvaturedOcc< T > | |
| vcg::vertex::CurvaturedOcf< T > | |
| vcg::vertex::Curvaturef< T > | |
| vcg::vertex::CurvaturefOcc< T > | |
| vcg::vertex::CurvaturefOcf< T > | |
| vcg::vertex::CurvatureOcc< A, TT > | *-------------------------- Curvature ----------------------------------*/ |
| vcg::vertex::CurvatureOcf< A, TT > | *-------------------------- CURVATURE ----------------------------------*/ |
| CUsedTypes | |
| nanoply::NanoPlyWrapper< MeshType >::CustomAttributeDescriptor | |
| CVertex | Compositing wanted proprieties |
| CVertexO | Compositing wanted proprieties |
| Eigen::Cwise< ExpressionType > | Pseudo expression providing additional coefficient-wise operations |
| Eigen::CwiseBinaryOp< BinaryOp, Lhs, Rhs > | Generic expression where a coefficient-wise binary operator is applied to two expressions |
| Eigen::CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, Dense > | |
| Eigen::CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, Sparse > | |
| Eigen::CwiseNullaryOp< NullaryOp, PlainObjectType > | Generic expression of a matrix where all coefficients are defined by a functor |
| Eigen::CwiseUnaryOp< UnaryOp, XprType > | Generic expression where a coefficient-wise unary operator is applied to an expression |
| Eigen::CwiseUnaryOpImpl< UnaryOp, MatrixType, Sparse > | |
| Eigen::CwiseUnaryOpImpl< UnaryOp, XprType, Dense > | |
| Eigen::CwiseUnaryView< ViewOp, MatrixType > | Generic lvalue expression of a coefficient-wise unary operator of a matrix or a vector |
| Eigen::CwiseUnaryViewImpl< ViewOp, MatrixType, Dense > | |
| Eigen::CwiseUnaryViewImpl< ViewOp, MatrixType, Sparse > | |
| vcg::tri::CylinderClipping< MeshType > | |
| vcg::CylinderMode | The constrained rotation manipulator |
| vcg::tri::CylinderClipping< MeshType >::CylMidPoint | |
| vcg::tri::CylinderClipping< MeshType >::CylPred | |
| vcg::PerfectSpatialHashing< OBJECT_TYPE, SCALAR_TYPE >::HashTable::Data | |
| nanoply::DataDescriptor< CointainerType, VectorSize, ScalarType > | |
| Eigen::internal::decrement_if_fixed_size< Size > | |
| Eigen::internal::decrement_size< n > | |
| Eigen::internal::default_packet_traits | |
| Eigen::SparseMatrix< _Scalar, _Options, _Index >::default_prunning_func | |
| glw::detail::DefaultDeleter< T > | |
| vcg::DefaultDeriver< T > | |
| glw::detail::DeleterOf< T > | |
| glw::detail::DeleterOf< BoundObject > | |
| glw::detail::DeleterOf< Object > | |
| glw::detail::DeleterOf< SafeObject > | |
| glw::detail::DeleterOfType< T, B > | |
| glw::detail::DeleterOfType< T, NoType > | |
| Eigen::Dense | |
| Eigen::internal::dense_xpr_base< Derived, XprKind > | |
| Eigen::internal::dense_xpr_base< Derived, ArrayXpr > | |
| Eigen::internal::dense_xpr_base< Derived, MatrixXpr > | |
| Eigen::DenseBase< Derived > | Base class for all dense matrices, vectors, and arrays |
| DenseCoeffsBase | |
| Eigen::DenseCoeffsBase< Derived, DirectAccessors > | Base class providing direct read-only coefficient access to matrices and arrays |
| Eigen::DenseCoeffsBase< Derived, DirectWriteAccessors > | Base class providing direct read/write coefficient access to matrices and arrays |
| Eigen::DenseCoeffsBase< Derived, ReadOnlyAccessors > | Base class providing read-only coefficient access to matrices and arrays |
| Eigen::DenseCoeffsBase< Derived, WriteAccessors > | Base class providing read/write coefficient access to matrices and arrays |
| Eigen::DenseFunctor< _Scalar, NX, NY > | |
| Eigen::DenseSparseProductReturnType< Lhs, Rhs, InnerSize > | |
| Eigen::DenseSparseProductReturnType< Lhs, Rhs, 1 > | |
| Eigen::DenseStorage< T, Size, _Rows, _Cols, _Options > | |
| Eigen::DenseStorage< T, 0, _Rows, _Cols, _Options > | |
| Eigen::DenseStorage< T, 0, _Rows, Dynamic, _Options > | |
| Eigen::DenseStorage< T, 0, Dynamic, _Cols, _Options > | |
| Eigen::DenseStorage< T, 0, Dynamic, Dynamic, _Options > | |
| Eigen::DenseStorage< T, Dynamic, _Rows, Dynamic, _Options > | |
| Eigen::DenseStorage< T, Dynamic, Dynamic, _Cols, _Options > | |
| Eigen::DenseStorage< T, Dynamic, Dynamic, Dynamic, _Options > | |
| Eigen::DenseStorage< T, Size, _Rows, Dynamic, _Options > | |
| Eigen::DenseStorage< T, Size, Dynamic, _Cols, _Options > | |
| Eigen::DenseStorage< T, Size, Dynamic, Dynamic, _Options > | |
| Eigen::DenseTimeSparseProduct< Lhs, Rhs > | |
| Eigen::DenseTimeSparseSelfAdjointProduct< Lhs, Rhs, UpLo > | |
| DepthRenderBuffer | |
| DepthRenderTarget | |
| DepthRenderTexture | |
| DepthTexture | |
| DepthTexture2D | |
| std::deque< T, EIGEN_ALIGNED_ALLOCATOR< T > > | |
| Der | |
| vcg::tri::Der< T, CONT > | |
| vcg::tri::io::Der< MeshType, A, T > | |
| vcg::Dereferencer< TYPE > | |
| vcg::PerfectSpatialHashing< OBJECT_TYPE, SCALAR_TYPE >::Dereferencer< TYPE > | |
| vcg::tri::io::DerK< MeshType, A, T > | |
| nanoply::DescriptorInterface | |
| Eigen::internal::determinant_impl< Derived, DeterminantType > | |
| Eigen::internal::determinant_impl< Derived, 1 > | |
| Eigen::internal::determinant_impl< Derived, 2 > | |
| Eigen::internal::determinant_impl< Derived, 3 > | |
| Eigen::internal::determinant_impl< Derived, 4 > | |
| Eigen::DGMRES< _MatrixType, _Preconditioner > | A Restarted GMRES with deflation. This class implements a modification of the GMRES solver for sparse linear systems. The basis is built with modified Gram-Schmidt. At each restart, a few approximated eigenvectors corresponding to the smallest eigenvalues are used to build a preconditioner for the next cycle. This preconditioner for deflation can be combined with any other preconditioner, the IncompleteLUT for instance. The preconditioner is applied at right of the matrix and the combination is multiplicative |
| DHeap< T > | |
| Eigen::Diagonal< MatrixType, _DiagIndex > | Expression of a diagonal/subdiagonal/superdiagonal in a matrix |
| Eigen::DiagonalBase< Derived > | |
| Eigen::MatrixBase< Derived >::DiagonalIndexReturnType< Index > | |
| Eigen::internal::BandMatrixBase< Derived >::DiagonalIntReturnType< Index > | |
| Eigen::DiagonalMatrix< _Scalar, SizeAtCompileTime, MaxSizeAtCompileTime > | Represents a diagonal matrix with its storage |
| Eigen::DiagonalPreconditioner< _Scalar > | A preconditioner based on the digonal entries |
| Eigen::DiagonalProduct< MatrixType, DiagonalType, ProductOrder > | |
| Eigen::DiagonalWrapper< _DiagonalVectorType > | Expression of a diagonal matrix |
| Collada::Tags::DiffuseTag | |
| vcg::tri::Geodesic< MeshType >::DIJKDist | |
| vcg::DiracPolicy< C > | Really simple example policy |
| Eigen::internal::direct_selfadjoint_eigenvalues< SolverType, Size, IsComplex > | |
| Eigen::internal::direct_selfadjoint_eigenvalues< SolverType, 2, false > | |
| Eigen::internal::direct_selfadjoint_eigenvalues< SolverType, 3, false > | |
| vcg::DisjointSet< OBJECT_TYPE > | |
| vcg::DisjointSet< OBJECT_TYPE >::DisjointSetNode | |
| vcg::tri::Distortion< MeshType, PerWedgeFlag > | |
| vcg::Distribution< ScalarType > | |
| Collada::DocumentManager | |
| Eigen::internal::dot_nocheck< T, U, NeedToTranspose > | |
| Eigen::internal::dot_nocheck< T, U, true > | |
| Eigen::internal::gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, _ConjLhs, _ConjRhs >::DoublePacket | |
| glw::DrawFramebufferBindingParams | |
| vcg::trackutils::DrawingHint | Drawing hints for manipulators |
| vcg::DumClass | |
| vcg::tri::DummyContainer | |
| vcg::math::DummyPolarFunctor< ScalarType > | |
| vcg::tri::io::DummyType< N > | |
| vcg::DummyTypes | |
| DuplicateVert_Compare< VertexIterator > | |
| vcg::math::DynamicLegendre< ScalarType, MAX_L > | |
| Eigen::DynamicSparseMatrix< _Scalar, _Options, _Index > | A sparse matrix class designed for matrix assembly purpose |
| vcg::DynamicSpatialHashTable< ContainerType, FLT > | |
| eckerle4_functor | |
| vcg::Edge< UserTypes, A, B, C, D, E, F, G, H, I, J > | |
| vcg::EdgeArityMax< UserTypes, A, B, C, D, E, F, G, H, I, J > | |
| vcg::tri::EdgeCollapser< TRI_MESH_TYPE, VertexPair > | |
| vcg::tri::EdgeFlipPriority< MeshType > | Generic priority for edge rotations |
| vcg::tri::TriMeshClipper< TRIMESHTYPE >::EdgeIntersections | |
| vcg::tri::TriMeshClipper< TRIMESHTYPE >::EdgeIsect | |
| vcg::tri::EdgeLen< MESH_TYPE, FLT > | |
| vcg::face::EdgePlane< T > | Per Face Precomputed Edge/Plane |
| vcg::face::EdgePlaneInfo< CoordType > | |
| vcg::tri::CoM< MeshType >::EdgePointPred | |
| vcg::tri::CoM< MeshType >::EdgePointSplit | |
| vcg::tri::Quadrangulator< TriMesh, PolyMesh >::EdgePredicate< MESH_TYPE > | |
| vcg::tri::EdgeCollapser< TRI_MESH_TYPE, VertexPair >::EdgeSet | |
| vcg::tri::UpdateFlags< UpdateMeshType >::EdgeSorter | |
| vcg::tri::EdgeSplSphere< FLT > | |
| vcg::tri::EdgeTmark< MESH_TYPE > | |
| vcg::tri::Hole< MESH >::EdgeToBeAvoided | |
| vcg::EdgeTypeHolder< UserTypes > | |
| vcg::edge::EEAdj< T > | Component: Edge-Edge adjacency relation This component implement store the pointer (and index) of the adjacent edges. If the vertex is 1-manifold (as in a classical polyline) it holds that: |
| vcg::edge::EFAdj< T > | Component: Edge-Face adjacency relation This component implement store the pointer to a face sharing this edge |
| vcg::face::EFAdj< T > | |
| Collada::Tags::EffectTag | |
| vcg::edge::EHAdj< T > | |
| Eigen::ei_cleantype< T > | |
| Eigen::ei_cleantype< const T & > | |
| Eigen::ei_cleantype< const T * > | |
| Eigen::ei_cleantype< const T > | |
| Eigen::ei_cleantype< T & > | |
| Eigen::ei_cleantype< T * > | |
| Eigen::ei_import_selector< Derived1, Derived2, false, false > | |
| Eigen::ei_import_selector< Derived1, Derived2, false, true > | |
| Eigen::ei_import_selector< Derived1, Derived2, true, true > | |
| Eigen::ei_is_same_type< T, U > | |
| Eigen::ei_is_same_type< T, T > | |
| Eigen::ei_lexi_comparison< Derived1, Derived2, 2 > | |
| Eigen::ei_lexi_comparison< Derived1, Derived2, 3 > | |
| Eigen::ei_lexi_comparison< Derived1, Derived2, 4 > | |
| Eigen::ei_meta_false | |
| Eigen::ei_meta_if< Condition, Then, Else > | |
| Eigen::ei_meta_if< false, Then, Else > | |
| Eigen::ei_meta_sqrt< Y, InfX, SupX, Done > | |
| Eigen::ei_meta_sqrt< Y, InfX, SupX, true > | |
| Eigen::ei_meta_true | |
| Eigen::ei_quaternion_assign_impl< Other, 3, 3 > | |
| Eigen::ei_quaternion_assign_impl< Other, 4, 1 > | |
| Eigen::ei_to_vcgtype< XprType, Rows, Cols, StorageOrder, MRows, MCols > | |
| Eigen::ei_traits< T > | |
| Eigen::ei_traits< AngleAxis< _Scalar > > | |
| Eigen::ei_traits< Quaternion< _Scalar > > | |
| Eigen::ei_traits< Rotation2D< _Scalar > > | |
| Eigen::ei_transform_product_impl< Other, Dim, HDim, Dim, 1 > | |
| Eigen::ei_transform_product_impl< Other, Dim, HDim, Dim, Dim > | |
| Eigen::ei_transform_product_impl< Other, Dim, HDim, HDim, 1 > | |
| Eigen::ei_transform_product_impl< Other, Dim, HDim, HDim, HDim > | |
| Eigen::ei_unconst< T > | |
| Eigen::ei_unconst< const T > | |
| Eigen::ei_unconst< T const & > | |
| Eigen::ei_unconst< T const * > | |
| Eigen::ei_unpointer< T > | |
| Eigen::ei_unpointer< T * > | |
| Eigen::ei_unpointer< T *const > | |
| Eigen::ei_unref< T > | |
| Eigen::ei_unref< T & > | |
| Eigen::EigenBase< Derived > | |
| Eigen::EigenSolver< _MatrixType > | Computes eigenvalues and eigenvectors of general matrices |
| Eigen::internal::eigenvalues_selector< Derived, IsComplex > | |
| Eigen::internal::eigenvalues_selector< Derived, false > | |
| vcg::HeapMaxPriorityQueue< Index, Weight >::Element | |
| nanoply::ElementDescriptor | |
| vcg::tri::EMCLookUpTable | |
| EmEdge | |
| EmFace | |
| Collada::Tags::EmissionTag | |
| EmMesh | |
| vcg::tetra::EmptyAdj< T > | |
| vcg::hedge::EmptyBitFlags< T > | |
| vcg::tetra::EmptyBitFlags< T > | |
| vcg::EmptyClass | |
| vcg::edge::EmptyCore< T > | |
| vcg::face::EmptyCore< T > | |
| vcg::vertex::EmptyCore< TT > | |
| vcg::face::EmptyEdgePlane< T > | |
| vcg::tetra::EmptyFaceNormal< A, T > | |
| vcg::hedge::EmptyHEAdj< T > | |
| vcg::hedge::EmptyHEdgeData< T > | |
| vcg::hedge::EmptyHFAdj< T > | |
| vcg::hedge::EmptyHHAdj< T > | |
| vcg::hedge::EmptyHNextAdj< T > | |
| vcg::hedge::EmptyHOppAdj< T > | |
| vcg::hedge::EmptyHPrevAdj< T > | |
| vcg::hedge::EmptyHVAdj< T > | |
| vcg::hedge::EmptyMark< T > | *-------------------------- VERTEX ----------------------------------------*/ |
| vcg::tetra::EmptyMark< T > | |
| vcg::vert::EmptyOSGColor< T > | |
| vcg::vert::EmptyOSGCoord< T > | |
| vcg::vert::EmptyOSGInfo< T > | Some Naming Rules : All the Components that can be added to a vertex should be defined in the namespace vert: |
| vcg::vert::EmptyOSGNormal< T > | |
| vcg::tri::EmptyTMark< MESH_TYPE > | |
| vcg::tetra::EmptyVertexRef< T > | |
| EmUsedTypes | |
| EmVertex | |
| Eigen::internal::enable_if< true, T > | |
| vcg::RayIterator< Spatial_Idexing, INTFUNCTOR, TMARKER >::Entry_Type | Structure that mantain for the current cell pre-calculated data |
| vcg::ClosestIterator< Spatial_Idexing, DISTFUNCTOR, TMARKER >::Entry_Type | Structure that mantain for the current cell pre-calculated data |
| vcg::RayIterator2D< Spatial_Idexing, INTFUNCTOR, TMARKER >::Entry_Type | Structure that mantain for the current cell pre-calculated data |
| vcg::EntryCAT< STL_CONT, ATTR_TYPE > | |
| vcg::EntryCATBase< STL_CONT > | |
| vcg::PerfectSpatialHashing< OBJECT_TYPE, SCALAR_TYPE >::UniformGrid::EntryIterator | |
| EntryNode | |
| vcg::Env | |
| vcg::tri::FourPCS< MeshType >::EPoint | |
| vcg::tri::EuclideanDistance< MeshType > | |
| vcg::edge::EVAdj< T > | |
| Eigen::internal::eval< Array< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Dense > | |
| Eigen::internal::eval< Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Dense > | |
| Eigen::internal::eval< T, Dense > | |
| Eigen::internal::eval< T, IsSkyline > | |
| Eigen::internal::eval< T, Sparse > | |
| vcg::tri::EvenPointLoop< MESH_TYPE > | |
| vcg::tri::EvenPointLoopGeneric< MESH_TYPE, METHOD_TYPE, WEIGHT_TYPE > | |
| vcg::tri::io::Exporter< OpenMeshType > | |
| vcg::tri::io::Exporter3DS< SaveMeshType > | |
| vcg::tri::io::ExporterCTM< SaveMeshType > | |
| vcg::tri::io::ExporterDAE< MESHMODEL > | |
| vcg::edg::io::ExporterDXF< EdgeMeshType > | |
| vcg::tri::io::ExporterDXF< SaveMeshType > | |
| ExporterFBX< SaveMeshType > | |
| vcg::tri::io::ExporterFIELD< MeshType > | |
| vcg::tri::io::ExporterGTS< SaveMeshType > | |
| vcg::tri::io::ExporterIDTF< SaveMeshType > | |
| vcg::tri::io::ExporterOBJ< SaveMeshType > | |
| vcg::tri::io::ExporterOFF< SaveMeshType > | |
| vcg::tetra::io::ExporterPLY< SaveMeshType > | |
| vcg::tri::io::ExporterPLY< SaveMeshType > | |
| vcg::tri::io::ExporterSMF< SaveMeshType > | |
| vcg::tri::io::ExporterSTL< SaveMeshType > | |
| vcg::tri::io::ExporterSVG< EdgeMeshType > | |
| vcg::tetra::io::ExporterTS< MESHTYPE > | |
| vcg::tri::io::ExporterU3D< SaveMeshType > | |
| vcg::tri::io::ExporterVMI< SaveMeshType > | |
| vcg::tri::io::ExporterWRL< SaveMeshType > | |
| vcg::tri::ExtendedMarchingCubes< TRIMESH_TYPE, WALKER_TYPE > | This class implements the Extended Marching Cubes algorithm |
| Eigen::VectorwiseOp< ExpressionType, Direction >::ExtendedType< OtherDerived > | |
| Eigen::internal::extract_data_selector< T, HasUsableDirectAccess > | |
| Eigen::internal::extract_data_selector< T, false > | |
| vcg::tri::ExtrinsicPlaneSymmetry< TriMeshType > | |
| vcg::tri::Extrude< MeshType > | |
| vcg::tri::Zonohedron< Scalar >::Face | |
| vcg::Face< UserTypes, A, B, C, D, E, F, G, H, I, J, K, L > | |
| Face | |
| vcg::FaceArityMax< UserTypes, A, B, C, D, E, F, G, H, I, J, K, L > | |
| vcg::FaceBase< UserTypes > | |
| vcg::ImplicitSmoother< MeshType >::FaceConstraint | |
| vcg::tri::Geodesic< MeshType >::FaceDist | |
| vcg::tetra::FaceNormal< A, T > | |
| vcg::tetra::FaceNormal3d< T > | |
| vcg::tetra::FaceNormal3f< T > | |
| vcg::tri::UpdateHalfEdges< MeshType >::FacePtrInt | |
| vcg::tri::FaceTmark< MESH_TYPE > | |
| FacetNode | |
| FacetsNode | |
| vcg::FaceTypeHolder< UserTypes > | |
| FAIL | |
| vcg::tri::TriEdgeCollapse< TriMeshType, VertexPair, MYTYPE >::FailStat | Static data to gather statistical information about the reasons of collapse failures |
| Eigen::internal::false_type | |
| vcg::face::FEAdj< T > | |
| vcg::tri::FeasibilityCheck< MeshType, TriMeshType > | Generic class for checking feasibility of collapses |
| glw::FeedbackBufferBindingParams | |
| vcg::face::FFAdj< T > | Component: Per Face Face-Face adjacency relation |
| vcg::face::FFAdjOcc< T > | |
| vcg::face::FFAdjOccBase< A, T > | |
| vcg::face::FFAdjOcf< T > | |
| vcg::face::FFAdjTypeSup< FP > | |
| Eigen::internal::fftw_impl< _Scalar > | |
| Eigen::internal::fftw_plan< T > | |
| Eigen::internal::fftw_plan< double > | |
| Eigen::internal::fftw_plan< float > | |
| Eigen::internal::fftw_plan< long double > | |
| vcg::face::FHAdj< T > | |
| vcg::tri::FieldSmoother< MeshType > | |
| Eigen::internal::first_aligned_impl< Derived, JustReturnZero > | |
| Eigen::internal::first_aligned_impl< Derived, false > | |
| vcg::tri::Fitmaps< MeshType > | |
| vcg::tri::FitmapsCollapse< MeshType, TriMeshType > | Class that provides methods for checking and weighting collapses using fitmaps |
| Eigen::SparseMatrixBase< Derived >::FixedSegmentReturnType< Size > | |
| Eigen::DenseBase< Derived >::FixedSegmentReturnType< Size > | |
| FixedSegmentReturnType< Size > | |
| Eigen::Flagged< ExpressionType, Added, Removed > | Expression with modified flags |
| vcg::vertex::FlagOcc< T > | *------------------------- FLAGS -----------------------------------------*/ |
| Collada::Tags::FloatArrayTag | |
| Collada::Tags::FloatTag | |
| Eigen::internal::floor_log2< n, lower, upper, selector > | |
| Eigen::internal::floor_log2< n, lower, upper, floor_log2_bogus > | |
| Eigen::internal::floor_log2< n, lower, upper, floor_log2_move_down > | |
| Eigen::internal::floor_log2< n, lower, upper, floor_log2_move_up > | |
| Eigen::internal::floor_log2< n, lower, upper, floor_log2_terminate > | |
| Eigen::internal::floor_log2_selector< n, lower, upper > | |
| Eigen::ForceAlignedAccess< ExpressionType > | Enforce aligned packet loads and stores regardless of what is requested |
| Collada::Tags::FormatTag | |
| vcg::tri::FourPCS< MeshType > | |
| vcg::MT< C >::Frag | |
| glw::FragmentOutputBinding | |
| glw::FragmentShader | |
| FragmentShader | |
| glw::FragmentShaderArguments | |
| glw::FragmentShaderBindingParams | |
| FrameBuffer | |
| glw::Framebuffer | |
| glw::FramebufferArguments | |
| glw::FramebufferBindingParams | |
| FrameBufferSemantic | |
| omip::FrameForSegmentation | |
| vcg::tri::FrontEdge | |
| vcg::Frustum< T > | |
| vcg::FrustumPolicy< C > | |
| Eigen::FullPivHouseholderQR< _MatrixType > | Householder rank-revealing QR decomposition of a matrix with full pivoting |
| Eigen::internal::FullPivHouseholderQRMatrixQReturnType< MatrixType > | Expression type for return value of FullPivHouseholderQR::matrixQ() |
| Eigen::FullPivLU< _MatrixType > | LU decomposition of a matrix with complete pivoting, and related features |
| Functor< _Scalar, NX, NY > | |
| Eigen::internal::functor_has_linear_access< Functor > | |
| Eigen::internal::functor_has_linear_access< scalar_identity_op< Scalar > > | |
| Eigen::internal::functor_is_product_like< Functor > | |
| Eigen::internal::functor_is_product_like< scalar_conj_product_op< LhsScalar, RhsScalar > > | |
| Eigen::internal::functor_is_product_like< scalar_product_op< LhsScalar, RhsScalar > > | |
| Eigen::internal::functor_is_product_like< scalar_quotient_op< LhsScalar, RhsScalar > > | |
| Eigen::internal::functor_traits< T > | |
| Eigen::internal::functor_traits< linspaced_op< Scalar, RandomAccess > > | |
| Eigen::internal::functor_traits< max_coeff_visitor< Scalar > > | |
| Eigen::internal::functor_traits< min_coeff_visitor< Scalar > > | |
| Eigen::internal::functor_traits< scalar_abs2_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_abs_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_acos_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_add_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_asin_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_binary_pow_op< Scalar, OtherScalar > > | |
| Eigen::internal::functor_traits< scalar_boolean_and_op > | |
| Eigen::internal::functor_traits< scalar_boolean_or_op > | |
| Eigen::internal::functor_traits< scalar_cast_op< Scalar, NewType > > | |
| Eigen::internal::functor_traits< scalar_cmp_op< Scalar, cmp > > | |
| Eigen::internal::functor_traits< scalar_conj_product_op< LhsScalar, RhsScalar > > | |
| Eigen::internal::functor_traits< scalar_conjugate_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_constant_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_cos_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_cube_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_difference_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_exp_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_hypot_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_identity_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_imag_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_imag_ref_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_inverse_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_log_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_max_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_min_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_multiple2_op< Scalar1, Scalar2 > > | |
| Eigen::internal::functor_traits< scalar_multiple_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_opposite_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_pow_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_product_op< LhsScalar, RhsScalar > > | |
| Eigen::internal::functor_traits< scalar_quotient1_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_quotient_op< LhsScalar, RhsScalar > > | |
| Eigen::internal::functor_traits< scalar_random_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_real_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_real_ref_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_sin_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_sqrt_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_square_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_sum_op< Scalar > > | |
| Eigen::internal::functor_traits< scalar_tan_op< Scalar > > | |
| Eigen::internal::functor_traits< std::binary_negate< T > > | |
| Eigen::internal::functor_traits< std::binder1st< T > > | |
| Eigen::internal::functor_traits< std::binder2nd< T > > | |
| Eigen::internal::functor_traits< std::divides< T > > | |
| Eigen::internal::functor_traits< std::equal_to< T > > | |
| Eigen::internal::functor_traits< std::greater< T > > | |
| Eigen::internal::functor_traits< std::greater_equal< T > > | |
| Eigen::internal::functor_traits< std::less< T > > | |
| Eigen::internal::functor_traits< std::less_equal< T > > | |
| Eigen::internal::functor_traits< std::logical_and< T > > | |
| Eigen::internal::functor_traits< std::logical_not< T > > | |
| Eigen::internal::functor_traits< std::logical_or< T > > | |
| Eigen::internal::functor_traits< std::minus< T > > | |
| Eigen::internal::functor_traits< std::multiplies< T > > | |
| Eigen::internal::functor_traits< std::negate< T > > | |
| Eigen::internal::functor_traits< std::not_equal_to< T > > | |
| Eigen::internal::functor_traits< std::plus< T > > | |
| Eigen::internal::functor_traits< std::unary_negate< T > > | |
| Eigen::internal::gebp_kernel< LhsScalar, RhsScalar, Index, mr, nr, ConjugateLhs, ConjugateRhs > | |
| Eigen::internal::gebp_madd_selector< CJ, A, B, C, T > | |
| Eigen::internal::gebp_madd_selector< CJ, T, T, T, T > | |
| Eigen::internal::gebp_traits< _LhsScalar, _RhsScalar, _ConjLhs, _ConjRhs > | |
| Eigen::internal::gebp_traits< RealScalar, std::complex< RealScalar >, false, _ConjRhs > | |
| Eigen::internal::gebp_traits< std::complex< RealScalar >, RealScalar, _ConjLhs, false > | |
| Eigen::internal::gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, _ConjLhs, _ConjRhs > | |
| Eigen::internal::gemm_blocking_space< StorageOrder, _LhsScalar, _RhsScalar, MaxRows, MaxCols, MaxDepth, KcFactor, false > | |
| Eigen::internal::gemm_blocking_space< StorageOrder, _LhsScalar, _RhsScalar, MaxRows, MaxCols, MaxDepth, KcFactor, true > | |
| Eigen::internal::gemm_functor< Scalar, Index, Gemm, Lhs, Rhs, Dest, BlockingType > | |
| Eigen::internal::gemm_pack_lhs< Scalar, Index, Pack1, Pack2, StorageOrder, Conjugate, PanelMode > | |
| Eigen::internal::gemm_pack_rhs< Scalar, Index, nr, ColMajor, Conjugate, PanelMode > | |
| Eigen::internal::gemm_pack_rhs< Scalar, Index, nr, RowMajor, Conjugate, PanelMode > | |
| Eigen::internal::GemmParallelInfo< Index > | |
| Eigen::internal::gemv_selector< OnTheLeft, StorageOrder, BlasCompatible > | |
| Eigen::internal::gemv_selector< OnTheRight, ColMajor, false > | |
| Eigen::internal::gemv_selector< OnTheRight, ColMajor, true > | |
| Eigen::internal::gemv_selector< OnTheRight, RowMajor, false > | |
| Eigen::internal::gemv_selector< OnTheRight, RowMajor, true > | |
| Eigen::internal::gemv_static_vector_if< Scalar, Size, Dynamic, true > | |
| Eigen::internal::gemv_static_vector_if< Scalar, Size, MaxSize, false > | |
| Eigen::internal::gemv_static_vector_if< Scalar, Size, MaxSize, true > | |
| Eigen::internal::general_matrix_matrix_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, ColMajor > | |
| Eigen::internal::general_matrix_matrix_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, RowMajor > | |
| Eigen::internal::general_matrix_matrix_rankupdate< Index, Scalar, AStorageOrder, ConjugateA, ResStorageOrder, UpLo > | |
| Eigen::internal::general_matrix_matrix_triangular_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, ColMajor, UpLo, Version > | |
| Eigen::internal::general_matrix_matrix_triangular_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, RowMajor, UpLo, Version > | |
| Eigen::internal::general_matrix_vector_product< Index, LhsScalar, ColMajor, ConjugateLhs, RhsScalar, ConjugateRhs, Version > | |
| Eigen::internal::general_matrix_vector_product< Index, LhsScalar, RowMajor, ConjugateLhs, RhsScalar, ConjugateRhs, Version > | |
| Eigen::internal::general_matrix_vector_product_gemv< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, ConjugateRhs > | |
| Eigen::general_product_to_triangular_selector< MatrixType, ProductType, UpLo, false > | |
| Eigen::general_product_to_triangular_selector< MatrixType, ProductType, UpLo, true > | |
| Eigen::GeneralizedEigenSolver< _MatrixType > | Computes the generalized eigenvalues and eigenvectors of a pair of general matrices |
| Eigen::GeneralizedSelfAdjointEigenSolver< _MatrixType > | Computes eigenvalues and eigenvectors of the generalized selfadjoint eigen problem |
| GeneralProduct | Expression of the product of two general matrices or vectors |
| Eigen::GeneralProduct< Lhs, Rhs, GemmProduct > | |
| Eigen::GeneralProduct< Lhs, Rhs, GemvProduct > | |
| Eigen::GeneralProduct< Lhs, Rhs, InnerProduct > | |
| Eigen::GeneralProduct< Lhs, Rhs, OuterProduct > | |
| generateTestMatrix< MatrixType, 0 > | |
| generateTestMatrix< MatrixType, 1 > | |
| generateTriangularMatrix< MatrixType, 0 > | |
| generateTriangularMatrix< MatrixType, 1 > | |
| Eigen::GenericNumTraits< T > | |
| vcg::tri::GenericVertexInterpolator< MESH_TYPE > | |
| vcg::GenNormal< ScalarType > | |
| vcg::tri::Geodesic< MeshType > | Class for computing approximate geodesic distances on a mesh |
| vcg::tri::GeometricInterpolator< VertexType > | |
| GeometryShader | |
| glw::GeometryShader | |
| glw::GeometryShaderArguments | |
| glw::GeometryShaderBindingParams | |
| glw::GeometryStage | |
| Collada::Tags::GeometryTag | |
| Eigen::internal::get_boxes_helper< ObjectList, VolumeList, BoxIter > | |
| Eigen::internal::get_boxes_helper< ObjectList, VolumeList, int > | |
| Eigen::internal::get_factor< From, To > | |
| Eigen::internal::get_factor< Scalar, typename NumTraits< Scalar >::Real > | |
| vcg::GetBarycenter3Functor | |
| vcg::GetBox3Functor | |
| GetOpt | |
| vcg::GetPointerFunctor | |
| vcg::gl_surface | |
| vcg::GL_TYPE_NM< T > | |
| vcg::GL_TYPE_NM< double > | |
| vcg::GL_TYPE_NM< float > | |
| vcg::GLW::GLAElem | |
| GLArea | |
| vcg::GLMeshAttributesFeeder< MESHTYPE >::GLBufferObject | |
| GlCamera< CameraType > | |
| vcg::GLFeederInfo::GLFeederException | |
| vcg::GLFeederInfo | |
| vcg::GLField< MeshType > | |
| vcg::glLabel | |
| vcg::GLMeshAttributesFeeder< MESHTYPE > | |
| Eigen::internal::global_math_functions_filtering_base< T, dummy > | |
| Eigen::internal::global_math_functions_filtering_base< T, typename always_void< typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl >::type > | |
| GLObject | |
| vcg::GLPickTri< MESH_TYPE > | |
| vcg::GlPos< PosType > | |
| GlShot< ShotType > | |
| vcg::tetra::GlTetramesh< CONT_TETRA > | |
| vcg::GlTrimesh< MeshType, partial, FACE_POINTER_CONTAINER > | |
| vcg::glu_tesselator | |
| vcg::GlVfIterator< VfIteType > | |
| vcg::tetra::GLW | |
| vcg::GLW | |
| GLWidget | |
| Eigen::GMRES< _MatrixType, _Preconditioner > | A GMRES solver for sparse square problems |
| vcg::GridStaticObj< ObjType, FLT > | |
| vcg::GridStaticPtr< OBJTYPE, FLT > | |
| vcg::GridStaticPtr2D< OBJTYPE, FLT > | |
| H | |
| hahn1_functor | |
| vcg::tri::HalfedgeQuadClean< MeshType > | The class provides methods for detecting doublets and singlets and removing them |
| vcg::tri::HalfEdgeTopology< MeshType > | Class containing functions to modify the topology of a halfedge based mesh |
| vcg::tri::Harmonic< MeshType, Scalar > | |
| Eigen::internal::has_direct_access< Derived > | |
| Eigen::internal::has_none | |
| Eigen::internal::has_std_result_type | |
| Eigen::internal::has_tr1_result | |
| std::hash< vcg::Point3i > | |
| vcg::HashFunctor | |
| vcg::HashFunctor2D | |
| vcg::PerfectSpatialHashing< OBJECT_TYPE, SCALAR_TYPE >::HashTable | |
| vcg::tri::HausdorffSampler< MeshType > | |
| vcg::tri::Smooth< SmoothMeshType >::HCSmoothInfo | |
| vcg::hedge::HEAdj< T > | |
| vcg::LocalOptimization< MeshType >::HeapElem | Element of the heap |
| vcg::HeapMaxPriorityQueue< Index, Weight > | |
| vcg::HEdge< UserTypes, A, B, C, D, E, F, G, H, I, J, K > | |
| vcg::HEdgeArityMax< UserTypes, A, B, C, D, E, F, G, H, I, J, K > | |
| vcg::HEdgeBase< UserTypes > | |
| vcg::hedge::HEdgeData< T > | |
| vcg::HEdgeTypeHolder< UserTypes > | |
| Eigen::HessenbergDecomposition< _MatrixType > | Reduces a square matrix to Hessenberg form by an orthogonal similarity transformation |
| Eigen::internal::HessenbergDecompositionMatrixHReturnType< MatrixType > | Expression type for return value of HessenbergDecomposition::matrixH() |
| vcg::hedge::HFAdj< T > | |
| vcg::hedge::HHAdj< T > | |
| vcg::tri::Hinge | |
| vcg::Histogram< ScalarType > | |
| vcg::hedge::HNextAdj< T > | |
| vcg::tri::Hole< MESH > | |
| vcg::tri::Homeometry< MeshType > | Priority based on minimizing homeometry |
| Eigen::Homogeneous< MatrixType, _Direction > | Expression of one (or a set of) homogeneous vector(s) |
| Eigen::internal::homogeneous_left_product_impl< Homogeneous< MatrixType, Vertical >, Lhs > | |
| Eigen::internal::homogeneous_right_product_impl< Homogeneous< MatrixType, Horizontal >, Rhs > | |
| vcg::hedge::HOppAdj< T > | |
| Eigen::internal::householder_qr_inplace_blocked< MatrixQR, HCoeffs, MatrixQRScalar, InnerStrideIsOne > | |
| Eigen::HouseholderQR< _MatrixType > | Householder QR decomposition of a matrix |
| Eigen::HouseholderSequence< VectorsType, CoeffsType, Side > | Sequence of Householder reflections acting on subspaces with decreasing size |
| vcg::hedge::HPrevAdj< T > | |
| Eigen::internal::hseq_side_dependent_impl< VectorsType, CoeffsType, Side > | |
| Eigen::internal::hseq_side_dependent_impl< VectorsType, CoeffsType, OnTheRight > | |
| vcg::hedge::HVAdj< T > | |
| hybrd_functor | |
| Eigen::HybridNonLinearSolver< FunctorType, Scalar > | Finds a zero of a system of n nonlinear functions in n variables by a modification of the Powell hybrid method ("dogleg") |
| hybrj_functor | |
| Eigen::Hyperplane< _Scalar, _AmbientDim > | A hyperplane |
| Eigen::internal::hypot_impl< Scalar > | |
| Eigen::internal::hypot_retval< Scalar > | |
| I | |
| Eigen::IdentityPreconditioner | A naive preconditioner which approximates any matrix as the identity matrix |
| vcg::tri::io::u3dparametersclasses::IDTFConverterParameters | |
| Eigen::internal::imag_default_impl< Scalar, IsComplex > | |
| Eigen::internal::imag_default_impl< Scalar, true > | |
| Eigen::internal::imag_impl< Scalar > | |
| Eigen::internal::imag_ref_default_impl< Scalar, IsComplex > | |
| Eigen::internal::imag_ref_default_impl< Scalar, false > | |
| Eigen::internal::imag_ref_impl< Scalar > | |
| Eigen::internal::imag_ref_retval< Scalar > | |
| Eigen::internal::imag_retval< Scalar > | |
| img::Image< Channels, ScalarType, Safe > | Generic image class |
| Eigen::internal::image_retval< FullPivLU< _MatrixType > > | |
| Eigen::internal::image_retval_base< _DecompositionType > | |
| img::ImageException | Basic exception class |
| Collada::Tags::ImageTag | |
| img::ImgAttributes< ScalarType > | |
| Implicit | |
| vcg::ImplicitSmoother< MeshType > | |
| ImplicitSphere | |
| vcg::tri::io::Importer< OpenMeshType > | |
| vcg::tri::io::ImporterASC< MESH_TYPE > | |
| vcg::tri::io::ImporterCTM< OpenMeshType > | |
| vcg::tri::io::ImporterDAE< OpenMeshType > | |
| ImporterFBX< OpenMeshType > | |
| vcg::tri::io::ImporterFIELD< MeshType > | |
| vcg::tri::io::ImporterGTS< MESH_TYPE > | |
| vcg::tri::io::ImporterNVM< OpenMeshType > | |
| vcg::tri::io::ImporterOBJ< OpenMeshType > | |
| vcg::tri::io::ImporterOFF< MESH_TYPE > | |
| vcg::tri::io::ImporterOUT< OpenMeshType > | |
| vcg::tetra::io::ImporterPLY< OpenMeshType > | |
| vcg::tri::io::ImporterPLY< OpenMeshType > | |
| vcg::tri::io::ImporterPTX< OpenMeshType > | |
| vcg::tri::io::ImporterRAW< MESH_TYPE > | |
| vcg::tri::io::ImporterSMF< OpenMeshType > | |
| vcg::tri::io::ImporterSTL< OpenMeshType > | |
| vcg::tetra::io::ImporterTS< MESHTYPE > | |
| vcg::tri::io::ImporterVMI< OpenMeshType, A0, A1, A2, A3, A4 > | |
| vcg::InactiveMode | An inactive manipulator |
| Eigen::IncompleteCholesky< Scalar, _UpLo, _OrderingType > | Modified Incomplete Cholesky with dual threshold |
| Eigen::IncompleteLU< _Scalar > | |
| Eigen::IncompleteLUT< _Scalar > | Incomplete LU factorization with dual-threshold strategy |
| Eigen::internal::increment_if_fixed_size< Size > | |
| glw::IndexBufferBindingParams | |
| nanoflann::IndexDist_Sorter | |
| Collada::Tags::IndexOfRefractionTag | |
| vcg::tri::Inertia< MeshType > | Methods for computing Polyhedral Mass properties (like inertia tensor, volume, etc) |
| vcg::tri::io::ImporterOBJ< OpenMeshType >::Info | |
| ImporterFBX< OpenMeshType >::Info | |
| vcg::tri::Hole< MESH >::Info | |
| vcg::tri::io::ImporterPTX< OpenMeshType >::Info | |
| nanoply::Info | |
| vcg::tri::io::InfoDAE | |
| vcg::face::InfoOcc< T > | |
| vcg::face::InfoOccBase< A, T > | *-------------------------- FACEINFO ----------------------------------------*/ |
| vcg::face::InfoOcf< T > | *-------------------------- InfoOpt ----------------------------------*/ |
| vcg::vertex::InfoOcf< T > | *-------------------------- InfoOpt ----------------------------------*/ |
| Collada::Tags::InitFromTag | |
| Eigen::internal::inner_stride_at_compile_time< Derived, HasDirectAccess > | |
| Eigen::internal::inner_stride_at_compile_time< Derived, false > | |
| Eigen::SparseMatrix< _Scalar, _Options, _Index >::InnerIterator | |
| Eigen::TransposeImpl< MatrixType, Sparse >::InnerIterator | |
| Eigen::SparseTriangularView< MatrixType, Mode >::InnerIterator | |
| Eigen::DenseBase< Derived >::InnerIterator< Derived > | |
| Eigen::SparseVector< _Scalar, _Options, _Index >::InnerIterator | |
| Eigen::SparseView< MatrixType >::InnerIterator | |
| Eigen::internal::MappedSuperNodalMatrix< _Scalar, _Index >::InnerIterator | InnerIterator class to iterate over nonzero values of the current column in the supernodal matrix L |
| Eigen::BlockImpl< SparseMatrix< _Scalar, _Options, _Index >, BlockRows, BlockCols, true, Sparse >::InnerIterator | |
| Eigen::DynamicSparseMatrix< _Scalar, _Options, _Index >::InnerIterator | |
| InnerIterator | An InnerIterator allows to loop over the element of a sparse (or dense) matrix or expression |
| Eigen::CwiseUnaryViewImpl< ViewOp, MatrixType, Sparse >::InnerIterator | |
| Eigen::CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, Sparse >::InnerIterator | |
| Eigen::BlockImpl< const SparseMatrix< _Scalar, _Options, _Index >, BlockRows, BlockCols, true, Sparse >::InnerIterator | |
| Eigen::MappedSparseMatrix< _Scalar, _Flags, _Index >::InnerIterator | |
| Eigen::BlockImpl< XprType, BlockRows, BlockCols, true, Sparse >::InnerIterator | |
| Eigen::BlockImpl< XprType, BlockRows, BlockCols, InnerPanel, Sparse >::InnerIterator | |
| Eigen::CwiseUnaryOpImpl< UnaryOp, MatrixType, Sparse >::InnerIterator | |
| Eigen::SparseDenseOuterProduct< Lhs, Rhs, Tr >::InnerIterator | |
| Eigen::SkylineMatrix< _Scalar, _Options >::InnerLowerIterator | |
| vcg::OctreeTemplate< VOXEL_TYPE, SCALAR_TYPE >::InnerNode | |
| Eigen::InnerStride< Value > | Convenience specialization of Stride to specify only an inner stride See class Map for some examples |
| Eigen::SkylineMatrix< _Scalar, _Options >::InnerUpperIterator | |
| Eigen::internal::inplace_transpose_selector< MatrixType, false > | |
| Eigen::internal::inplace_transpose_selector< MatrixType, true > | |
| Collada::Tags::InputTag | |
| vcg::tri::Inside< FaceSpatialIndexing, TriMeshType > | |
| Collada::Tags::InstanceEffectTag | |
| Collada::Tags::InstanceGeometryTag | |
| Collada::Tags::InstanceMaterialTag | |
| InstanceNode | |
| InstancesNode | |
| Collada::Tags::InstanceVisualSceneTag | |
| vcg::tri::Quadrangulator< TriMesh, PolyMesh >::InterpolationInfo | |
| Eigen::internal::intersector_helper1< Volume1, Object1, Object2, Intersector > | |
| Eigen::internal::intersector_helper2< Volume2, Object2, Object1, Intersector > | |
| nanoflann::KDTreeSingleIndexAdaptor< Distance, DatasetAdaptor, DIM, IndexType >::Interval | |
| Eigen::internal::inverse_impl< MatrixType > | |
| Eigen::IOFormat | Stores a set of parameters controlling the way matrices are printed |
| Eigen::internal::is_arithmetic< T > | |
| Eigen::internal::is_arithmetic< __m128 > | |
| Eigen::internal::is_arithmetic< __m128d > | |
| Eigen::internal::is_arithmetic< __m128i > | |
| Eigen::internal::is_arithmetic< bool > | |
| Eigen::internal::is_arithmetic< char > | |
| Eigen::internal::is_arithmetic< double > | |
| Eigen::internal::is_arithmetic< float > | |
| Eigen::internal::is_arithmetic< long double > | |
| Eigen::internal::is_arithmetic< signed char > | |
| Eigen::internal::is_arithmetic< signed int > | |
| Eigen::internal::is_arithmetic< signed long > | |
| Eigen::internal::is_arithmetic< signed short > | |
| Eigen::internal::is_arithmetic< unsigned char > | |
| Eigen::internal::is_arithmetic< unsigned int > | |
| Eigen::internal::is_arithmetic< unsigned long > | |
| Eigen::internal::is_arithmetic< unsigned short > | |
| Eigen::internal::is_const< T > | |
| Eigen::internal::is_const< T const > | |
| Eigen::internal::is_diagonal< T > | |
| Eigen::internal::is_diagonal< DiagonalBase< T > > | |
| Eigen::internal::is_diagonal< DiagonalMatrix< T, S > > | |
| Eigen::internal::is_diagonal< DiagonalWrapper< T > > | |
| Eigen::internal::is_lvalue< ExpressionType > | |
| Eigen::internal::is_same< T, U > | |
| Eigen::internal::is_same< T, T > | |
| Eigen::internal::isApprox_selector< Derived, OtherDerived, is_integer > | |
| Eigen::internal::isApprox_selector< Derived, OtherDerived, true > | |
| Eigen::internal::isMuchSmallerThan_object_selector< Derived, OtherDerived, is_integer > | |
| Eigen::internal::isMuchSmallerThan_object_selector< Derived, OtherDerived, true > | |
| Eigen::internal::isMuchSmallerThan_scalar_selector< Derived, is_integer > | |
| Eigen::internal::isMuchSmallerThan_scalar_selector< Derived, true > | |
| vcg::tri::IsotropicDistance< MeshType > | |
| Eigen::GeneralProduct< Lhs, Rhs, OuterProduct >::IsRowMajor< T > | |
| PtrDHeap< T >::Item | |
| Eigen::IterationController | Controls the iterations of the iterative solvers |
| Eigen::IterativeSolverBase< Derived > | Base class for linear iterative solvers |
| vcg::tri::BitQuad< _MeshType, Interpolator >::Iterator | |
| ring< T >::iterator | |
| Eigen::internal::AmbiVector< _Scalar, _Index >::Iterator | |
| Eigen::IterScaling< _MatrixType > | |
| J | |
| Eigen::JacobiRotation< Scalar > | Rotation given by a cosine-sine pair |
| Eigen::JacobiSVD< _MatrixType, QRPreconditioner > | Two-sided Jacobi SVD decomposition of a rectangular matrix |
| vcg::face::JumpingPos< FACE_TYPE > | |
| vcg::tri::io::K< MeshType > | |
| vcg::tri::io::K0< MeshType, B0 > | |
| vcg::tri::io::K1< MeshType, B0, B1 > | |
| vcg::tri::io::K10< MeshType, B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10 > | |
| vcg::tri::io::K11< MeshType, B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11 > | |
| vcg::tri::io::K12< MeshType, B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12 > | |
| vcg::tri::io::K2< MeshType, B0, B1, B2 > | |
| vcg::tri::io::K3< MeshType, B0, B1, B2, B3 > | |
| vcg::tri::io::K4< MeshType, B0, B1, B2, B3, B4 > | |
| vcg::tri::io::K5< MeshType, B0, B1, B2, B3, B4, B5 > | |
| vcg::tri::io::K6< MeshType, B0, B1, B2, B3, B4, B5, B6 > | |
| vcg::tri::io::K7< MeshType, B0, B1, B2, B3, B4, B5, B6, B7 > | |
| vcg::tri::io::K8< MeshType, B0, B1, B2, B3, B4, B5, B6, B7, B8 > | |
| vcg::tri::io::K9< MeshType, B0, B1, B2, B3, B4, B5, B6, B7, B8, B9 > | |
| Eigen::KdBVH< _Scalar, _Dim, _Object > | A simple bounding volume hierarchy based on AlignedBox |
| vcg::KdTree< _Scalar > | |
| nanoflann::KDTreeEigenMatrixAdaptor< MatrixType, DIM, Distance, IndexType > | |
| nanoflann::KDTreeSingleIndexAdaptor< Distance, DatasetAdaptor, DIM, IndexType > | |
| nanoflann::KDTreeSingleIndexAdaptorParams | |
| Eigen::IncompleteLUT< _Scalar >::keep_diag | |
| Eigen::SimplicialCholeskyBase< Derived >::keep_diag | |
| Eigen::internal::kernel_retval< FullPivLU< _MatrixType > > | |
| Eigen::internal::kernel_retval_base< _DecompositionType > | |
| Eigen::internal::kiss_cpx_fft< _Scalar > | |
| Eigen::internal::kissfft_impl< _Scalar > | |
| nanoflann::KNNResultSet< DistanceType, IndexType, CountType > | |
| Eigen::KroneckerProduct< Lhs, Rhs > | Kronecker tensor product helper class for dense matrices |
| Eigen::KroneckerProductSparse< Lhs, Rhs > | Kronecker tensor product helper class for sparse matrices |
| L | |
| nanoflann::L1_Adaptor< T, DataSource, _DistanceType > | |
| nanoflann::L2_Adaptor< T, DataSource, _DistanceType > | |
| nanoflann::L2_Simple_Adaptor< T, DataSource, _DistanceType > | |
| lanczos1_functor | |
| vcg::tri::Smooth< SmoothMeshType >::LaplacianInfo | |
| Eigen::LazyProductReturnType< Lhs, Rhs > | |
| vcg::tri::PolychordCollapse< PolyMeshType >::LinkConditions::LCEdge | The LCEdge struct represents an edge for the Link Conditions |
| vcg::tri::PolychordCollapse< PolyMeshType >::LinkConditions::LCVertex | The LCVertex struct represents a vertex for the Link Conditions |
| Eigen::LDLT< _MatrixType, _UpLo > | Robust Cholesky decomposition of a matrix with pivoting |
| Eigen::internal::ldlt_inplace< Lower > | |
| Eigen::internal::ldlt_inplace< Upper > | |
| Eigen::internal::LDLT_Traits< MatrixType, Lower > | |
| Eigen::internal::LDLT_Traits< MatrixType, Upper > | |
| vcg::OctreeTemplate< VOXEL_TYPE, SCALAR_TYPE >::Leaf | |
| vcg::math::Legendre< ScalarType > | |
| Eigen::internal::level3_blocking< _LhsScalar, _RhsScalar > | |
| Eigen::LevenbergMarquardt< _FunctorType > | Performs non linear optimization over a non-linear function, using a variant of the Levenberg Marquardt algorithm |
| Collada::Tags::LibraryEffectsTag | |
| Collada::Tags::LibraryGeometriesTag | |
| Collada::Tags::LibraryImagesTag | |
| Collada::Tags::LibraryMaterialsTag | |
| Collada::Tags::LibraryVisualScenesTag | |
| vcg::tri::ExtendedMarchingCubes< TRIMESH_TYPE, WALKER_TYPE >::LightEdge | |
| vcg::Line2< LineScalarType, NORM > | |
| vcg::Line3< LineScalarType, NORM > | |
| vcg::Linear< T > | |
| vcg::GridStaticPtr< OBJTYPE, FLT >::Link | |
| vcg::tri::PolychordCollapse< PolyMeshType >::LinkConditions | The LinkCondition class provides a tool to check if a polychord satisfies the link conditions |
| Eigen::internal::linspaced_op< Scalar, RandomAccess > | |
| Eigen::internal::linspaced_op_impl< Scalar, false > | |
| Eigen::internal::linspaced_op_impl< Scalar, true > | |
| std::list< T, EIGEN_ALIGNED_ALLOCATOR< T > > | |
| Eigen::internal::AmbiVector< _Scalar, _Index >::ListEl | |
| Eigen::LLT< _MatrixType, _UpLo > | Standard Cholesky decomposition (LL^T) of a matrix and associated features |
| Eigen::internal::llt_inplace< Scalar, Lower > | |
| Eigen::internal::llt_inplace< Scalar, Upper > | |
| Eigen::internal::LLT_Traits< MatrixType, Lower > | |
| Eigen::internal::LLT_Traits< MatrixType, Upper > | |
| LMDiff::lm_control_type | |
| LMDiff::lm_status_type | |
| lmder_functor | |
| lmdif_functor | |
| LMDiff | |
| lmstr_functor | |
| vcg::tri::io::ImporterVMI< OpenMeshType, A0, A1, A2, A3, A4 >::LoadFaceOcf< MeshType, CONT > | |
| vcg::tri::io::ImporterVMI< OpenMeshType, A0, A1, A2, A3, A4 >::LoadFaceOcf< MeshType, face::vector_ocf< typename OpenMeshType::FaceType > > | |
| vcg::tri::io::ImporterPLY< OpenMeshType >::LoadPly_Camera | |
| vcg::tri::io::ImporterPLY< OpenMeshType >::LoadPly_EdgeAux | |
| vcg::tri::io::ImporterPLY< OpenMeshType >::LoadPly_FaceAux | |
| vcg::tri::io::ImporterPLY< OpenMeshType >::LoadPly_RangeGridAux | |
| vcg::tetra::io::ImporterPLY< OpenMeshType >::LoadPly_TetraAux | |
| vcg::tri::io::ImporterPLY< OpenMeshType >::LoadPly_TristripAux | |
| vcg::tri::io::ImporterPLY< OpenMeshType >::LoadPly_VertAux< S > | |
| vcg::tetra::io::ImporterPLY< OpenMeshType >::LoadPly_VertAux< S > | |
| vcg::tri::io::ImporterVMI< OpenMeshType, A0, A1, A2, A3, A4 >::LoadVertexOcf< MeshType, CONT > | |
| vcg::tri::io::ImporterVMI< OpenMeshType, A0, A1, A2, A3, A4 >::LoadVertexOcf< MeshType, vertex::vector_ocf< typename OpenMeshType::VertexType > > | |
| vcg::LocalModification< MeshType > | This abstract class define which functions a local modification to be used in the LocalOptimization |
| vcg::LocalOptimization< MeshType > | |
| vcg::tri::LoopWeight< SCALAR_TYPE > | Weight class for classical Loop's scheme |
| Eigen::internal::lpNorm_selector< Derived, p > | |
| Eigen::internal::lpNorm_selector< Derived, 1 > | |
| Eigen::internal::lpNorm_selector< Derived, 2 > | |
| Eigen::internal::lpNorm_selector< Derived, Infinity > | |
| vcg::tri::LS3Projection< MESH_TYPE, LSCALAR_TYPE > | |
| Eigen::LU< MatrixType > | |
| Eigen::internal::LU_GlobalLU_t< IndexVector, ScalarVector > | |
| Eigen::internal::LU_kernel_bmod< SegSizeAtCompileTime > | Performs numeric block updates from a given supernode to a single column |
| Eigen::internal::LU_kernel_bmod< 1 > | |
| Collada::Tags::MagFilterTag | |
| vcg::math::MagnitudoComparer< SCALAR > | |
| MainNode | |
| MainWindow | |
| Eigen::internal::make_coherent_impl< A, B > | |
| Eigen::internal::make_coherent_impl< A, Matrix< B_Scalar, B_Rows, B_Cols, B_Options, B_MaxRows, B_MaxCols > > | |
| Eigen::internal::make_coherent_impl< Matrix< A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols >, B > | |
| Eigen::internal::make_coherent_impl< Matrix< A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols >, Matrix< B_Scalar, B_Rows, B_Cols, B_Options, B_MaxRows, B_MaxCols > > | |
| Eigen::internal::make_proper_matrix_type< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > | |
| Eigen::Map< PlainObjectType, MapOptions, StrideType > | A matrix or vector expression mapping an existing array of data |
| Eigen::Map< const Quaternion< _Scalar >, _Options > | Quaternion expression mapping a constant memory buffer |
| Eigen::Map< PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, IndexType >, _PacketAccess > | |
| Eigen::Map< Quaternion< _Scalar >, _Options > | Expression of a quaternion from a memory buffer |
| Eigen::Map< Transpositions< SizeAtCompileTime, MaxSizeAtCompileTime, IndexType >, PacketAccess > | |
| MapBase | Base class for Map and Block expression with direct access |
| Eigen::MapBase< Derived, ReadOnlyAccessors > | |
| Eigen::MapBase< Derived, WriteAccessors > | |
| Eigen::MappedSparseMatrix< _Scalar, _Flags, _Index > | Sparse matrix |
| Eigen::internal::MappedSuperNodalMatrix< _Scalar, _Index > | Class to manipulate the L supernodal factor from the SparseLU factorization |
| vcg::tri::MarchingCubes< TRIMESH_TYPE, WALKER_TYPE > | This class implements the Marching Cubes algorithm |
| vcg::MArity1< Base, TA, A > | |
| vcg::MArity2< Base, TA, A, TB, B > | |
| vcg::MArity3< Base, TA, A, TB, B, TC, C > | |
| vcg::MArity4< Base, TA, A, TB, B, TC, C, TD, D > | |
| vcg::hedge::Mark< T > | |
| vcg::edge::Mark< T > | Component: Per edge Incremental Mark |
| vcg::face::Mark< T > | Per vertex Incremental Mark |
| vcg::tetra::Mark< T > | |
| vcg::vertex::Mark< T > | Per vertex Incremental Mark |
| vcg::face::MarkOcc< T > | *-------------------------- MARK ----------------------------------------*/ |
| vcg::face::MarkOcf< T > | *-------------------------- MARK ----------------------------------*/ |
| vcg::vertex::MarkOcf< T > | *-------------------------- MARK ----------------------------------*/ |
| vcg::math::MarsenneTwisterRNG | |
| vcg::tri::io::Mask | |
| Eigen::internal::traits< Ref< _PlainObjectType, _Options, _StrideType > >::match< Derived > | |
| vcg::tri::io::Material | |
| Material | |
| ImporterFBX< OpenMeshType >::VCGMaterialBridge::MaterialInfo | |
| vcg::tri::io::Materials< SaveMeshType > | |
| Collada::Tags::MaterialTag | |
| Eigen::Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > | The matrix class, also used for vectors and row-vectors |
| vcg::ndim::Matrix< TYPE > | |
| vcg::Matrix33 | |
| vcg::Matrix44< T > | |
| Eigen::internal::matrix_swap_impl< MatrixTypeA, MatrixTypeB, SwapPointers > | |
| Eigen::internal::matrix_swap_impl< MatrixTypeA, MatrixTypeB, true > | |
| Eigen::internal::matrix_type_times_scalar_type< OtherScalarType, MatrixType > | |
| Eigen::MatrixBase< Derived > | Base class for all dense matrices, vectors, and expressions |
| vcg::ndim::MatrixDiag< N, S > | |
| vcg::ndim::MatrixDiagBase | |
| Eigen::MatrixExponential< MatrixType > | Class for computing the matrix exponential |
| Eigen::MatrixExponentialReturnValue< Derived > | Proxy for the matrix exponential of some matrix (expression) |
| Eigen::MatrixFunction< MatrixType, AtomicType, IsComplex > | Class for computing matrix functions |
| Eigen::MatrixFunction< MatrixType, AtomicType, 0 > | |
| Eigen::MatrixFunction< MatrixType, AtomicType, 1 > | |
| Eigen::MatrixFunctionAtomic< MatrixType > | Helper class for computing matrix functions of atomic matrices |
| Eigen::MatrixFunctionReturnValue< Derived > | Proxy for the matrix function of some matrix (expression) |
| Eigen::MatrixLogarithmAtomic< MatrixType > | Helper class for computing matrix logarithm of atomic matrices |
| Eigen::MatrixLogarithmReturnValue< Derived > | Proxy for the matrix logarithm of some matrix (expression) |
| Eigen::MatrixMarketIterator< Scalar > | Iterator to browse matrices from a specified folder |
| Eigen::MatrixPower< MatrixType > | Class for computing matrix powers |
| Eigen::MatrixPowerAtomic< MatrixType > | |
| Eigen::MatrixPowerReturnValue< Derived > | Proxy for the matrix power of some matrix (expression) |
| Eigen::MatrixPowerRetval< MatrixType > | |
| Eigen::MatrixSquareRoot< MatrixType, IsComplex > | Class for computing matrix square roots of general matrices |
| Eigen::MatrixSquareRoot< MatrixType, 0 > | |
| Eigen::MatrixSquareRoot< MatrixType, 1 > | |
| Eigen::MatrixSquareRootQuasiTriangular< MatrixType > | Class for computing matrix square roots of upper quasi-triangular matrices |
| Eigen::MatrixSquareRootReturnValue< Derived > | Proxy for the matrix square root of some matrix (expression) |
| Eigen::MatrixSquareRootTriangular< MatrixType > | Class for computing matrix square roots of upper triangular matrices |
| Eigen::MatrixWrapper< ExpressionType > | Expression of an array as a mathematical vector or matrix |
| Eigen::MatrixXpr | |
| Eigen::internal::max_coeff_visitor< Derived > | |
| vcg::math::MAX_FACTORIAL< ScalarType > | |
| vcg::math::MAX_FACTORIAL< double > | |
| vcg::math::MAX_FACTORIAL< float > | |
| vcg::math::MAX_FACTORIAL< int > | |
| vcg::math::MAX_FACTORIAL< long double > | |
| vcg::math::MAX_FACTORIAL< short > | |
| vcg::tri::MCLookUpTable | |
| Eigen::internal::member_redux< BinaryOp, Scalar > | |
| vcg::MemoryInfo | |
| vcg::MemoryInfo::MemoryInfoException | |
| Mesh | |
| vcg::tri::MeshAssert< MeshType > | For checking the adequacy of a mesh to a given algorithm |
| MeshInfo | |
| vcg::tri::MeshSampler< MeshType > | |
| Collada::Tags::MeshTag | |
| vcg::tri::MeshToMatrix< MeshType > | |
| vcg::tri::MeshTypeHolder< T, CONT, TRAIT > | |
| vcg::tri::MeshTypeHolder< T, CONT, AllTypes::AEdgeType > | |
| vcg::tri::MeshTypeHolder< T, CONT, AllTypes::AFaceType > | |
| vcg::tri::MeshTypeHolder< T, CONT, AllTypes::AHEdgeType > | |
| vcg::tri::MeshTypeHolder< T, CONT, AllTypes::AVertexType > | |
| Eigen::internal::meta_sqrt< Y, InfX, SupX, Done > | |
| Eigen::internal::meta_sqrt< Y, InfX, SupX, true > | |
| Eigen::MetisOrdering< Index > | |
| nanoflann::metric_L1 | |
| nanoflann::metric_L2 | |
| nanoflann::metric_L2_Simple | |
| MGH09_functor | |
| MGH10_functor | |
| MGH17_functor | |
| vcg::tri::MidPoint< MESH_TYPE, InterpolatorFunctorType > | |
| vcg::tri::MidPointArc< MESH_TYPE > | |
| vcg::tri::MidPointArcNaive< MESH_TYPE > | |
| vcg::tri::MidPointButterfly< MESH_TYPE > | |
| vcg::tri::MidPointButterfly2< MESH_TYPE > | |
| vcg::tri::MidPointSphere< MESH_TYPE > | |
| Eigen::internal::min_coeff_visitor< Derived > | |
| Collada::Tags::MinFilterTag | |
| Eigen::internal::minimizer_helper1< Volume1, Object1, Object2, Minimizer > | |
| Eigen::internal::minimizer_helper2< Volume2, Object2, Object1, Minimizer > | |
| vcg::tri::MinimumWeightEar< MESH > | |
| Eigen::Minor< MatrixType > | Expression of a minor |
| Eigen::MINRES< _MatrixType, _UpLo, _Preconditioner > | A minimal residual solver for sparse symmetric problems |
| vcg::tri::MiQParametrizer< MeshType >::MIQParameters | |
| vcg::tri::MiQParametrizer< MeshType > | |
| misra1a_functor | |
| misra1d_functor | |
| vcg::MissingCompactnessException | |
| vcg::MissingComponentException | |
| vcg::MissingPolygonalRequirementException | |
| vcg::MissingPreconditionException | |
| vcg::MissingTriangularRequirementException | |
| MLAtomicGuard | |
| MLThreadSafeGLMeshAttributesFeeder | |
| MLThreadSafeMemoryInfo | |
| MLThreadSafeGLMeshAttributesFeeder::MLThreadSafeTextureNamesContainer | |
| vcg::glLabel::Mode | |
| Collada::Tags::ModifiedTag | |
| vcg::MovableCoordinateFrame | The MovableCoordinateFrame class |
| vcg::tri::io::u3dparametersclasses::Movie15Parameters< SaveMeshType > | |
| mpfr::mpreal | |
| vcg::MT< C > | |
| Eigen::internal::must_nest_by_value< T > | |
| mt::mutex | |
| my_functor | |
| MyCollapse | Collapse for uniform simplification |
| MyCollapseAdaptive | Collapse operation for adaptive simplification using fitmaps |
| MyDelaunayFlip | |
| MyEdge | |
| MyEdgeMesh | |
| MyFace | |
| MyFaceC | |
| MyFaceOcf | |
| MyMarker | |
| MyMaterialInfo | |
| MyMesh | |
| MyMeshC | |
| MyMeshOcf | |
| MyPolyFace | |
| vcg::tri::io::MyPolygon< VERTEX_TYPE > | |
| MyPolyMesh | |
| MyPolyVertex | |
| MySegmentType | |
| MyStraightMesh | |
| MyTriEdgeCollapse | |
| MyTriEdgeCollapseQTex | |
| MyTypes | |
| MyUsedTypes | |
| MyUsedTypesOcf | |
| MyVertex | |
| MyVertex0 | |
| MyVertex1 | |
| MyVertex2 | |
| MyVertexC | |
| MyVertexInfo | |
| MyVertexOcf | |
| nanoply::NanoPlyWrapper< MeshType > | |
| Eigen::NaturalOrdering< Index > | |
| vcg::NavigatorWasdMode | |
| Eigen::DenseBase< Derived >::NColsBlockXpr< N > | |
| Eigen::SparseMatrixBase< Derived >::NColsBlockXpr< N > | |
| NColsBlockXpr< N > | |
| vcg::NDFeature< MeshType > | |
| vcg::NDFeatureSet< MeshType > | |
| vcg::tri::NearestToCenter< MeshType > | |
| vcg::PerfectSpatialHashing< OBJECT_TYPE, SCALAR_TYPE >::Neighbor | |
| vcg::PerfectSpatialHashing< OBJECT_TYPE, SCALAR_TYPE >::NeighboringEntryIterator | |
| vcg::Octree< OBJECT_TYPE, SCALAR_TYPE >::Neighbour | |
| Eigen::NestByValue< ExpressionType > | Expression which must be nested by value |
| Eigen::internal::nested< T, n, PlainObject > | |
| Eigen::internal::nested< CoeffBasedProduct< Lhs, Rhs, EvalBeforeNestingBit|EvalBeforeAssigningBit >, N, PlainObject > | |
| Eigen::internal::nested< const GeneralProduct< Lhs, Rhs, Mode >, N, PlainObject > | |
| Eigen::internal::nested< GeneralProduct< Lhs, Rhs, Mode >, N, PlainObject > | |
| Eigen::internal::nested< ReturnByValue< Derived >, n, PlainObject > | |
| Collada::Tags::NewParamTag | |
| Eigen::internal::no_assignment_operator | |
| Eigen::NoAlias< ExpressionType, StorageBase > | Pseudo expression providing an operator = assuming no aliasing |
| nanoflann::KDTreeSingleIndexAdaptor< Distance, DatasetAdaptor, DIM, IndexType >::Node | |
| Node | |
| vcg::OctreeTemplate< VOXEL_TYPE, SCALAR_TYPE >::Node | |
| vcg::KdTree< _Scalar >::Node | |
| vcg::MT< C >::Node | |
| NodeGroup | |
| Collada::Tags::NodeTag | |
| NON_FLOAT_OR_DOUBLE_TYPE_CompileTimeError< double > | Partial instantiation for the static typecheck mechanism |
| NON_FLOAT_OR_DOUBLE_TYPE_CompileTimeError< float > | Partial instantiation for the static typecheck mechanism |
| NON_TRUE_EXPR_CompileTimeError< true > | Partial instantiation for the static assertion mechanism |
| Eigen::internal::noncopyable | |
| glw::detail::NonCopyable | |
| Eigen::internal::norm1_default_impl< Scalar, IsComplex > | |
| Eigen::internal::norm1_default_impl< Scalar, false > | |
| Eigen::internal::norm1_impl< Scalar > | |
| Eigen::internal::norm1_retval< Scalar > | |
| vcg::vertex::Normal< A, T > | Generic Component: Normal of the vertex |
| vcg::face::Normal3d< T > | |
| vcg::vertex::Normal3d< T > | Specialized Normal component in double point precision |
| vcg::face::Normal3dOcc< T > | |
| vcg::vertex::Normal3dOcc< T > | |
| vcg::face::Normal3dOcf< T > | |
| vcg::vertex::Normal3dOcf< T > | |
| vcg::face::Normal3f< T > | |
| vcg::vertex::Normal3f< T > | Specialized Normal component in floating point precision |
| vcg::face::Normal3fOcc< T > | |
| vcg::vertex::Normal3fOcc< T > | |
| vcg::vertex::Normal3fOcf< T > | |
| vcg::face::Normal3fOcf< T > | |
| vcg::face::Normal3s< T > | |
| vcg::vertex::Normal3s< T > | |
| vcg::face::Normal3sOcc< T > | |
| vcg::vertex::Normal3sOcc< T > | |
| vcg::face::Normal3sOcf< T > | |
| vcg::vertex::Normal3sOcf< T > | |
| vcg::face::NormalAbs< A, T > | |
| vcg::vertex::NormalOcc< A, T > | |
| vcg::face::NormalOcc< A, T > | *-------------------------- NORMAL ----------------------------------------*/ |
| vcg::face::NormalOcf< A, T > | |
| vcg::vertex::NormalOcf< A, T > | |
| vcg::NotThreadSafeMemoryInfo | |
| glw::detail::NoType | |
| vcg::tri::Nring< MeshType > | |
| Eigen::SparseMatrixBase< Derived >::NRowsBlockXpr< N > | |
| Eigen::DenseBase< Derived >::NRowsBlockXpr< N > | |
| NRowsBlockXpr< N > | |
| std::numeric_limits< mpfr::mpreal > | |
| Eigen::NumericalDiff< _Functor, mode > | |
| Eigen::NumTraits< T > | Holds information about the various numeric (i.e. scalar) types allowed by Eigen |
| Eigen::NumTraits< Array< Scalar, Rows, Cols, Options, MaxRows, MaxCols > > | |
| Eigen::NumTraits< double > | |
| Eigen::NumTraits< float > | |
| Eigen::NumTraits< long double > | |
| Eigen::NumTraits< short int > | |
| Eigen::NumTraits< std::complex< _Real > > | |
| Eigen::NumTraits< unsigned char > | |
| glw::Object | |
| glw::ObjectArguments | |
| glw::detail::ObjectBase< T > | |
| glw::detail::ObjectBase< BoundBuffer > | |
| glw::detail::ObjectBase< BoundDrawFramebuffer > | |
| glw::detail::ObjectBase< BoundFeedbackBuffer > | |
| glw::detail::ObjectBase< BoundFragmentShader > | |
| glw::detail::ObjectBase< BoundFramebuffer > | |
| glw::detail::ObjectBase< BoundGeometryShader > | |
| glw::detail::ObjectBase< BoundIndexBuffer > | |
| glw::detail::ObjectBase< BoundObject > | |
| glw::detail::ObjectBase< BoundPixelPackBuffer > | |
| glw::detail::ObjectBase< BoundPixelUnpackBuffer > | |
| glw::detail::ObjectBase< BoundProgram > | |
| glw::detail::ObjectBase< BoundReadDrawFramebuffer > | |
| glw::detail::ObjectBase< BoundReadFramebuffer > | |
| glw::detail::ObjectBase< BoundRenderable > | |
| glw::detail::ObjectBase< BoundRenderbuffer > | |
| glw::detail::ObjectBase< BoundShader > | |
| glw::detail::ObjectBase< BoundTexture > | |
| glw::detail::ObjectBase< BoundTexture2D > | |
| glw::detail::ObjectBase< BoundTextureCube > | |
| glw::detail::ObjectBase< BoundUniformBuffer > | |
| glw::detail::ObjectBase< BoundVertexBuffer > | |
| glw::detail::ObjectBase< BoundVertexShader > | |
| glw::detail::ObjectBase< SafeBuffer > | |
| glw::detail::ObjectBase< SafeFragmentShader > | |
| glw::detail::ObjectBase< SafeFramebuffer > | |
| glw::detail::ObjectBase< SafeGeometryShader > | |
| glw::detail::ObjectBase< SafeObject > | |
| glw::detail::ObjectBase< SafeProgram > | |
| glw::detail::ObjectBase< SafeRenderable > | |
| glw::detail::ObjectBase< SafeRenderbuffer > | |
| glw::detail::ObjectBase< SafeShader > | |
| glw::detail::ObjectBase< SafeTexture > | |
| glw::detail::ObjectBase< SafeTexture2D > | |
| glw::detail::ObjectBase< SafeTextureCube > | |
| glw::detail::ObjectBase< SafeVertexShader > | |
| glw::ObjectBindingParams | |
| glw::detail::ObjectBound< T > | |
| glw::detail::ObjectBound< Buffer > | |
| glw::detail::ObjectBound< FragmentShader > | |
| glw::detail::ObjectBound< Framebuffer > | |
| glw::detail::ObjectBound< GeometryShader > | |
| glw::detail::ObjectBound< Object > | |
| glw::detail::ObjectBound< Program > | |
| glw::detail::ObjectBound< Renderable > | |
| glw::detail::ObjectBound< Renderbuffer > | |
| glw::detail::ObjectBound< Shader > | |
| glw::detail::ObjectBound< Texture > | |
| glw::detail::ObjectBound< Texture2D > | |
| glw::detail::ObjectBound< TextureCube > | |
| glw::detail::ObjectBound< VertexShader > | |
| glw::Context::ObjectBoundFromObject< TObject > | |
| glw::detail::ObjectDeleter | |
| glw::Context::ObjectFromBinding< TBinding > | |
| vcg::Octree< OBJECT_TYPE, SCALAR_TYPE >::ObjectPlaceholder< LEAF_TYPE > | |
| vcg::Octree< OBJECT_TYPE, SCALAR_TYPE >::ObjectReference | |
| glw::detail::ObjectSafe< T > | |
| glw::detail::ObjectSafe< Buffer > | |
| glw::detail::ObjectSafe< FragmentShader > | |
| glw::detail::ObjectSafe< Framebuffer > | |
| glw::detail::ObjectSafe< GeometryShader > | |
| glw::detail::ObjectSafe< Object > | |
| glw::detail::ObjectSafe< Program > | |
| glw::detail::ObjectSafe< Renderable > | |
| glw::detail::ObjectSafe< Renderbuffer > | |
| glw::detail::ObjectSafe< Shader > | |
| glw::detail::ObjectSafe< Texture > | |
| glw::detail::ObjectSafe< Texture2D > | |
| glw::detail::ObjectSafe< TextureCube > | |
| glw::detail::ObjectSafe< VertexShader > | |
| glw::Context::ObjectSafeFromObject< TObject > | |
| glw::detail::ObjectSharedPointer< TObject, TDeleter, TBaseObject > | |
| glw::detail::ObjectSharedPointer< TObject, TDeleter, NoType > | |
| glw::detail::ObjectSharedPointerTraits< T > | |
| vcg::Octree< OBJECT_TYPE, SCALAR_TYPE >::ObjectSorter< LEAF_TYPE > | |
| vcg::tri::io::ImporterOBJ< OpenMeshType >::ObjEdge | |
| vcg::tri::io::ImporterOBJ< OpenMeshType >::ObjIndexedFace | |
| vcg::tri::io::ImporterOBJ< OpenMeshType >::ObjTexCoord | |
| vcg::Obox3< T > | |
| OcfEdge | |
| OcfFace | |
| OcfMesh | |
| OcfUsedTypes | |
| OcfVertex | |
| vcg::GenNormal< ScalarType >::OctaLevel | |
| vcg::Octree< OBJECT_TYPE, SCALAR_TYPE > | |
| vcg::OctreeTemplate< VOXEL_TYPE, SCALAR_TYPE > | |
| vcg::tri::OddPointLoop< MESH_TYPE > | |
| vcg::tri::OddPointLoopGeneric< MESH_TYPE, METHOD_TYPE, WEIGHT_TYPE > | |
| vcg::PerfectSpatialHashing< OBJECT_TYPE, SCALAR_TYPE >::OffsetTable | |
| Eigen::internal::OP< MatrixSolver, MatrixType, Scalar, BisSPD > | |
| Eigen::internal::OP< MatrixSolver, MatrixType, Scalar, false > | |
| Eigen::internal::OP< MatrixSolver, MatrixType, Scalar, true > | |
| vcg::tri::OperationWeight< MeshType, TriMeshType > | Generic class for weighting collapses |
| Eigen::VectorwiseOp< ExpressionType, Direction >::OppositeExtendedType< OtherDerived > | |
| option | |
| GetOpt::Option | |
| vcg::tri::io::ImporterGTS< MESH_TYPE >::Options | |
| vcg::vert::OSGColor< A, T > | |
| vcg::vert::OSGColor3f< T > | |
| vcg::vert::OSGColorCore< T > | |
| vcg::vert::OSGColorCore3f | |
| vcg::vert::OSGCoord< A, T > | |
| vcg::vert::OSGCoord3f< T > | |
| vcg::vert::OSGCoordCore< T > | Core for the coordinate component templated with the coordinate type of the component |
| vcg::vert::OSGCoordCore3f | |
| vcg::vert::OSGInfo< T > | |
| vcg::vert::OSGNormal< A, T > | |
| vcg::vert::OSGNormal3f< T > | |
| vcg::vert::OSGNormalCore< T > | |
| vcg::vert::OSGNormalCore3f | |
| Eigen::internal::outer_stride_at_compile_time< Derived, HasDirectAccess > | |
| Eigen::internal::outer_stride_at_compile_time< Derived, false > | |
| Eigen::OuterStride< Value > | Convenience specialization of Stride to specify only an outer stride See class Map for some examples |
| vcg::tri::OutlierRemoval< MeshType > | |
| Outline2Dumper | This class is used to draw polygons on an image could be vectorial or not |
| vcg::tri::OutlineUtil< ScalarType > | |
| Output_File | |
| OverlapEstimation< MESH_TYPE > | This class provides a strategy to estimate the overlap percentage of two range maps/point clouds |
| OwnSlotNode | |
| OwnSlotsNode | |
| Eigen::internal::Packet1cd | |
| Eigen::internal::Packet2cf | |
| Eigen::internal::packet_traits< T > | |
| Eigen::internal::packet_traits< double > | |
| Eigen::internal::packet_traits< float > | |
| Eigen::internal::packet_traits< int > | |
| Eigen::internal::packet_traits< std::complex< double > > | |
| Eigen::internal::packet_traits< std::complex< float > > | |
| vcg::RasterizedOutline2Packer< SCALAR_TYPE, RASTERIZER_TYPE >::packingfield | |
| Eigen::internal::palign_impl< Offset, PacketType > | |
| Eigen::internal::palign_impl< Offset, Packet1cd > | |
| Eigen::internal::palign_impl< Offset, Packet2cf > | |
| Eigen::internal::palign_impl< Offset, Packet2d > | |
| Eigen::internal::palign_impl< Offset, Packet4f > | |
| Eigen::internal::palign_impl< Offset, Packet4i > | |
| Eigen::internal::panel_dfs_traits< IndexVector > | |
| vcg::PanMode | The panning manipulator |
| vcg::tri::CoM< MeshType >::Param | |
| vcg::tri::PointCloudNormal< MeshType >::Param | Parameters for the normal generation |
| vcg::NDFeatureSet< MeshType >::Param | |
| vcg::RansacFramework< MeshType, FeatureSetType >::Param | |
| vcg::tri::VoronoiVolumeSampling< MeshType >::Param | |
| Outline2Dumper::Param | |
| vcg::BaseFeatureSet< MeshType >::Param | |
| vcg::tri::FourPCS< MeshType >::Param | |
| vcg::ImplicitSmoother< MeshType >::Parameter | |
| OverlapEstimation< MESH_TYPE >::Parameters | Public class to hold parameters. Used to avoid endless list of parameters inside functions |
| Eigen::HybridNonLinearSolver< FunctorType, Scalar >::Parameters | |
| Eigen::LevenbergMarquardt< _FunctorType >::Parameters | |
| vcg::RasterizedOutline2Packer< SCALAR_TYPE, RASTERIZER_TYPE >::Parameters | |
| Eigen::ParametrizedLine< _Scalar, _AmbientDim > | A parametrized line |
| glw::detail::ParamsOf< T > | |
| glw::detail::ParamsOf< BoundBuffer > | |
| glw::detail::ParamsOf< BoundDrawFramebuffer > | |
| glw::detail::ParamsOf< BoundFeedbackBuffer > | |
| glw::detail::ParamsOf< BoundFragmentShader > | |
| glw::detail::ParamsOf< BoundFramebuffer > | |
| glw::detail::ParamsOf< BoundGeometryShader > | |
| glw::detail::ParamsOf< BoundIndexBuffer > | |
| glw::detail::ParamsOf< BoundObject > | |
| glw::detail::ParamsOf< BoundPixelPackBuffer > | |
| glw::detail::ParamsOf< BoundPixelUnpackBuffer > | |
| glw::detail::ParamsOf< BoundProgram > | |
| glw::detail::ParamsOf< BoundReadDrawFramebuffer > | |
| glw::detail::ParamsOf< BoundReadFramebuffer > | |
| glw::detail::ParamsOf< BoundRenderable > | |
| glw::detail::ParamsOf< BoundRenderbuffer > | |
| glw::detail::ParamsOf< BoundShader > | |
| glw::detail::ParamsOf< BoundTexture > | |
| glw::detail::ParamsOf< BoundTexture2D > | |
| glw::detail::ParamsOf< BoundTextureCube > | |
| glw::detail::ParamsOf< BoundUniformBuffer > | |
| glw::detail::ParamsOf< BoundVertexBuffer > | |
| glw::detail::ParamsOf< BoundVertexShader > | |
| Collada::Tags::ParamTag | |
| Eigen::internal::pardiso_run_selector< Index > | |
| Eigen::internal::pardiso_run_selector< long long int > | |
| Eigen::internal::pardiso_traits< PardisoLDLT< _MatrixType, Options > > | |
| Eigen::internal::pardiso_traits< PardisoLLT< _MatrixType, Options > > | |
| Eigen::internal::pardiso_traits< PardisoLU< _MatrixType > > | |
| Eigen::PardisoImpl< Derived > | |
| Eigen::PardisoLDLT< MatrixType, Options > | A sparse direct Cholesky (LDLT) factorization and solver based on the PARDISO library |
| Eigen::PardisoLLT< MatrixType, _UpLo > | A sparse direct Cholesky (LLT) factorization and solver based on the PARDISO library |
| Eigen::PardisoLU< MatrixType > | A sparse direct LU factorization and solver based on the PARDISO library |
| Eigen::internal::partial_lu_impl< Scalar, StorageOrder, PivIndex > | |
| Eigen::PartialPivLU< _MatrixType > | LU decomposition of a matrix with partial pivoting, and related features |
| Eigen::PartialReduxExpr< MatrixType, MemberOp, Direction > | Generic expression of a partially reduxed matrix |
| shape_reconstruction::PassThrough< PointT > | PassThrough passes points in a cloud based on constraints for one particular field of the point type |
| Eigen::internal::pastix_traits< PastixLDLT< _MatrixType, Options > > | |
| Eigen::internal::pastix_traits< PastixLLT< _MatrixType, Options > > | |
| Eigen::internal::pastix_traits< PastixLU< _MatrixType > > | |
| Eigen::PastixBase< Derived > | |
| Eigen::PastixLDLT< _MatrixType, _UpLo > | A sparse direct supernodal Cholesky (LLT) factorization and solver based on the PaStiX library |
| Eigen::PastixLLT< _MatrixType, _UpLo > | A sparse direct supernodal Cholesky (LLT) factorization and solver based on the PaStiX library |
| Eigen::PastixLU< _MatrixType, IsStrSym > | Sparse direct LU solver based on PaStiX library |
| vcg::PathMode | The path constrained manipulator |
| vcg::tri::PolychordCollapse< PolyMeshType >::PC_Chord | The PC_Chord struct identifies a coord of a polychord passing through a quad |
| vcg::tri::PolychordCollapse< PolyMeshType >::PC_Chords | Gives efficient access to each coord (relative to a face) |
| vcg::tri::Smooth< SmoothMeshType >::PDFaceInfo | |
| vcg::tri::Smooth< SmoothMeshType >::PDVertInfo | |
| vcg::tri::UpdateTopology< UpdateMeshType >::PEdge | Auxiliairy data structure for computing face face adjacency information |
| PEdge | |
| vcg::tri::UpdateTopology< UpdateMeshType >::PEdgeTex | Auxiliairy data structure for computing face face adjacency information |
| vcg::tri::TriMesh< Container0, Container1, Container2, Container3 >::PerEdgeAttributeHandle< ATTR_TYPE > | |
| vcg::tri::TriMesh< Container0, Container1, Container2, Container3 >::PerFaceAttributeHandle< ATTR_TYPE > | |
| vcg::PerfectSpatialHashing< OBJECT_TYPE, SCALAR_TYPE > | |
| Eigen::internal::perfvalues< Index > | |
| vcg::math::Perlin | |
| vcg::tri::TriMesh< Container0, Container1, Container2, Container3 >::PerMeshAttributeHandle< ATTR_TYPE > | |
| Eigen::internal::permut_matrix_product_retval< PermutationType, MatrixType, Side, Transposed > | |
| Eigen::internal::permut_sparsematrix_product_retval< PermutationType, MatrixType, Side, Transposed > | |
| Eigen::PermutationBase< Derived > | Base class for permutations |
| Eigen::PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, IndexType > | Permutation matrix |
| Eigen::PermutationStorage | |
| Eigen::PermutationWrapper< _IndicesType > | Class to view a vector of integers as a permutation matrix |
| vcg::tri::TriMesh< Container0, Container1, Container2, Container3 >::PerVertexAttributeHandle< ATTR_TYPE > | |
| vcg::tri::FourPCS< MeshType >::PFace | |
| PFace | |
| vcg::face::PFEAdj< T > | |
| vcg::face::PFFAdj< T > | |
| vcg::face::PFHAdj< T > | |
| vcg::face::PFVAdj< T > | |
| PHEdge | |
| vcg::tri::Pivot< MESH > | |
| glw::PixelPackBufferBindingParams | |
| glw::PixelUnpackBufferBindingParams | |
| vcg::tri::io::PlaceHolderType< N > | |
| Eigen::internal::plain_array< T, Size, MatrixOrArrayOptions, Alignment > | |
| Eigen::internal::plain_array< T, 0, MatrixOrArrayOptions, Alignment > | |
| Eigen::internal::plain_array< T, Size, MatrixOrArrayOptions, 16 > | |
| Eigen::internal::plain_col_type< ExpressionType, Scalar > | |
| Eigen::internal::plain_diag_type< ExpressionType, Scalar > | |
| Eigen::internal::plain_matrix_type< T, Dense > | |
| Eigen::internal::plain_matrix_type< T, Sparse > | |
| Eigen::internal::plain_matrix_type_column_major< T > | |
| Eigen::internal::plain_matrix_type_dense< T, ArrayXpr > | |
| Eigen::internal::plain_matrix_type_dense< T, MatrixXpr > | |
| Eigen::internal::plain_matrix_type_row_major< T > | |
| Eigen::internal::plain_row_type< ExpressionType, Scalar > | |
| Eigen::PlainObjectBase< Derived > | Dense storage base class for matrices and arrays |
| vcg::tri::PlanarEdgeFlip< TRIMESH_TYPE, MYTYPE, QualityFunc > | |
| vcg::tri::PlanarEdgeFlipParameter | |
| vcg::Plane3< T, NORM > | |
| vcg::PlaneMode | The planar manipulator |
| vcg::ply::PlyElement | |
| nanoply::PlyElement | |
| nanoply::PlyFile | |
| vcg::ply::PlyFile | |
| vcg::tetra::io::PlyInfo | |
| vcg::tri::io::PlyInfo | |
| vcg::ply::PlyPoint3d | |
| nanoply::PlyProperty | |
| vcg::ply::PlyProperty | |
| PMesh | |
| vcg::tri::FourPCS< MeshType >::PMesh | |
| PointCloud< T >::Point | |
| vcg::ndim::Point< N, S > | |
| vcg::Point2< P2ScalarType > | |
| vcg::ndim::Point2< S > | |
| vcg::ndim::Point3< S > | |
| vcg::Point3< P3ScalarType > | |
| vcg::ndim::Point4< S > | |
| vcg::Point4< T > | |
| vcg::ndim::PointBase< N, S > | |
| PointCloud< T > | |
| vcg::tri::PointCloudNormal< MeshType > | Class of static functions to smooth and fair meshes and their attributes |
| vcg::face::PointDistanceBaseFunctor< S > | |
| vcg::face::PointDistanceEPFunctor< S > | |
| vcg::edge::PointDistanceFunctor< S > | |
| vcg::vertex::PointDistanceFunctor< SCALARTYPE > | |
| vcg::PointerToAttribute | |
| vcg::tri::Allocator< MeshType >::PointerUpdater< SimplexPointerType > | Accessory class to update pointers after eventual reallocation caused by adding elements |
| vcg::vertex::PointNormalDistanceFunctor< VERTYPE > | |
| vcg::face::PointNormalDistanceFunctor< S > | |
| PointPointMinimizer | |
| vcg::vertex::PointScaledDistanceFunctor< VERTEXYPE > | |
| vcg::PointSegment2DEPFunctor< S > | |
| vcg::tri::SurfaceSampling< MeshType, VertexSampler >::PoissonDiskParam | |
| vcg::tri::PoissonSolver< MeshType > | |
| vcg::PolarMode | |
| vcg::tri::PolychordCollapse< PolyMeshType > | The PolychordCollapse class provides methods to semplify a quad mesh, by collapsing the polychords |
| PolyFace | |
| vcg::tri::io::PolygonalMesh< POLYGONAL_TYPE > | |
| vcg::tri::PolygonSupport< TriMeshType, PolyMeshType > | This class is used convert between polygonal meshes and triangular meshes |
| vcg::face::PolyInfo< T > | |
| PolyMesh | |
| Eigen::PolynomialSolver< _Scalar, _Deg > | A polynomial solver |
| Eigen::PolynomialSolver< _Scalar, 1 > | |
| Eigen::PolynomialSolverBase< _Scalar, _Deg > | Defined to be inherited by polynomial solvers: it provides convenient methods such as |
| vcg::PolyPacker< SCALAR_TYPE > | |
| PolyUsedTypes | |
| PolyVertex | |
| nanoflann::PooledAllocator | |
| vcg::tetra::Pos< MTTYPE > | |
| vcg::tri::BitQuad< _MeshType, Interpolator >::Pos | |
| vcg::hedge::Pos< MeshType > | Class implementing a Pos using halfedges |
| vcg::edge::Pos< EDGETYPE > | |
| vcg::face::Pos< FaceType > | |
| vcg::tetra::PosJump< MTTYPE > | This pos structure jump on next tetrahedron if find an external face |
| vcg::tetra::PosLoop< MTTYPE > | This pos structure jump on next tetrahedron in rotational sense if find an external face |
| Eigen::internal::pow_default_impl< Scalar, IsInteger > | |
| Eigen::internal::pow_default_impl< Scalar, true > | |
| Eigen::internal::pow_impl< Scalar > | |
| Eigen::internal::pow_retval< Scalar > | |
| vcg::tri::io::Precision< SCALAR > | |
| vcg::tri::io::Precision< double > | |
| vcg::tri::io::Precision< float > | |
| vcg::tri::Geodesic< MeshType >::pred | |
| vcg::PerfectSpatialHashing< OBJECT_TYPE, SCALAR_TYPE >::OffsetTable::PreImage | |
| Eigen::internal::product_coeff_impl< DefaultTraversal, 0, Lhs, Rhs, RetScalar > | |
| Eigen::internal::product_coeff_impl< DefaultTraversal, 1, Lhs, Rhs, RetScalar > | |
| Eigen::internal::product_coeff_impl< DefaultTraversal, Dynamic, Lhs, Rhs, RetScalar > | |
| Eigen::internal::product_coeff_impl< DefaultTraversal, UnrollingIndex, Lhs, Rhs, RetScalar > | |
| Eigen::internal::product_coeff_impl< InnerVectorizedTraversal, 0, Lhs, Rhs, RetScalar > | |
| Eigen::internal::product_coeff_impl< InnerVectorizedTraversal, Dynamic, Lhs, Rhs, RetScalar > | |
| Eigen::internal::product_coeff_impl< InnerVectorizedTraversal, UnrollingIndex, Lhs, Rhs, RetScalar > | |
| Eigen::internal::product_coeff_vectorized_dyn_selector< Lhs, Rhs, LhsRows, RhsCols > | |
| Eigen::internal::product_coeff_vectorized_dyn_selector< Lhs, Rhs, 1, 1 > | |
| Eigen::internal::product_coeff_vectorized_dyn_selector< Lhs, Rhs, 1, RhsCols > | |
| Eigen::internal::product_coeff_vectorized_dyn_selector< Lhs, Rhs, LhsRows, 1 > | |
| Eigen::internal::product_coeff_vectorized_unroller< UnrollingIndex, Lhs, Rhs, Packet > | |
| Eigen::internal::product_coeff_vectorized_unroller< 0, Lhs, Rhs, Packet > | |
| Eigen::internal::product_packet_impl< ColMajor, 0, Lhs, Rhs, Packet, LoadMode > | |
| Eigen::internal::product_packet_impl< ColMajor, 1, Lhs, Rhs, Packet, LoadMode > | |
| Eigen::internal::product_packet_impl< ColMajor, Dynamic, Lhs, Rhs, Packet, LoadMode > | |
| Eigen::internal::product_packet_impl< ColMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode > | |
| Eigen::internal::product_packet_impl< RowMajor, 0, Lhs, Rhs, Packet, LoadMode > | |
| Eigen::internal::product_packet_impl< RowMajor, 1, Lhs, Rhs, Packet, LoadMode > | |
| Eigen::internal::product_packet_impl< RowMajor, Dynamic, Lhs, Rhs, Packet, LoadMode > | |
| Eigen::internal::product_packet_impl< RowMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode > | |
| Eigen::internal::product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, false, ConjugateLhs, RhsStorageOrder, true, ConjugateRhs, ColMajor > | |
| Eigen::internal::product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, LhsSelfAdjoint, ConjugateLhs, RhsStorageOrder, RhsSelfAdjoint, ConjugateRhs, RowMajor > | |
| Eigen::internal::product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, true, ConjugateLhs, RhsStorageOrder, false, ConjugateRhs, ColMajor > | |
| Eigen::internal::product_size_category< Size, MaxSize > | |
| Eigen::internal::product_triangular_matrix_matrix< Scalar, Index, Mode, false, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor, Version > | |
| Eigen::internal::product_triangular_matrix_matrix< Scalar, Index, Mode, LhsIsTriangular, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, RowMajor, Version > | |
| Eigen::internal::product_triangular_matrix_matrix< Scalar, Index, Mode, true, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor, Version > | |
| Eigen::internal::product_triangular_matrix_matrix_trmm< Scalar, Index, Mode, LhsIsTriangular, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, ResStorageOrder > | |
| Eigen::internal::product_type< Lhs, Rhs > | |
| Eigen::internal::product_type_selector< 1, 1, 1 > | |
| Eigen::internal::product_type_selector< 1, 1, Depth > | |
| Eigen::internal::product_type_selector< 1, Large, Large > | |
| Eigen::internal::product_type_selector< 1, Large, Small > | |
| Eigen::internal::product_type_selector< 1, Small, Large > | |
| Eigen::internal::product_type_selector< 1, Small, Small > | |
| Eigen::internal::product_type_selector< Large, 1, Large > | |
| Eigen::internal::product_type_selector< Large, 1, Small > | |
| Eigen::internal::product_type_selector< Large, Large, Large > | |
| Eigen::internal::product_type_selector< Large, Large, Small > | |
| Eigen::internal::product_type_selector< Large, Small, 1 > | |
| Eigen::internal::product_type_selector< Large, Small, Large > | |
| Eigen::internal::product_type_selector< Large, Small, Small > | |
| Eigen::internal::product_type_selector< M, N, 1 > | |
| Eigen::internal::product_type_selector< Small, 1, Large > | |
| Eigen::internal::product_type_selector< Small, 1, Small > | |
| Eigen::internal::product_type_selector< Small, Large, 1 > | |
| Eigen::internal::product_type_selector< Small, Large, Large > | |
| Eigen::internal::product_type_selector< Small, Large, Small > | |
| Eigen::internal::product_type_selector< Small, Small, 1 > | |
| Eigen::internal::product_type_selector< Small, Small, Large > | |
| Eigen::internal::product_type_selector< Small, Small, Small > | |
| Eigen::ProductBase< Derived, Lhs, Rhs > | |
| Eigen::ProductReturnType< Lhs, Rhs, ProductType > | Helper class to get the correct and optimized returned type of operator* |
| Eigen::ProductReturnType< Lhs, Rhs, CoeffBasedProductMode > | |
| Eigen::ProductReturnType< Lhs, Rhs, LazyCoeffBasedProductMode > | |
| Collada::Tags::ProfileCommonTag | |
| Program | |
| glw::Program | |
| glw::ProgramArguments | |
| glw::ProgramBindingParams | |
| ProgramVF | |
| Eigen::internal::projective_transform_inverse< TransformType, Mode > | |
| Eigen::internal::projective_transform_inverse< TransformType, Projective > | |
| Eigen::internal::promote_index_type< I1, I2 > | |
| Eigen::internal::promote_storage_type< A, A > | |
| Eigen::internal::promote_storage_type< Dense, Sparse > | |
| Eigen::internal::promote_storage_type< Sparse, Dense > | |
| vcg::ply::PropDescriptor | |
| vcg::Provider< Token > | |
| Collada::Tags::PTag | |
| PtrDHeap< T > | |
| glw::Context::PtrFromObject< TObject > | |
| PUsedTypes | |
| vcg::tri::FourPCS< MeshType >::PUsedTypes | |
| vcg::tri::FourPCS< MeshType >::PVertex | |
| PVertex | |
| vcg::tri::UpdateTopology< UpdateMeshType >::PVertexEdge | |
| vcg::face::PVFAdj< T > | |
| QDoor | |
| vcg::tri::QInfoStandard< VERTEX_TYPE > | |
| QMyWindow | |
| Eigen::QR< MatrixType > | |
| Eigen::internal::qr_preconditioner_impl< MatrixType, QRPreconditioner, Case, DoAnything > | |
| Eigen::internal::qr_preconditioner_impl< MatrixType, ColPivHouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true > | |
| Eigen::internal::qr_preconditioner_impl< MatrixType, ColPivHouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true > | |
| Eigen::internal::qr_preconditioner_impl< MatrixType, FullPivHouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true > | |
| Eigen::internal::qr_preconditioner_impl< MatrixType, FullPivHouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true > | |
| Eigen::internal::qr_preconditioner_impl< MatrixType, HouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true > | |
| Eigen::internal::qr_preconditioner_impl< MatrixType, HouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true > | |
| Eigen::internal::qr_preconditioner_impl< MatrixType, QRPreconditioner, Case, false > | |
| Eigen::internal::qr_preconditioner_should_do_anything< MatrixType, QRPreconditioner, Case > | |
| QtOutline2Rasterizer | This class is used to draw polygons on an image could be vectorial or not |
| vcg::tri::QuadDiagonalCollapse< MeshType, MYTYPE, TriMeshType, OptimizationType, WeightType, CheckType > | Class implementing simplification of quad meshes by diagonal collapses priority of the operations is weighted with a value computed by class WeightType Feasibility is checked with class CheckType |
| vcg::tri::QuadDiagonalCollapseBase< MeshType, MYTYPE, TriMeshType, OptimizationType > | Class implementing simplification of quad meshes by diagonal collapses |
| vcg::tri::Quadrangulator< TriMesh, PolyMesh > | |
| vcg::tri::UpdateCurvatureFitting< MeshType >::Quadric | |
| vcg::math::Quadric< _ScalarType > | |
| vcg::Quadric5< Scalar > | |
| vcg::tri::UpdateCurvatureFitting< MeshType >::QuadricLocal | |
| vcg::tri::VoronoiProcessing< MeshType, DistanceFunctor >::QuadricSumDistance | |
| vcg::tri::QuadricTexHelper< MeshType > | |
| vcg::face::Quality< A, T > | |
| vcg::edge::Quality< A, TT > | Component: Per edge quality |
| vcg::vertex::Quality< A, TT > | Component: Per vertex quality The Quality Component is a generic place for storing a float. The term 'quality' is a bit misleading and it is due to its original storic meaning. You should intend it as a general purpose container |
| vcg::face::Quality3< A, T > | |
| vcg::face::Quality3d< T > | |
| vcg::face::Quality3f< T > | |
| vcg::face::Quality3s< T > | |
| vcg::edge::Qualityd< TT > | |
| vcg::vertex::Qualityd< TT > | |
| vcg::face::Qualityd< T > | |
| vcg::vertex::QualitydOcc< T > | |
| vcg::tri::QualityEdgePredicate< MESH_TYPE > | |
| vcg::vertex::Qualityf< TT > | |
| vcg::face::Qualityf< T > | |
| vcg::edge::Qualityf< TT > | |
| vcg::vertex::QualityfOcc< T > | |
| vcg::face::QualityfOcf< T > | |
| vcg::vertex::QualityfOcf< T > | |
| vcg::tri::QualityMidPointFunctor< MESH_TYPE > | |
| vcg::vertex::QualityOcc< A, T > | *-------------------------- Quality ----------------------------------*/ |
| vcg::face::QualityOcf< A, T > | *-------------------------- QUALITY ----------------------------------*/ |
| vcg::vertex::QualityOcf< A, T > | *-------------------------- QUALITY ----------------------------------*/ |
| vcg::vertex::Qualitys< TT > | |
| vcg::edge::Qualitys< TT > | |
| vcg::face::Qualitys< T > | |
| vcg::tri::CoM< MeshType >::QualitySign | |
| vcg::tri::CoM< MeshType >::QualitySignSplit | |
| vcg::tri::Smooth< SmoothMeshType >::QualitySmoothInfo | |
| vcg::vertex::QualitysOcc< T > | |
| Eigen::internal::quat_product< Arch, Derived1, Derived2, Scalar, _Options > | |
| Eigen::internal::quat_product< Architecture::SSE, Derived, OtherDerived, double, Aligned > | |
| Eigen::internal::quat_product< Architecture::SSE, Derived, OtherDerived, float, Aligned > | |
| vcg::Quaternion< S > | |
| Eigen::Quaternion< _Scalar > | The quaternion class used to represent 3D orientations and rotations |
| Eigen::QuaternionBase< Derived > | Base class for quaternion expressions |
| Eigen::internal::quaternionbase_assign_impl< Other, 3, 3 > | |
| Eigen::internal::quaternionbase_assign_impl< Other, 4, 1 > | |
| vcg::KdTree< _Scalar >::QueryNode | |
| vcg::vertex::Radius< A, TT > | Component: Per vertex radius |
| vcg::vertex::RadiusdOcc< T > | |
| vcg::vertex::RadiusdOcf< T > | |
| vcg::vertex::Radiusf< TT > | |
| vcg::vertex::RadiusfOcc< T > | |
| vcg::vertex::RadiusfOcf< T > | |
| vcg::vertex::RadiusOcc< A, TT > | |
| vcg::vertex::RadiusOcf< A, TT > | *-------------------------- RADIUS ----------------------------------*/ |
| nanoflann::RadiusResultSet< DistanceType, IndexType > | |
| vcg::tri::Fitmaps< MeshType >::radSorter | |
| Eigen::internal::random_default_impl< Scalar, IsComplex, IsInteger > | |
| Eigen::internal::random_default_impl< Scalar, false, false > | |
| Eigen::internal::random_default_impl< Scalar, false, true > | |
| Eigen::internal::random_default_impl< Scalar, true, false > | |
| Eigen::internal::random_impl< Scalar > | |
| Eigen::internal::random_impl< bool > | |
| Eigen::internal::random_retval< Scalar > | |
| vcg::math::RandomGenerator | |
| randomMatrixWithImagEivals< MatrixType, IsComplex > | |
| randomMatrixWithImagEivals< MatrixType, 0 > | |
| randomMatrixWithImagEivals< MatrixType, 1 > | |
| Eigen::RandomSetter< SparseMatrixType, MapTraits, OuterPacketBits > | The RandomSetter is a wrapper object allowing to set/update a sparse matrix with random access |
| shape_reconstruction::RangeImagePlanar | Adapted version of pcl::RangeImagePlanar |
| vcg::RansacFramework< MeshType, FeatureSetType > | |
| vcg::RasterizedOutline2 | |
| vcg::RasterizedOutline2Packer< SCALAR_TYPE, RASTERIZER_TYPE > | |
| glw::RasterizerSettings | |
| rat42_functor | |
| rat43_functor | |
| vcg::RawVolumeImporter< VolumeType > | |
| vcg::Ray2< RayScalarType, NORM > | |
| vcg::Ray3< RayScalarType, NORM > | |
| vcg::AABBBinaryTreeRay< TREETYPE >::Ray3Ex | |
| vcg::RayIterator< Spatial_Idexing, INTFUNCTOR, TMARKER > | |
| vcg::RayIterator2D< Spatial_Idexing, INTFUNCTOR, TMARKER > | |
| vcg::RaySegmentIntersectionFunctor | |
| vcg::RayTriangleIntersectionFunctor< BACKFACETEST > | |
| glw::ReadDrawFramebufferBindingParams | |
| glw::ReadFramebufferBindingParams | |
| Eigen::internal::real_default_impl< Scalar, IsComplex > | |
| Eigen::internal::real_default_impl< Scalar, true > | |
| Eigen::internal::real_impl< Scalar > | |
| Eigen::internal::real_ref_impl< Scalar > | |
| Eigen::internal::real_ref_retval< Scalar > | |
| Eigen::internal::real_retval< Scalar > | |
| Eigen::RealQZ< _MatrixType > | Performs a real QZ decomposition of a pair of square matrices |
| Eigen::RealSchur< _MatrixType > | Performs a real Schur decomposition of a square matrix |
| Eigen::aligned_allocator_indirection< T >::rebind< U > | |
| Eigen::aligned_allocator< T >::rebind< U > | |
| vcg::RectPacker< SCALAR_TYPE > | |
| vcg::tri::RedetailSampler< MeshType > | |
| Eigen::internal::redux_impl< Func, Derived, DefaultTraversal, CompleteUnrolling > | |
| Eigen::internal::redux_impl< Func, Derived, DefaultTraversal, NoUnrolling > | |
| Eigen::internal::redux_impl< Func, Derived, LinearVectorizedTraversal, CompleteUnrolling > | |
| Eigen::internal::redux_impl< Func, Derived, LinearVectorizedTraversal, NoUnrolling > | |
| Eigen::internal::redux_impl< Func, Derived, SliceVectorizedTraversal, NoUnrolling > | |
| Eigen::internal::redux_novec_unroller< Func, Derived, Start, Length > | |
| Eigen::internal::redux_novec_unroller< Func, Derived, Start, 0 > | |
| Eigen::internal::redux_novec_unroller< Func, Derived, Start, 1 > | |
| Eigen::internal::redux_traits< Func, Derived > | |
| Eigen::internal::redux_vec_unroller< Func, Derived, Start, Length > | |
| Eigen::internal::redux_vec_unroller< Func, Derived, Start, 1 > | |
| Eigen::VectorwiseOp< ExpressionType, Direction >::ReduxReturnType< BinaryOp > | |
| Eigen::Ref< PlainObjectType, Options, StrideType > | A matrix or vector expression mapping an existing expressions |
| Eigen::Ref< const TPlainObjectType, Options, StrideType > | |
| Eigen::internal::ref_selector< T > | |
| Eigen::RefBase< Derived > | |
| glw::Context::RefCountedBindingHandleFromBinding< TBinding > | |
| glw::Context::RefCountedBindingHandleFromObject< TObject > | |
| glw::detail::RefCountedObject< TObject, TDeleter, TBaseObject > | |
| glw::detail::RefCountedObject< TObject, TDeleter, NoType > | |
| glw::detail::RefCountedObjectTraits< T > | |
| glw::Context::RefCountedPtrFromObject< TObject > | |
| glw::Context::RefCountedSafeHandleFromObject< TObject > | |
| vcg::Shot< S, RotationType >::ReferenceFrame< ScalarType, RotoType > | |
| vcg::PerfectSpatialHashing< OBJECT_TYPE, SCALAR_TYPE >::ReferenceType< TYPE > | |
| vcg::ReferenceType< T > | |
| vcg::ReferenceType< T * > | |
| vcg::PerfectSpatialHashing< OBJECT_TYPE, SCALAR_TYPE >::ReferenceType< TYPE * > | |
| vcg::tri::RefinedFaceData< VertexPointer > | |
| Collada::Tags::ReflectiveTag | |
| Collada::Tags::ReflectivityTag | |
| vcg::tri::RegularLoopWeight< SCALAR_TYPE > | Modified Loop's weight to optimise continuity |
| vcg::tri::Append< MeshLeft, ConstMeshRight >::Remap | |
| Eigen::internal::remove_all< T > | |
| Eigen::internal::remove_all< const T > | |
| Eigen::internal::remove_all< T & > | |
| Eigen::internal::remove_all< T * > | |
| Eigen::internal::remove_all< T const & > | |
| Eigen::internal::remove_all< T const * > | |
| Eigen::internal::remove_const< T > | |
| Eigen::internal::remove_const< const T > | |
| Eigen::internal::remove_const< const T[]> | |
| Eigen::internal::remove_const< const T[Size]> | |
| Eigen::internal::remove_pointer< T > | |
| Eigen::internal::remove_pointer< T * > | |
| Eigen::internal::remove_pointer< T *const > | |
| Eigen::internal::remove_reference< T > | |
| Eigen::internal::remove_reference< T & > | |
| vcg::tri::Clean< CleanMeshType >::RemoveDuplicateVert_Compare | |
| glw::Renderable | |
| glw::RenderableArguments | |
| glw::RenderableBindingParams | |
| glw::Renderbuffer | |
| glw::RenderbufferArguments | |
| glw::RenderbufferBindingParams | |
| glw::RenderTarget | |
| RenderTarget | |
| glw::RenderTargetBinding | |
| glw::RenderTargetMapping | |
| Eigen::Replicate< MatrixType, RowFactor, ColFactor > | Expression of the multiple replication of a matrix or vector |
| vcg::GLFeederInfo::ReqAtts | |
| vcg::tri::Resampler< OldMeshType, NewMeshType, DISTFUNCTOR > | |
| Eigen::internal::result_of< T > | |
| Eigen::internal::result_of< Func(ArgType)> | |
| Eigen::internal::result_of< Func(ArgType0, ArgType1)> | |
| Eigen::internal::result_of< scalar_cmp_op< Scalar, Cmp >(Scalar, Scalar)> | |
| mpfr::internal::result_type< ArgumentType > | |
| mpfr::internal::result_type< double > | |
| mpfr::internal::result_type< int > | |
| mpfr::internal::result_type< long double > | |
| mpfr::internal::result_type< long int > | |
| mpfr::internal::result_type< mpq_t > | |
| mpfr::internal::result_type< mpreal > | |
| mpfr::internal::result_type< mpz_t > | |
| mpfr::internal::result_type< unsigned int > | |
| mpfr::internal::result_type< unsigned long int > | |
| Eigen::ReturnByValue< Derived > | |
| Eigen::VectorwiseOp< ExpressionType, Direction >::ReturnType< Functor, Scalar > | |
| Eigen::Reverse< MatrixType, Direction > | Expression of the reverse of a vector or matrix |
| Eigen::internal::reverse_packet_cond< PacketScalar, ReversePacket > | |
| Eigen::internal::reverse_packet_cond< PacketScalar, false > | |
| Eigen::TransposeImpl< MatrixType, Sparse >::ReverseInnerIterator | |
| Eigen::CwiseUnaryOpImpl< UnaryOp, MatrixType, Sparse >::ReverseInnerIterator | |
| Eigen::SparseVector< _Scalar, _Options, _Index >::ReverseInnerIterator | |
| Eigen::MappedSparseMatrix< _Scalar, _Flags, _Index >::ReverseInnerIterator | |
| Eigen::DynamicSparseMatrix< _Scalar, _Options, _Index >::ReverseInnerIterator | |
| Eigen::BlockImpl< XprType, BlockRows, BlockCols, true, Sparse >::ReverseInnerIterator | |
| Eigen::BlockImpl< SparseMatrix< _Scalar, _Options, _Index >, BlockRows, BlockCols, true, Sparse >::ReverseInnerIterator | |
| Eigen::SparseTriangularView< MatrixType, Mode >::ReverseInnerIterator | |
| Eigen::BlockImpl< XprType, BlockRows, BlockCols, InnerPanel, Sparse >::ReverseInnerIterator | |
| Eigen::SparseMatrix< _Scalar, _Options, _Index >::ReverseInnerIterator | |
| Eigen::BlockImpl< const SparseMatrix< _Scalar, _Options, _Index >, BlockRows, BlockCols, true, Sparse >::ReverseInnerIterator | |
| Eigen::CwiseUnaryViewImpl< ViewOp, MatrixType, Sparse >::ReverseInnerIterator | |
| ring< T > | |
| glw::detail::RootOf< T > | |
| glw::detail::RootOfType< T, B > | |
| glw::detail::RootOfType< T, NoType > | |
| Collada::Tags::RotateTag | |
| Eigen::Rotation2D< _Scalar > | Represents a rotation/orientation in a 2 dimensional space |
| Eigen::internal::rotation_base_generic_product_selector< RotationDerived, DiagonalMatrix< Scalar, Dim, MaxDim >, false > | |
| Eigen::internal::rotation_base_generic_product_selector< RotationDerived, MatrixType, false > | |
| Eigen::internal::rotation_base_generic_product_selector< RotationDerived, OtherVectorType, true > | |
| Eigen::RotationBase< Derived, _Dim > | Common base class for compact rotation representations |
| vcg::tri::SurfaceSampling< MeshType, VertexSampler >::RRParam | |
| RTEdge | |
| RTFace | |
| RTMesh | |
| RTUsedTypes | |
| RTVertex | |
| vcg::Rubberband | The Rubberband class |
| mt::rw_lock | |
| glw::SafeBuffer | |
| glw::SafeFragmentShader | |
| glw::SafeFramebuffer | |
| glw::SafeGeometryShader | |
| glw::Context::SafeHandleFromBinding< TBinding > | |
| glw::Context::SafeHandleFromObject< TObject > | |
| glw::SafeObject | |
| glw::SafeProgram | |
| glw::SafeRenderable | |
| glw::SafeRenderbuffer | |
| glw::SafeShader | |
| glw::SafeTexture | |
| glw::SafeTexture2D | |
| glw::SafeTextureCube | |
| glw::SafeVertexShader | |
| Collada::Tags::Sampler2DTag | |
| vcg::Sampling< MetroMesh > | |
| vcg::SamplingFlags | |
| vcg::tri::io::ExporterVMI< SaveMeshType >::SaveFaceOcf< MeshType, CONT > | |
| vcg::tri::io::ExporterVMI< SaveMeshType >::SaveFaceOcf< MeshType, face::vector_ocf< typename MeshType::FaceType > > | |
| vcg::tri::io::ExporterVMI< SaveMeshType >::SaveVertexOcf< OpenMeshType, CONT > | |
| vcg::tri::io::ExporterVMI< SaveMeshType >::SaveVertexOcf< MeshType, vertex::vector_ocf< typename MeshType::VertexType > > | |
| Eigen::internal::scalar_abs2_op< Scalar > | |
| Eigen::internal::scalar_abs_op< Scalar > | |
| Eigen::internal::scalar_acos_op< Scalar > | |
| Eigen::internal::scalar_add_op< Scalar > | |
| Eigen::internal::scalar_asin_op< Scalar > | |
| Eigen::internal::scalar_binary_pow_op< Scalar, OtherScalar > | |
| Eigen::internal::scalar_boolean_and_op | |
| Eigen::internal::scalar_boolean_or_op | |
| Eigen::internal::scalar_cast_op< Scalar, NewType > | |
| Eigen::internal::scalar_cmp_op< Scalar, cmp_EQ > | |
| Eigen::internal::scalar_cmp_op< Scalar, cmp_LE > | |
| Eigen::internal::scalar_cmp_op< Scalar, cmp_LT > | |
| Eigen::internal::scalar_cmp_op< Scalar, cmp_NEQ > | |
| Eigen::internal::scalar_cmp_op< Scalar, cmp_UNORD > | |
| Eigen::internal::scalar_conj_product_op< LhsScalar, RhsScalar > | |
| Eigen::internal::scalar_conjugate_op< Scalar > | |
| Eigen::internal::scalar_constant_op< Scalar > | |
| Eigen::internal::scalar_cos_op< Scalar > | |
| Eigen::internal::scalar_cube_op< Scalar > | |
| Eigen::internal::scalar_difference_op< Scalar > | |
| Eigen::internal::scalar_exp_op< Scalar > | |
| Eigen::internal::scalar_fuzzy_default_impl< Scalar, IsComplex, IsInteger > | |
| Eigen::internal::scalar_fuzzy_default_impl< Scalar, false, false > | |
| Eigen::internal::scalar_fuzzy_default_impl< Scalar, false, true > | |
| Eigen::internal::scalar_fuzzy_default_impl< Scalar, true, false > | |
| Eigen::internal::scalar_fuzzy_impl< Scalar > | |
| Eigen::internal::scalar_fuzzy_impl< bool > | |
| Eigen::internal::scalar_hypot_op< Scalar > | |
| Eigen::internal::scalar_identity_op< Scalar > | |
| Eigen::internal::scalar_imag_op< Scalar > | |
| Eigen::internal::scalar_imag_ref_op< Scalar > | |
| Eigen::internal::scalar_inverse_mult_op< Scalar > | |
| Eigen::internal::scalar_inverse_op< Scalar > | |
| Eigen::internal::scalar_log_op< Scalar > | |
| Eigen::internal::scalar_max_op< Scalar > | |
| Eigen::internal::scalar_min_op< Scalar > | |
| Eigen::internal::scalar_multiple2_op< Scalar1, Scalar2 > | |
| Eigen::internal::scalar_multiple_op< Scalar > | |
| Eigen::internal::scalar_opposite_op< Scalar > | |
| Eigen::internal::scalar_pow_op< Scalar > | |
| Eigen::internal::scalar_product_op< LhsScalar, RhsScalar > | |
| Eigen::internal::scalar_product_traits< T, U > | |
| Eigen::internal::scalar_product_traits< A_Scalar, Matrix< A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols > > | |
| Eigen::internal::scalar_product_traits< AutoDiffScalar< DerType >, typename DerType::Scalar > | |
| Eigen::internal::scalar_product_traits< Matrix< A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols >, A_Scalar > | |
| Eigen::internal::scalar_product_traits< std::complex< T >, T > | |
| Eigen::internal::scalar_product_traits< T, std::complex< T > > | |
| Eigen::internal::scalar_product_traits< T, T > | |
| Eigen::internal::scalar_product_traits< typename DerType::Scalar, AutoDiffScalar< DerType > > | |
| Eigen::internal::scalar_quotient1_op< Scalar > | |
| Eigen::internal::scalar_quotient_op< LhsScalar, RhsScalar > | |
| Eigen::internal::scalar_random_op< Scalar > | |
| Eigen::internal::scalar_real_op< Scalar > | |
| Eigen::internal::scalar_real_ref_op< Scalar > | |
| Eigen::internal::scalar_sin_op< Scalar > | |
| Eigen::internal::scalar_sqrt_op< Scalar > | |
| Eigen::internal::scalar_square_op< Scalar > | |
| Eigen::internal::scalar_sum_op< Scalar > | |
| Eigen::internal::scalar_tan_op< Scalar > | |
| Eigen::RandomSetter< SparseMatrixType, MapTraits, OuterPacketBits >::ScalarWrapper | |
| Eigen::ScaledProduct< NestedProduct > | |
| vcg::tri::Smooth< SmoothMeshType >::ScaleLaplacianInfo | |
| vcg::ScaleMode | The scale manipulator |
| Eigen::Scaling< _Scalar, _Dim > | Represents a possibly non uniform scaling transformation |
| vcg::math::ScalingFactor< ScalarType, MAX_BAND > | |
| toyexample.Scene | |
| Collada::Tags::SceneTag | |
| mt::scoped_mutex_lock | |
| mt::scoped_read_lock | |
| mt::scoped_write_lock | |
| ScrUsedTypes | |
| nanoflann::SearchParams | |
| vcg::Segment2< SegmentScalarType > | |
| vcg::Segment3< SegmentScalarType > | |
| toyexample.Segmenter | |
| Eigen::Select< ConditionMatrixType, ThenMatrixType, ElseMatrixType > | Expression of a coefficient wise version of the C++ ternary operator ?: |
| vcg::tri::SelectionStack< ComputeMeshType > | A stack for saving and restoring selection |
| Eigen::internal::selfadjoint_matrix_vector_product< Scalar, Index, StorageOrder, UpLo, ConjugateLhs, ConjugateRhs, Version > | |
| Eigen::internal::selfadjoint_matrix_vector_product_symv< Scalar, Index, StorageOrder, UpLo, ConjugateLhs, ConjugateRhs > | |
| Eigen::selfadjoint_product_selector< MatrixType, OtherType, UpLo, false > | |
| Eigen::selfadjoint_product_selector< MatrixType, OtherType, UpLo, true > | |
| Eigen::selfadjoint_rank1_update< Scalar, Index, ColMajor, UpLo, ConjLhs, ConjRhs > | |
| Eigen::selfadjoint_rank1_update< Scalar, Index, RowMajor, UpLo, ConjLhs, ConjRhs > | |
| Eigen::internal::selfadjoint_rank2_update_selector< Scalar, Index, UType, VType, Lower > | |
| Eigen::internal::selfadjoint_rank2_update_selector< Scalar, Index, UType, VType, Upper > | |
| Eigen::SelfAdjointEigenSolver< _MatrixType > | Computes eigenvalues and eigenvectors of selfadjoint matrices |
| Eigen::SelfadjointProductMatrix< Lhs, 0, true, Rhs, RhsMode, false > | |
| Eigen::SelfadjointProductMatrix< Lhs, LhsMode, false, Rhs, 0, true > | |
| Eigen::SelfadjointProductMatrix< Lhs, LhsMode, false, Rhs, RhsMode, false > | |
| Eigen::SelfAdjointView< MatrixType, UpLo > | Expression of a selfadjoint matrix from a triangular part of a dense matrix |
| Eigen::MatrixBase< Derived >::SelfAdjointViewReturnType< UpLo > | |
| Eigen::SelfCwiseBinaryOp< BinaryOp, Lhs, Rhs > | |
| vcg::tri::SelfIntersectionEar< MESH > | |
| mt::semaphore | |
| Eigen::GeneralProduct< Lhs, Rhs, OuterProduct >::set | |
| Eigen::internal::setIdentity_impl< Derived, Big > | |
| Eigen::internal::setIdentity_impl< Derived, true > | |
| Shader | |
| glw::Shader | |
| glw::ShaderArguments | |
| glw::ShaderBindingParams | |
| glw::ShaderHeaderBuilder | |
| omip::ShapeReconstruction | |
| omip::ShapeReconstructionNode | |
| omip::ShapeRecPlotter | |
| SharedDataOpenGLContext | |
| vcg::AABBBinaryTree< OBJTYPE, SCALARTYPE, NODEAUXDATATYPE >::AABBBinaryTreeNode::SharedDataUnion | |
| Collada::Tags::ShininessTag | |
| vcg::Shot< S, RotationType > | |
| vcg::tri::Zonohedron< Scalar >::Signature | |
| Eigen::internal::significant_decimals_default_impl< Scalar, IsInteger > | |
| Eigen::internal::significant_decimals_default_impl< Scalar, true > | |
| Eigen::internal::significant_decimals_impl< Scalar > | |
| vcg::Similarity< S, RotationType > | |
| vcg::Similarity2< SCALAR_TYPE > | |
| vcg::Similarityd | |
| vcg::Similarityf | |
| vcg::DisjointSet< OBJECT_TYPE >::SimpleObjHashFunc | |
| vcg::SimplePic< PixType > | |
| vcg::SimpleTempData< STL_CONT, ATTR_TYPE > | |
| vcg::SimpleTempDataBase | |
| vcg::tri::Clustering< MeshType, CellType >::SimpleTri | |
| vcg::SimpleVolume< VOX_TYPE > | |
| vcg::SimpleVoxel< _ScalarType > | |
| vcg::SimpleVoxelWithNormal< _ScalarType > | |
| Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering > | |
| Eigen::SimplicialCholeskyBase< Derived > | A direct sparse Cholesky factorizations |
| Eigen::SimplicialLDLT< _MatrixType, _UpLo, _Ordering > | A direct sparse LDLT Cholesky factorizations without square root |
| Eigen::SimplicialLLT< _MatrixType, _UpLo, _Ordering > | A direct sparse LLT Cholesky factorizations |
| Eigen::SparseMatrix< _Scalar, _Options, _Index >::SingletonVector | |
| Eigen::internal::size_at_compile_time< _Rows, _Cols > | |
| Eigen::internal::skyline_product_selector< Lhs, Rhs, ResultType, ColMajor > | |
| Eigen::internal::skyline_product_selector< Lhs, Rhs, ResultType, RowMajor > | |
| Eigen::SkylineInplaceLU< MatrixType > | Inplace LU decomposition of a skyline matrix and associated features |
| Eigen::SkylineMatrix< _Scalar, _Options > | The main skyline matrix class |
| Eigen::SkylineMatrixBase< Derived > | Base class of any skyline matrices or skyline expressions |
| Eigen::internal::SkylineProduct< LhsNested, RhsNested, ProductMode > | |
| Eigen::SkylineProductReturnType< Lhs, Rhs, ProductMode > | |
| Eigen::SkylineStorage< Scalar > | |
| SlotNode | |
| SlotsNode | |
| Eigen::SluMatrix | |
| Eigen::SluMatrixMapHelper< Matrix< Scalar, Rows, Cols, Options, MRows, MCols > > | |
| Eigen::SluMatrixMapHelper< SparseMatrixBase< Derived > > | |
| vcg::SmallestEnclosing | |
| Eigen::internal::smart_copy_helper< T, false > | |
| Eigen::internal::smart_copy_helper< T, true > | |
| vcg::tri::io::ImporterSMF< OpenMeshType >::SMFFacet | |
| vcg::tri::Smooth< SmoothMeshType > | Class of static functions to smooth and fair meshes and their attributes |
| vcg::tri::FieldSmoother< MeshType >::SmoothParam | |
| Eigen::internal::solve_retval< BDCSVD< _MatrixType >, Rhs > | |
| Eigen::internal::solve_retval< BiCGSTAB< _MatrixType, _Preconditioner >, Rhs > | |
| Eigen::internal::solve_retval< CholmodBase< _MatrixType, _UpLo, Derived >, Rhs > | |
| Eigen::internal::solve_retval< ColPivHouseholderQR< _MatrixType >, Rhs > | |
| Eigen::internal::solve_retval< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner >, Rhs > | |
| Eigen::internal::solve_retval< DGMRES< _MatrixType, _Preconditioner >, Rhs > | |
| Eigen::internal::solve_retval< DiagonalPreconditioner< _MatrixType >, Rhs > | |
| Eigen::internal::solve_retval< FullPivHouseholderQR< _MatrixType >, Rhs > | |
| Eigen::internal::solve_retval< FullPivLU< _MatrixType >, Rhs > | |
| Eigen::internal::solve_retval< GMRES< _MatrixType, _Preconditioner >, Rhs > | |
| Eigen::internal::solve_retval< HouseholderQR< _MatrixType >, Rhs > | |
| Eigen::internal::solve_retval< IncompleteCholesky< _Scalar, _UpLo, OrderingType >, Rhs > | |
| Eigen::internal::solve_retval< IncompleteLU< _MatrixType >, Rhs > | |
| Eigen::internal::solve_retval< IncompleteLUT< _MatrixType >, Rhs > | |
| Eigen::internal::solve_retval< JacobiSVD< _MatrixType, QRPreconditioner >, Rhs > | |
| Eigen::internal::solve_retval< LDLT< _MatrixType, _UpLo >, Rhs > | |
| Eigen::internal::solve_retval< LLT< _MatrixType, UpLo >, Rhs > | |
| Eigen::internal::solve_retval< MINRES< _MatrixType, _UpLo, _Preconditioner >, Rhs > | |
| Eigen::internal::solve_retval< PardisoImpl< _Derived >, Rhs > | |
| Eigen::internal::solve_retval< PartialPivLU< _MatrixType >, Rhs > | |
| Eigen::internal::solve_retval< PastixBase< _MatrixType >, Rhs > | |
| Eigen::internal::solve_retval< SimplicialCholeskyBase< Derived >, Rhs > | |
| Eigen::internal::solve_retval< SparseLU< _MatrixType, Derived >, Rhs > | |
| Eigen::internal::solve_retval< SparseQR< _MatrixType, OrderingType >, Rhs > | |
| Eigen::internal::solve_retval< SPQR< _MatrixType >, Rhs > | |
| Eigen::internal::solve_retval< SuperLUBase< _MatrixType, Derived >, Rhs > | |
| Eigen::internal::solve_retval< UmfPackLU< _MatrixType >, Rhs > | |
| Eigen::internal::solve_retval_base< _DecompositionType, Rhs > | |
| Eigen::internal::solve_retval_with_guess< DecompositionType, Rhs, Guess > | |
| vcg::tri::Clean< CleanMeshType >::SortedPair | |
| vcg::tri::Clean< CleanMeshType >::SortedTriple | |
| Collada::Tags::SourceTag | |
| vcg::Space< N, S > | |
| Eigen::internal::sparse_cwise_binary_op_inner_iterator_selector< BinaryOp, Lhs, Rhs, Derived, Sparse, Sparse > | |
| Eigen::internal::sparse_cwise_binary_op_inner_iterator_selector< scalar_product_op< T >, Lhs, Rhs, Derived, Dense, Sparse > | |
| Eigen::internal::sparse_cwise_binary_op_inner_iterator_selector< scalar_product_op< T >, Lhs, Rhs, Derived, Sparse, Dense > | |
| Eigen::internal::sparse_cwise_binary_op_inner_iterator_selector< scalar_product_op< T >, Lhs, Rhs, Derived, Sparse, Sparse > | |
| Eigen::internal::sparse_diagonal_product_inner_iterator_selector< Lhs, Rhs, SparseDiagonalProductType, SDP_IsDiagonal, SDP_IsSparseColMajor > | |
| Eigen::internal::sparse_diagonal_product_inner_iterator_selector< Lhs, Rhs, SparseDiagonalProductType, SDP_IsDiagonal, SDP_IsSparseRowMajor > | |
| Eigen::internal::sparse_diagonal_product_inner_iterator_selector< Lhs, Rhs, SparseDiagonalProductType, SDP_IsSparseColMajor, SDP_IsDiagonal > | |
| Eigen::internal::sparse_diagonal_product_inner_iterator_selector< Lhs, Rhs, SparseDiagonalProductType, SDP_IsSparseRowMajor, SDP_IsDiagonal > | |
| Eigen::internal::sparse_eval< T, Rows, Cols > | |
| Eigen::internal::sparse_eval< T, 1, 1 > | |
| Eigen::internal::sparse_eval< T, 1, Cols > | |
| Eigen::internal::sparse_eval< T, Rows, 1 > | |
| Eigen::internal::sparse_solve_retval< CholmodBase< _MatrixType, _UpLo, Derived >, Rhs > | |
| Eigen::internal::sparse_solve_retval< IterativeSolverBase< Derived >, Rhs > | |
| Eigen::internal::sparse_solve_retval< PardisoImpl< Derived >, Rhs > | |
| Eigen::internal::sparse_solve_retval< PastixBase< _MatrixType >, Rhs > | |
| Eigen::internal::sparse_solve_retval< SimplicialCholeskyBase< Derived >, Rhs > | |
| Eigen::internal::sparse_solve_retval< SparseLU< _MatrixType, Derived >, Rhs > | |
| Eigen::internal::sparse_solve_retval< SparseQR< _MatrixType, OrderingType >, Rhs > | |
| Eigen::internal::sparse_solve_retval< SuperLUBase< _MatrixType, Derived >, Rhs > | |
| Eigen::internal::sparse_solve_retval< UmfPackLU< _MatrixType >, Rhs > | |
| Eigen::internal::sparse_solve_retval_base< _DecompositionType, Rhs > | |
| Eigen::internal::sparse_solve_triangular_selector< Lhs, Rhs, Mode, Lower, ColMajor > | |
| Eigen::internal::sparse_solve_triangular_selector< Lhs, Rhs, Mode, Lower, RowMajor > | |
| Eigen::internal::sparse_solve_triangular_selector< Lhs, Rhs, Mode, Upper, ColMajor > | |
| Eigen::internal::sparse_solve_triangular_selector< Lhs, Rhs, Mode, Upper, RowMajor > | |
| Eigen::internal::sparse_solve_triangular_sparse_selector< Lhs, Rhs, Mode, UpLo, ColMajor > | |
| Eigen::internal::sparse_sparse_product_with_pruning_selector< Lhs, Rhs, ResultType, ColMajor, ColMajor, ColMajor > | |
| Eigen::internal::sparse_sparse_product_with_pruning_selector< Lhs, Rhs, ResultType, ColMajor, ColMajor, RowMajor > | |
| Eigen::internal::sparse_sparse_product_with_pruning_selector< Lhs, Rhs, ResultType, RowMajor, RowMajor, ColMajor > | |
| Eigen::internal::sparse_sparse_product_with_pruning_selector< Lhs, Rhs, ResultType, RowMajor, RowMajor, RowMajor > | |
| Eigen::internal::sparse_time_dense_product_impl< SparseLhsType, DenseRhsType, DenseResType, ColMajor, false > | |
| Eigen::internal::sparse_time_dense_product_impl< SparseLhsType, DenseRhsType, DenseResType, ColMajor, true > | |
| Eigen::internal::sparse_time_dense_product_impl< SparseLhsType, DenseRhsType, DenseResType, RowMajor, false > | |
| Eigen::internal::sparse_time_dense_product_impl< SparseLhsType, DenseRhsType, DenseResType, RowMajor, true > | |
| Eigen::internal::sparse_vector_assign_selector< Dest, Src, SVA_Inner > | |
| Eigen::internal::sparse_vector_assign_selector< Dest, Src, SVA_Outer > | |
| Eigen::internal::sparse_vector_assign_selector< Dest, Src, SVA_RuntimeSwitch > | |
| Eigen::SparseDenseOuterProduct< Lhs, Rhs, Tr > | |
| Eigen::SparseDenseProductReturnType< Lhs, Rhs, InnerSize > | |
| Eigen::SparseDenseProductReturnType< Lhs, Rhs, 1 > | |
| Eigen::SparseDiagonalProduct< Lhs, Rhs > | |
| Eigen::SparseFunctor< _Scalar, _Index > | |
| Eigen::SparseLU< _MatrixType, _OrderingType > | Sparse supernodal LU factorization for general matrices |
| Eigen::internal::SparseLUImpl< Scalar, Index > | |
| Eigen::SparseLUMatrixLReturnType< MappedSupernodalType > | |
| Eigen::SparseLUMatrixUReturnType< MatrixLType, MatrixUType > | |
| Eigen::SparseMatrix< _Scalar, _Options, _Index > | A versatible sparse matrix representation |
| SparseMatrix< ScalarType > | |
| Eigen::SparseMatrixBase< Derived > | Base class of any sparse matrices or sparse expressions |
| Eigen::SparseQR< _MatrixType, _OrderingType > | Sparse left-looking rank-revealing QR factorization |
| Eigen::SparseQR_QProduct< SparseQRType, Derived > | |
| Eigen::SparseQRMatrixQReturnType< SparseQRType > | |
| Eigen::SparseQRMatrixQTransposeReturnType< SparseQRType > | |
| Eigen::SparseSelfAdjointTimeDenseProduct< Lhs, Rhs, UpLo > | |
| Eigen::SparseSelfAdjointView< MatrixType, UpLo > | Pseudo expression to manipulate a triangular sparse matrix as a selfadjoint matrix |
| Eigen::SparseSparseProduct< LhsNested, RhsNested > | |
| Eigen::SparseSparseProductReturnType< Lhs, Rhs > | |
| Eigen::SparseSymmetricPermutationProduct< MatrixType, UpLo > | |
| Eigen::SparseTimeDenseProduct< Lhs, Rhs > | |
| Eigen::SparseTriangularView< MatrixType, Mode > | |
| Eigen::SparseVector< _Scalar, _Options, _Index > | Sparse vector class |
| Eigen::SparseView< MatrixType > | |
| vcg::SpatialHashTable< ObjType, FLT > | |
| vcg::SpatialHashTable2D< ObjType, FLT > | |
| vcg::SpatialIndex< OBJTYPE, SCALARTYPE > | |
| vcg::SpatialIndex2D< OBJTYPE, SCALARTYPE > | |
| Eigen::internal::special_scalar_op_base< Derived, Scalar, OtherScalar, EnableIt > | |
| Eigen::internal::special_scalar_op_base< Derived, Scalar, OtherScalar, true > | |
| Collada::Tags::SpecularTag | |
| vcg::vertex::Sph< A, T > | |
| vcg::vertex::Sph16d< T > | |
| vcg::vertex::Sph16f< T > | |
| vcg::vertex::Sph25d< T > | |
| vcg::vertex::Sph25f< T > | |
| vcg::vertex::Sph36d< T > | |
| vcg::vertex::Sph36f< T > | |
| vcg::vertex::Sph49f< T > | |
| vcg::vertex::Sph9d< T > | |
| vcg::vertex::Sph9f< T > | |
| vcg::Sphere3< T > | |
| SphereDifference | |
| vcg::SphereMode | The classic arcball manipulator |
| SphereUnion | |
| vcg::math::SphericalHarmonics< ScalarType, MAX_BAND > | |
| SplatRenderer< MeshType > | |
| Eigen::Spline< _Scalar, _Dim, _Degree > | A class representing multi-dimensional spline curves |
| Eigen::SplineFitting< SplineType > | Spline fitting methods |
| Eigen::SplineTraits< SplineType, DerivativeOrder > | |
| Eigen::SplineTraits< Spline< _Scalar, _Dim, _Degree >, _DerivativeOrder > | Compile-time attributes of the Spline class for fixed degree |
| Eigen::SplineTraits< Spline< _Scalar, _Dim, _Degree >, Dynamic > | Compile-time attributes of the Spline class for Dynamic degree |
| vcg::tri::Split | |
| vcg::tri::Quadrangulator< TriMesh, PolyMesh >::SplitMidPoint< MESH_TYPE > | |
| Eigen::SPQR< _MatrixType > | Sparse QR factorization based on SuiteSparseQR library |
| Eigen::SPQR_QProduct< SPQRType, Derived > | |
| Eigen::SPQRMatrixQReturnType< SPQRType > | |
| Eigen::SPQRMatrixQTransposeReturnType< SPQRType > | |
| SrcFace | |
| SrcMesh | |
| SrcVertex | |
| vcg::tri::FourPCS< MeshType >::Stat | |
| vcg::RectPacker< SCALAR_TYPE >::Stat | |
| vcg::tri::SurfaceSampling< MeshType, VertexSampler >::PoissonDiskParam::Stat | |
| vcg::tri::Stat< StatMeshType > | |
| vcg::tri::VoronoiAtlas< MeshType >::VoronoiAtlasParam::Stat | |
| Eigen::internal::static_assertion< condition > | |
| Eigen::internal::static_assertion< true > | |
| Eigen::StdMapTraits< Scalar > | |
| Eigen::StdStemFunctions< Scalar > | Stem functions corresponding to standard mathematical functions |
| Eigen::internal::stem_function< Scalar > | |
| StencilRenderBuffer | |
| StencilRenderTarget | |
| StencilRenderTexture | |
| StencilTexture | |
| StencilTexture2D | |
| vcg::tri::io::ImporterSTL< OpenMeshType >::STLFacet | |
| StraightFace | |
| StraightVertex | |
| Eigen::Stride< _OuterStrideAtCompileTime, _InnerStrideAtCompileTime > | Holds strides information for Map |
| Eigen::PlainObjectBase< Derived >::StridedAlignedMapType< StrideType > | |
| Eigen::PlainObjectBase< Derived >::StridedConstAlignedMapType< StrideType > | |
| Eigen::PlainObjectBase< Derived >::StridedConstMapType< StrideType > | |
| Eigen::PlainObjectBase< Derived >::StridedMapType< StrideType > | |
| vcg::StripMesh | |
| vcg::StripMeshBuilder | |
| Eigen::GeneralProduct< Lhs, Rhs, OuterProduct >::sub | |
| vcg::math::SubtractiveRingRNG | |
| Eigen::SuperLU< _MatrixType > | A sparse direct LU factorization and solver based on the SuperLU library |
| Eigen::SuperLUBase< _MatrixType, Derived > | The base class for the direct and incomplete LU factorization of SuperLU |
| vcg::tri::SurfaceSampling< MeshType, VertexSampler > | Main Class of the Sampling framework |
| omip::SurfaceSmootherNode | |
| Collada::Tags::SurfaceTag | |
| Eigen::SVD< MatrixType > | Standard SVD decomposition of a matrix and associated features |
| Eigen::internal::svd_precondition_2x2_block_to_be_real< MatrixType, QRPreconditioner, IsComplex > | |
| Eigen::internal::svd_precondition_2x2_block_to_be_real< MatrixType, QRPreconditioner, false > | |
| Eigen::internal::svd_precondition_2x2_block_to_be_real< MatrixType, QRPreconditioner, true > | |
| Eigen::SVDBase< _MatrixType > | Mother class of SVD classes algorithms |
| vcg::tri::io::SVGProperties | |
| Eigen::SwapWrapper< ExpressionType > | |
| Eigen::internal::symm_pack_lhs< Scalar, Index, Pack1, Pack2, StorageOrder > | |
| Eigen::internal::symm_pack_rhs< Scalar, Index, nr, StorageOrder > | |
| SystemLDL | |
| Eigen::internal::take_matrix_for_product< MatrixOrTransformType > | |
| Eigen::internal::take_matrix_for_product< Transform< Scalar, Dim, Mode, Options > > | |
| Eigen::internal::take_matrix_for_product< Transform< Scalar, Dim, Projective, Options > > | |
| Collada::Tags::TechniqueCommonTag | |
| Collada::Tags::TechniqueTag | |
| vcg::tri::Geodesic< MeshType >::TempData | |
| template AsFaceType< Arity5< DummyTypes, Use< Vertex< UsedTypes< vcg::Use< ColladaVertex >::template AsVertexType, vcg::Use< ColladaFace >::template AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< vcg::Use< ColladaVertex >::template AsVertexType, vcg::Use< ColladaFace >::template AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< vcg::Use< ColladaVertex >::template AsVertexType, vcg::Use< ColladaFace >::template AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< vcg::Use< ColladaVertex >::template AsVertexType, vcg::Use< ColladaFace >::template AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, vcg::Use< ColladaVertex >::template AsVertexType > > | |
| template AsFaceType< Arity5< DummyTypes, Use< Vertex< UsedTypes< vcg::Use< PVertex >::template AsVertexType, vcg::Use< PFace >::template AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< vcg::Use< PVertex >::template AsVertexType, vcg::Use< PFace >::template AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< vcg::Use< PVertex >::template AsVertexType, vcg::Use< PFace >::template AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< vcg::Use< PVertex >::template AsVertexType, vcg::Use< PFace >::template AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, vcg::Use< PVertex >::template AsVertexType > > | |
| template AsFaceType< Arity6< DummyTypes, Use< Vertex< UsedTypes< Use< VoroVertex >::template AsVertexType, Use< VoroEdge >::template AsEdgeType, Use< VoroFace >::template AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsVertexType, Use< Edge< UsedTypes< Use< VoroVertex >::template AsVertexType, Use< VoroEdge >::template AsEdgeType, Use< VoroFace >::template AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsEdgeType, Use< Face< UsedTypes< Use< VoroVertex >::template AsVertexType, Use< VoroEdge >::template AsEdgeType, Use< VoroFace >::template AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsFaceType, Use< HEdge< UsedTypes< Use< VoroVertex >::template AsVertexType, Use< VoroEdge >::template AsEdgeType, Use< VoroFace >::template AsFaceType, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver, DefaultDeriver > > >::template AsHEdgeType, Use< VoroVertex >::template AsVertexType, Use< VoroEdge >::template AsEdgeType > > | |
| vcg::glu_tesselator::tess_prim_data | |
| TestFunc1< _Scalar, NX, NY > | |
| vcg::Tetra | |
| vcg::Tetra3< ScalarType > | |
| vcg::TetraArity1< BVT, BET, BFT, BTT, A > | |
| vcg::TetraArity2< BVT, BET, BFT, BTT, A, B > | |
| vcg::TetraArity3< BVT, BET, BFT, BTT, A, B, C > | |
| vcg::TetraArity4< BVT, BET, BFT, BTT, A, B, C, D > | |
| vcg::TetraArity5< BVT, BET, BFT, BTT, A, B, C, D, E > | |
| vcg::TetraArity6< BVT, BET, BFT, BTT, A, B, C, D, E, F > | |
| vcg::TetraArity7< BVT, BET, BFT, BTT, A, B, C, D, E, F, G > | |
| vcg::TetraArity8< BVT, BET, BFT, BTT, A, B, C, D, E, F, G, H > | |
| vcg::TetraArityMax< BVT, BET, BFT, BTT, A, B, C, D, E, F, G, H, I > | |
| vcg::TetraBase< BVT, BET, BFT, BTT > | |
| vcg::TetraDefaultDeriver< T > | |
| vcg::tetra::TetraEdgeCollapse< TETRA_MESH_TYPE > | |
| vcg::TetraSimp2< BVT, BET, BFT, A, B, C, D, E, F, G, H, I > | |
| vcg::TetraSimp3< BVT, BET, BFT, BTT, A, B, C, D, E, F, G, H, I > | |
| vcg::TetraTypeHolder< BVT, BET, BFT, BTT > | |
| vcg::vertex::TexCoord< A, TT > | Generic Component: Per vertex Texture Coords |
| vcg::TexCoord2< T, NMAX > | Templated class for a storing a set of 2D texture coord plus their texture id |
| vcg::vertex::TexCoord2d< TT > | Specialized Texture component in double precision |
| vcg::vertex::TexCoord2dOcc< T > | |
| vcg::vertex::TexCoord2f< TT > | Specialized Texture component in floating point precision |
| vcg::vertex::TexCoord2fOcc< T > | |
| vcg::vertex::TexCoord2s< TT > | |
| vcg::TexCoord2Simple< T > | |
| vcg::vertex::TexCoord2sOcc< T > | |
| vcg::vertex::TexCoordfOcf< T > | |
| vcg::vertex::TexCoordOcc< A, TT > | |
| vcg::vertex::TexCoordOcf< A, TT > | *-------------------------- TEXTURE ----------------------------------*/ |
| glw::Texture | |
| Texture | |
| Texture1D | |
| Texture2D | |
| glw::Texture2D | |
| glw::Texture2DArguments | |
| glw::Texture2DBindingParams | |
| Texture3D | |
| glw::TextureArguments | |
| glw::TextureBindingParams | |
| glw::TextureCube | |
| glw::TextureCubeArguments | |
| glw::TextureCubeBindingParams | |
| vcg::tri::TextureOptimizer< MESH_TYPE > | |
| TextureRenderTarget | |
| glw::TextureSampleMode | |
| Collada::Tags::TextureTag | |
| TextUtility | |
| TFace | |
| vcg::tri::io::TGA_Exporter | |
| vcg::tri::io::TGA_Exporter::TGAHeader | |
| mt::thread | |
| thurber_functor | |
| vcg::tri::Tmark< MESH_TYPE, OBJ_TYPE > | |
| TMesh | |
| vcg::Token< Priority > | |
| vcg::tri::TopoEdgeFlip< TRIMESH_TYPE, MYTYPE > | |
| vcg::Trackball | The manipulator manager system |
| vcg::TrackMode | Base class for all the manipulators |
| vcg::TrackRecorder | |
| nanoflann::metric_L2_Simple::traits< T, DataSource > | |
| nanoflann::metric_L1::traits< T, DataSource > | |
| nanoflann::metric_L2::traits< T, DataSource > | |
| Eigen::internal::traits< AngleAxis< _Scalar > > | |
| Eigen::internal::traits< Array< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > > | |
| Eigen::internal::traits< ArrayWrapper< ExpressionType > > | |
| Eigen::internal::traits< BandMatrix< _Scalar, _Rows, _Cols, _Supers, _Subs, _Options > > | |
| Eigen::internal::traits< BandMatrixWrapper< _CoefficientsType, _Rows, _Cols, _Supers, _Subs, _Options > > | |
| Eigen::internal::traits< BiCGSTAB< _MatrixType, _Preconditioner > > | |
| Eigen::internal::traits< Block< XprType, BlockRows, BlockCols, InnerPanel > > | |
| Eigen::internal::traits< CoeffBasedProduct< LhsNested, RhsNested, NestingFlags > > | |
| Eigen::internal::traits< ConjugateGradient< _MatrixType, _UpLo, _Preconditioner > > | |
| Eigen::internal::traits< const T > | |
| Eigen::internal::traits< CwiseBinaryOp< BinaryOp, Lhs, Rhs > > | |
| Eigen::internal::traits< CwiseNullaryOp< NullaryOp, PlainObjectType > > | |
| Eigen::internal::traits< CwiseUnaryOp< UnaryOp, XprType > > | |
| Eigen::internal::traits< CwiseUnaryView< ViewOp, MatrixType > > | |
| Eigen::internal::traits< DenseTimeSparseProduct< Lhs, Rhs > > | |
| Eigen::internal::traits< DenseTimeSparseSelfAdjointProduct< Lhs, Rhs, UpLo > > | |
| Eigen::internal::traits< DGMRES< _MatrixType, _Preconditioner > > | |
| Eigen::internal::traits< Diagonal< const SparseMatrix< _Scalar, _Options, _Index >, DiagIndex > > | |
| Eigen::internal::traits< Diagonal< MatrixType, DiagIndex > > | |
| Eigen::internal::traits< DiagonalMatrix< _Scalar, SizeAtCompileTime, MaxSizeAtCompileTime > > | |
| Eigen::internal::traits< DiagonalProduct< MatrixType, DiagonalType, ProductOrder > > | |
| Eigen::internal::traits< DiagonalWrapper< _DiagonalVectorType > > | |
| Eigen::internal::traits< DynamicSparseMatrix< _Scalar, _Options, _Index > > | |
| Eigen::internal::traits< Flagged< ExpressionType, Added, Removed > > | |
| Eigen::internal::traits< ForceAlignedAccess< ExpressionType > > | |
| Eigen::internal::traits< FullPivHouseholderQRMatrixQReturnType< MatrixType > > | |
| Eigen::internal::traits< GeneralProduct< Lhs, Rhs, GemmProduct > > | |
| Eigen::internal::traits< GeneralProduct< Lhs, Rhs, GemvProduct > > | |
| Eigen::internal::traits< GeneralProduct< Lhs, Rhs, InnerProduct > > | |
| Eigen::internal::traits< GeneralProduct< Lhs, Rhs, OuterProduct > > | |
| Eigen::internal::traits< GMRES< _MatrixType, _Preconditioner > > | |
| Eigen::internal::traits< HessenbergDecompositionMatrixHReturnType< MatrixType > > | |
| Eigen::internal::traits< Homogeneous< MatrixType, Direction > > | |
| Eigen::internal::traits< homogeneous_left_product_impl< Homogeneous< MatrixType, Vertical >, Lhs > > | |
| Eigen::internal::traits< homogeneous_right_product_impl< Homogeneous< MatrixType, Horizontal >, Rhs > > | |
| Eigen::internal::traits< HouseholderSequence< VectorsType, CoeffsType, Side > > | |
| Eigen::internal::traits< image_retval_base< DecompositionType > > | |
| Eigen::internal::traits< inverse_impl< MatrixType > > | |
| Eigen::internal::traits< kernel_retval_base< DecompositionType > > | |
| Eigen::internal::traits< KroneckerProduct< _Lhs, _Rhs > > | |
| Eigen::internal::traits< KroneckerProductSparse< _Lhs, _Rhs > > | |
| Eigen::internal::traits< Map< const Quaternion< _Scalar >, _Options > > | |
| Eigen::internal::traits< Map< PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, IndexType >, _PacketAccess > > | |
| Eigen::internal::traits< Map< PlainObjectType, MapOptions, StrideType > > | |
| Eigen::internal::traits< Map< Quaternion< _Scalar >, _Options > > | |
| Eigen::internal::traits< Map< Transpositions< SizeAtCompileTime, MaxSizeAtCompileTime, IndexType >, _PacketAccess > > | |
| Eigen::internal::traits< MappedSparseMatrix< _Scalar, _Flags, _Index > > | |
| Eigen::internal::traits< Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > > | |
| Eigen::internal::traits< MatrixExponentialReturnValue< Derived > > | |
| Eigen::internal::traits< MatrixFunctionReturnValue< Derived > > | |
| Eigen::internal::traits< MatrixLogarithmReturnValue< Derived > > | |
| Eigen::internal::traits< MatrixPowerReturnValue< Derived > > | |
| Eigen::internal::traits< MatrixPowerRetval< MatrixPowerType > > | |
| Eigen::internal::traits< MatrixSquareRootReturnValue< Derived > > | |
| Eigen::internal::traits< MatrixWrapper< ExpressionType > > | |
| Eigen::internal::traits< Minor< MatrixType > > | |
| Eigen::internal::traits< MINRES< _MatrixType, _UpLo, _Preconditioner > > | |
| Eigen::internal::traits< NestByValue< ExpressionType > > | |
| Eigen::internal::traits< PartialReduxExpr< MatrixType, MemberOp, Direction > > | |
| Eigen::internal::traits< permut_matrix_product_retval< PermutationType, MatrixType, Side, Transposed > > | |
| Eigen::internal::traits< permut_sparsematrix_product_retval< PermutationType, MatrixType, Side, Transposed > > | |
| Eigen::internal::traits< PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, IndexType > > | |
| Eigen::internal::traits< PermutationWrapper< _IndicesType > > | |
| Eigen::internal::traits< ProductBase< Derived, _Lhs, _Rhs > > | |
| Eigen::internal::traits< Quaternion< _Scalar, _Options > > | |
| Eigen::internal::traits< Ref< _PlainObjectType, _Options, _StrideType > > | |
| Eigen::internal::traits< RefBase< Derived > > | |
| Eigen::internal::traits< Replicate< MatrixType, RowFactor, ColFactor > > | |
| Eigen::internal::traits< ReturnByValue< Derived > > | |
| Eigen::internal::traits< Reverse< MatrixType, Direction > > | |
| Eigen::internal::traits< Rotation2D< _Scalar > > | |
| Eigen::internal::traits< ScaledProduct< NestedProduct > > | |
| Eigen::internal::traits< Select< ConditionMatrixType, ThenMatrixType, ElseMatrixType > > | |
| Eigen::internal::traits< SelfadjointProductMatrix< Lhs, 0, true, Rhs, RhsMode, false > > | |
| Eigen::internal::traits< SelfadjointProductMatrix< Lhs, LhsMode, false, Rhs, 0, true > > | |
| Eigen::internal::traits< SelfadjointProductMatrix< Lhs, LhsMode, false, Rhs, RhsMode, false > > | |
| Eigen::internal::traits< SelfAdjointView< MatrixType, UpLo > > | |
| Eigen::internal::traits< SelfCwiseBinaryOp< BinaryOp, Lhs, Rhs > > | |
| Eigen::internal::traits< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > > | |
| Eigen::internal::traits< SimplicialLDLT< _MatrixType, _UpLo, _Ordering > > | |
| Eigen::internal::traits< SimplicialLLT< _MatrixType, _UpLo, _Ordering > > | |
| Eigen::internal::traits< SkylineMatrix< _Scalar, _Options > > | |
| Eigen::internal::traits< SkylineProduct< LhsNested, RhsNested, ProductMode > > | |
| Eigen::internal::traits< solve_retval_base< DecompositionType, Rhs > > | |
| Eigen::internal::traits< solve_retval_with_guess< DecompositionType, Rhs, Guess > > | |
| Eigen::internal::traits< sparse_solve_retval_base< DecompositionType, Rhs > > | |
| Eigen::internal::traits< SparseDenseOuterProduct< Lhs, Rhs, Tr > > | |
| Eigen::internal::traits< SparseDiagonalProduct< Lhs, Rhs > > | |
| Eigen::internal::traits< SparseMatrix< _Scalar, _Options, _Index > > | |
| Eigen::internal::traits< SparseQR_QProduct< SparseQRType, Derived > > | |
| Eigen::internal::traits< SparseQRMatrixQReturnType< SparseQRType > > | |
| Eigen::internal::traits< SparseQRMatrixQTransposeReturnType< SparseQRType > > | |
| Eigen::internal::traits< SparseSelfAdjointTimeDenseProduct< Lhs, Rhs, UpLo > > | |
| Eigen::internal::traits< SparseSelfAdjointView< MatrixType, UpLo > > | |
| Eigen::internal::traits< SparseSparseProduct< LhsNested, RhsNested > > | |
| Eigen::internal::traits< SparseSymmetricPermutationProduct< MatrixType, UpLo > > | |
| Eigen::internal::traits< SparseTimeDenseProduct< Lhs, Rhs > > | |
| Eigen::internal::traits< SparseTriangularView< MatrixType, Mode > > | |
| Eigen::internal::traits< SparseVector< _Scalar, _Options, _Index > > | |
| Eigen::internal::traits< SparseView< MatrixType > > | |
| Eigen::internal::traits< SPQR_QProduct< SPQRType, Derived > > | |
| Eigen::internal::traits< SPQRMatrixQReturnType< SPQRType > > | |
| Eigen::internal::traits< SPQRMatrixQTransposeReturnType< SPQRType > > | |
| Eigen::internal::traits< SwapWrapper< ExpressionType > > | |
| Eigen::internal::traits< Transpose< MatrixType > > | |
| Eigen::internal::traits< Transpose< PermutationBase< Derived > > > | |
| Eigen::internal::traits< transposition_matrix_product_retval< TranspositionType, MatrixType, Side, Transposed > > | |
| Eigen::internal::traits< Transpositions< SizeAtCompileTime, MaxSizeAtCompileTime, IndexType > > | |
| Eigen::internal::traits< TranspositionsWrapper< _IndicesType > > | |
| Eigen::internal::traits< triangular_solve_retval< Side, TriangularType, Rhs > > | |
| Eigen::internal::traits< TriangularProduct< Mode, LhsIsTriangular, Lhs, false, Rhs, false > > | |
| Eigen::internal::traits< TriangularProduct< Mode, LhsIsTriangular, Lhs, false, Rhs, true > > | |
| Eigen::internal::traits< TriangularProduct< Mode, LhsIsTriangular, Lhs, true, Rhs, false > > | |
| Eigen::internal::traits< TriangularView< MatrixType, _Mode > > | |
| Eigen::internal::traits< TridiagonalizationMatrixTReturnType< MatrixType > > | |
| Eigen::internal::traits< VectorBlock< VectorType, Size > > | |
| Eigen::internal::transfer_constness< T1, T2 > | |
| Eigen::Transform< _Scalar, _Dim > | Represents an homogeneous transformation in a N dimensional space |
| vcg::Transform | The base class for Trackball |
| Eigen::internal::transform_construct_from_matrix< Other, AffineCompact, Options, Dim, HDim, HDim, HDim > | |
| Eigen::internal::transform_construct_from_matrix< Other, Mode, Options, Dim, HDim, Dim, Dim > | |
| Eigen::internal::transform_construct_from_matrix< Other, Mode, Options, Dim, HDim, Dim, HDim > | |
| Eigen::internal::transform_construct_from_matrix< Other, Mode, Options, Dim, HDim, HDim, HDim > | |
| Eigen::internal::transform_left_product_impl< Other, AffineCompact, Options, Dim, HDim, Dim, HDim > | |
| Eigen::internal::transform_left_product_impl< Other, AffineCompact, Options, Dim, HDim, HDim, HDim > | |
| Eigen::internal::transform_left_product_impl< Other, Mode, Options, Dim, HDim, Dim, Dim > | |
| Eigen::internal::transform_left_product_impl< Other, Mode, Options, Dim, HDim, Dim, HDim > | |
| Eigen::internal::transform_left_product_impl< Other, Mode, Options, Dim, HDim, HDim, HDim > | |
| Eigen::internal::transform_make_affine< Mode > | |
| Eigen::internal::transform_make_affine< AffineCompact > | |
| Eigen::internal::transform_product_result< LhsMode, RhsMode > | |
| Eigen::internal::transform_right_product_impl< TransformType, MatrixType, 0 > | |
| Eigen::internal::transform_right_product_impl< TransformType, MatrixType, 1 > | |
| Eigen::internal::transform_right_product_impl< TransformType, MatrixType, 2 > | |
| Eigen::internal::transform_take_affine_part< TransformType > | |
| Eigen::internal::transform_take_affine_part< Transform< Scalar, Dim, AffineCompact, Options > > | |
| Eigen::internal::transform_traits< Transform > | |
| Eigen::internal::transform_transform_product_impl< Transform< Scalar, Dim, AffineCompact, LhsOptions >, Transform< Scalar, Dim, Projective, RhsOptions >, true > | |
| Eigen::internal::transform_transform_product_impl< Transform< Scalar, Dim, LhsMode, LhsOptions >, Transform< Scalar, Dim, RhsMode, RhsOptions >, false > | |
| Eigen::internal::transform_transform_product_impl< Transform< Scalar, Dim, LhsMode, LhsOptions >, Transform< Scalar, Dim, RhsMode, RhsOptions >, true > | |
| Eigen::internal::transform_transform_product_impl< Transform< Scalar, Dim, Projective, LhsOptions >, Transform< Scalar, Dim, AffineCompact, RhsOptions >, true > | |
| toyexample.Transformation | |
| glw::TransformFeedbackStream | |
| Collada::Tags::TranslateTag | |
| Eigen::Translation< _Scalar, _Dim > | Represents a translation transformation |
| Collada::Tags::TransparencyTag | |
| Collada::Tags::TransparentTag | |
| Eigen::Transpose< MatrixType > | Expression of the transpose of a matrix |
| Eigen::Transpose< PermutationBase< Derived > > | |
| Eigen::Transpose< TranspositionsBase< TranspositionsDerived > > | |
| Eigen::TransposeImpl< MatrixType, Dense > | |
| Eigen::TransposeImpl< MatrixType, Sparse > | |
| Eigen::internal::TransposeImpl_base< MatrixType, HasDirectAccess > | |
| Eigen::internal::TransposeImpl_base< MatrixType, false > | |
| Eigen::internal::transposition_matrix_product_retval< TranspositionType, MatrixType, Side, Transposed > | |
| Eigen::Transpositions< SizeAtCompileTime, MaxSizeAtCompileTime, IndexType > | Represents a sequence of transpositions (row/column interchange) |
| Eigen::TranspositionsBase< Derived > | |
| Eigen::TranspositionsWrapper< _IndicesType > | |
| TreeTest< Dim > | |
| vcg::Triangle2< SCALAR_TYPE > | |
| vcg::Triangle3< ScalarTriangleType > | |
| vcg::tri::TriMeshClipper< TRIMESHTYPE >::TriangleInfo | |
| Collada::Tags::TrianglesTag | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, Mode, UnrollCount, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, Lower, Dynamic, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, Mode, 0, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, SelfAdjoint|Lower, 0, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, SelfAdjoint|Lower, Dynamic, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, SelfAdjoint|Upper, 0, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, SelfAdjoint|Upper, Dynamic, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, StrictlyLower, Dynamic, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, StrictlyUpper, Dynamic, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, UnitLower, Dynamic, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, UnitUpper, Dynamic, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2, Upper, Dynamic, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2,(SelfAdjoint|Lower), UnrollCount, ClearOpposite > | |
| Eigen::internal::triangular_assignment_selector< Derived1, Derived2,(SelfAdjoint|Upper), UnrollCount, ClearOpposite > | |
| Eigen::internal::triangular_matrix_vector_product< Index, Mode, LhsScalar, ConjLhs, RhsScalar, ConjRhs, ColMajor, Version > | |
| Eigen::internal::triangular_matrix_vector_product< Index, Mode, LhsScalar, ConjLhs, RhsScalar, ConjRhs, RowMajor, Version > | |
| Eigen::internal::triangular_matrix_vector_product_trmv< Index, Mode, LhsScalar, ConjLhs, RhsScalar, ConjRhs, StorageOrder > | |
| Eigen::internal::triangular_solve_matrix< Scalar, Index, OnTheLeft, Mode, Conjugate, TriStorageOrder, ColMajor > | |
| Eigen::internal::triangular_solve_matrix< Scalar, Index, OnTheRight, Mode, Conjugate, TriStorageOrder, ColMajor > | |
| Eigen::internal::triangular_solve_matrix< Scalar, Index, Side, Mode, Conjugate, TriStorageOrder, RowMajor > | |
| Eigen::internal::triangular_solve_retval< Side, TriangularType, Rhs > | |
| Eigen::internal::triangular_solve_vector< LhsScalar, RhsScalar, Index, OnTheLeft, Mode, Conjugate, ColMajor > | |
| Eigen::internal::triangular_solve_vector< LhsScalar, RhsScalar, Index, OnTheLeft, Mode, Conjugate, RowMajor > | |
| Eigen::internal::triangular_solve_vector< LhsScalar, RhsScalar, Index, OnTheRight, Mode, Conjugate, StorageOrder > | |
| Eigen::internal::triangular_solver_selector< Lhs, Rhs, OnTheLeft, Mode, CompleteUnrolling, 1 > | |
| Eigen::internal::triangular_solver_selector< Lhs, Rhs, OnTheRight, Mode, CompleteUnrolling, 1 > | |
| Eigen::internal::triangular_solver_selector< Lhs, Rhs, Side, Mode, NoUnrolling, 1 > | |
| Eigen::internal::triangular_solver_selector< Lhs, Rhs, Side, Mode, NoUnrolling, Dynamic > | |
| Eigen::internal::triangular_solver_unroller< Lhs, Rhs, Mode, Index, Size, false > | |
| Eigen::internal::triangular_solver_unroller< Lhs, Rhs, Mode, Index, Size, true > | |
| Eigen::TriangularBase< Derived > | |
| Eigen::TriangularProduct< Mode, false, Lhs, true, Rhs, false > | |
| Eigen::TriangularProduct< Mode, LhsIsTriangular, Lhs, false, Rhs, false > | |
| Eigen::TriangularProduct< Mode, true, Lhs, false, Rhs, true > | |
| Eigen::TriangularView< _MatrixType, _Mode > | Base class for triangular part in a matrix |
| Eigen::MatrixBase< Derived >::TriangularViewReturnType< Mode > | |
| Eigen::internal::tribb_kernel< LhsScalar, RhsScalar, Index, mr, nr, ConjLhs, ConjRhs, UpLo > | |
| Eigen::Tridiagonalization< _MatrixType > | Tridiagonal decomposition of a selfadjoint matrix |
| Eigen::internal::tridiagonalization_inplace_selector< MatrixType, Size, IsComplex > | |
| Eigen::internal::tridiagonalization_inplace_selector< MatrixType, 1, IsComplex > | |
| Eigen::internal::tridiagonalization_inplace_selector< MatrixType, 3, false > | |
| Eigen::internal::TridiagonalizationMatrixTReturnType< MatrixType > | |
| Eigen::internal::TridiagonalMatrix< Scalar, Size, Options > | Represents a tridiagonal matrix with a compact banded storage |
| vcg::tri::TriEdgeCollapse< TriMeshType, VertexPair, MYTYPE > | |
| vcg::tri::TriEdgeCollapseQuadric< TriMeshType, VertexPair, MYTYPE, HelperType > | |
| vcg::tri::TriEdgeCollapseQuadricParameter | |
| vcg::tri::TriEdgeCollapseQuadricTex< TriMeshType, VertexPair, MYTYPE, HelperType > | |
| vcg::tri::TriEdgeCollapseQuadricTexParameter | |
| vcg::tri::TriEdgeFlip< TRIMESH_TYPE, MYTYPE > | |
| vcg::tri::TriMesh< Container0, Container1, Container2, Container3 > | The official mesh class |
| vcg::tri::TriMeshClipper< TRIMESHTYPE > | |
| Eigen::Triplet< Scalar, Index > | A small structure to hold a non zero as a triplet (i,j,value) |
| vcg::tri::TriRayIterator< GRID, MESH > | |
| vcg::tri::TriSplit< TRIMESH_TYPE, CenterPoint > | Triangle split Simple templated function for splitting a triangle with a internal point. It can be templated on a CenterPoint class that is used to generate the position of the internal point |
| vcg::tri::TrivialEar< MESH > | |
| vcg::tri::TrivialPointerSampler< MeshType > | |
| vcg::tri::TrivialSampler< MeshType > | A basic sampler class that show the required interface used by the SurfaceSampling class |
| vcg::tri::TrivialWalker< MeshType, VolumeType > | |
| Eigen::internal::trmv_selector< ColMajor > | |
| Eigen::internal::trmv_selector< RowMajor > | |
| Eigen::internal::trsolve_traits< Lhs, Rhs, Side > | |
| Eigen::internal::true_type | |
| TsaiCorrelation | |
| TsaiMethods | |
| TT | |
| vcg::tetra::TTAdj< T > | |
| TUsedTypes | |
| TVertex | |
| type | |
| Eigen::internal::umeyama_transform_matrix_type< MatrixType, OtherMatrixType > | |
| Eigen::internal::umfpack_helper_is_sparse_plain< T > | |
| Eigen::internal::umfpack_helper_is_sparse_plain< MappedSparseMatrix< Scalar, Options, StorageIndex > > | |
| Eigen::internal::umfpack_helper_is_sparse_plain< SparseMatrix< Scalar, Options, StorageIndex > > | |
| Eigen::UmfPackLU< _MatrixType > | A sparse LU factorization and solver based on UmfPack |
| Eigen::internal::unaligned_assign_impl< IsAligned > | |
| Eigen::internal::unaligned_assign_impl< false > | |
| unary_function | |
| Eigen::internal::unary_result_of_select< Func, ArgType, SizeOf > | |
| Eigen::internal::unary_result_of_select< Func, ArgType, sizeof(has_std_result_type)> | |
| Eigen::internal::unary_result_of_select< Func, ArgType, sizeof(has_tr1_result)> | |
| glw::UniformBufferBindingParams | |
| vcg::PerfectSpatialHashing< OBJECT_TYPE, SCALAR_TYPE >::UniformGrid | |
| glw::Program::UniformInfo | |
| SplatRenderer< MeshType >::UniformParameters | |
| Eigen::UniformScaling< _Scalar > | |
| Eigen::internal::unitOrthogonal_selector< Derived, Size > | |
| Eigen::internal::unitOrthogonal_selector< Derived, 2 > | |
| Eigen::internal::unitOrthogonal_selector< Derived, 3 > | |
| Eigen::internal::unpacket_traits< T > | |
| Eigen::internal::unpacket_traits< Packet1cd > | |
| Eigen::internal::unpacket_traits< Packet2cf > | |
| Eigen::internal::unpacket_traits< Packet2d > | |
| Eigen::internal::unpacket_traits< Packet4f > | |
| Eigen::internal::unpacket_traits< Packet4i > | |
| Eigen::ReturnByValue< Derived >::Unusable | |
| Collada::Tags::UpAxisTag | |
| vcg::MT< C >::Update | |
| vcg::tri::UpdateBounding< ComputeMeshType > | This class is used to compute or update the bounding box of a mesh. |
| vcg::tri::UpdateColor< MeshType > | Generation and processing of per-vertex and per-face colors according to various strategy |
| vcg::tri::UpdateComponentEP< ComputeMeshType > | This class is used to compute or update the precomputed data used to efficiently compute point-face distances |
| vcg::tri::UpdateCurvature< MeshType > | Management, updating and computation of per-vertex and per-face normals |
| vcg::tri::UpdateCurvatureFitting< MeshType > | Computation of per-vertex directions and values of curvature |
| vcg::tri::UpdateFlags< UpdateMeshType > | Management, updating and computation of per-vertex and per-face flags (like border flags) |
| vcg::tri::UpdateHalfEdges< MeshType > | This class is used to build edge based data structure from indexed data structure and viceversa |
| vcg::tri::UpdateIndexed< MeshType > | |
| vcg::tri::UpdateNormal< ComputeMeshType > | Management, updating and computation of per-vertex, per-face, and per-wedge normals |
| vcg::tri::UpdatePosition< ComputeMeshType > | This class is used to update vertex position according to a transformation matrix |
| vcg::tri::UpdateQuality< UpdateMeshType > | Generation of per-vertex and per-face qualities |
| vcg::tri::UpdateSelection< ComputeMeshType > | Management, updating and conditional computation of selections (per-vertex, per-edge, and per-face) |
| vcg::tri::UpdateTexture< ComputeMeshType > | This class is used to update/generate texcoord position according to various critera. |
| vcg::tri::UpdateTopology< UpdateMeshType > | Generation of per-vertex and per-face topological information |
| Eigen::internal::UpperBidiagonalization< _MatrixType > | |
| vcg::Use< A > | |
| UsedTypes | |
| vcg::UsedTypes< A, B, C, D, E, F, G, H > | |
| vcg::tri::io::UtilDAE | |
| vcg::tri::UV_Utils< MeshType > | |
| vcg::tri::DummyContainer::value_type | |
| ValueNode | |
| Eigen::internal::variable_if_dynamic< T, Value > | |
| Eigen::internal::variable_if_dynamic< T, Dynamic > | |
| Eigen::internal::variable_if_dynamicindex< T, Value > | |
| Eigen::internal::variable_if_dynamicindex< T, DynamicIndex > | |
| ImporterFBX< OpenMeshType >::VCGMaterialBridge | |
| vcg::vertex::VEAdj< T > | Component: Per vertex Vertex-Edge adjacency relation It stores a pointer to the first Edge of a list edges that is stored in a distributed way on the edges themselves |
| vcg::edge::VEAdj< T > | Component: Per vertex Vertex-Edge adjacency relation companion component This component implement one element of the list of edges incident on a vertex. You must use this component only toghether with the corresponding vcg::vertex::VEAdj component in the vertex type |
| vector | |
| std::vector< T, EIGEN_ALIGNED_ALLOCATOR< T > > | |
| Eigen::internal::vector_int_pair< Scalar, Dim > | |
| vcg::vector_occ< VALUE_TYPE > | |
| vcg::face::vector_ocf< VALUE_TYPE > | |
| vcg::vertex::vector_ocf< VALUE_TYPE > | |
| Eigen::VectorBlock< VectorType, Size > | Expression of a fixed-size or dynamic-size sub-vector |
| Eigen::KdBVH< _Scalar, _Dim, _Object >::VectorComparator | |
| vcg::VectorConstDataWrapper< StdVectorType > | |
| vcg::VectorNBW< TYPE > | |
| vcg::VectorNBW< bool > | |
| VectorType< EigenVectorContainer, Scalar > | |
| VectorType< StdVectorContainer, Scalar > | |
| Eigen::VectorwiseOp< ExpressionType, Direction > | Pseudo expression providing partial reduction operations |
| vcg::edge::VEIterator< EdgeType > | |
| vcg::tri::Geodesic< MeshType >::VertDist | |
| vcg::Vertex< UserTypes, A, B, C, D, E, F, G, H, I, J, K, L > | |
| Vertex | |
| vcg::VertexArityMax< UserTypes, A, B, C, D, E, F, G, H, I, J, K, L > | |
| glw::VertexAttributeBinding | |
| glw::VertexBufferBindingParams | |
| vcg::tri::TriMeshClipper< TRIMESHTYPE >::VertexClipInfo< ScalarType > | |
| vcg::VertexConstDataWrapper< MeshType > | |
| vcg::tri::UpdateIndexed< MeshType >::VertexPairEdgePtr | |
| vcg::tri::UpdateHalfEdges< MeshType >::VertexPairEdgePtr | |
| OverlapEstimation< MESH_TYPE >::VertexPointerSampler | |
| vcg::tetra::VertexRef< T > | |
| vcg::edge::VertexRef< T > | The references to the two vertexes of a edge |
| vcg::face::VertexRef< T > | The references to the vertexes of a triangular face |
| vcg::face::VertexRefOcc< T > | |
| VertexShader | |
| glw::VertexShader | |
| glw::VertexShaderArguments | |
| glw::VertexShaderBindingParams | |
| vcg::edge::VertexStar< EDGETYPE > | |
| vcg::VertexVisShader< MESH_TYPE > | |
| Collada::Tags::VerticesTag | |
| vcg::tri::VertReg< MeshType > | Priority based on maximizing vertices regularity |
| vcg::GLW::VertToSplit< MeshType > | |
| vcg::face::VFAdj< T > | Component: Per Face Vertex-Face adjacency relation |
| vcg::vertex::VFAdj< T > | Component: Per vertex Vertex-Face adjacency relation |
| vcg::face::VFAdjOcc< T > | |
| vcg::vertex::VFAdjOcc< T > | *----------------------------- VFADJ ------------------------------*/ |
| vcg::face::VFAdjOccBase< A, T > | |
| vcg::face::VFAdjOcf< T > | |
| vcg::vertex::VFAdjOcf< T > | |
| vcg::vertex::vector_ocf< VALUE_TYPE >::VFAdjType | |
| vcg::face::VFAdjTypeSup< FP > | |
| vcg::face::VFIterator< FaceType > | |
| vcg::AABBBinaryTreeFrustumCull< TREETYPE >::VFrustum | |
| vcg::AABBBinaryTreeFrustumCull< TREETYPE >::VFrustumPlane | |
| vcg::vertex::VHAdj< T > | |
| vcg::View< T > | |
| Eigen::internal::visitor_impl< Visitor, Derived, UnrollCount > | |
| Eigen::internal::visitor_impl< Visitor, Derived, 1 > | |
| Eigen::internal::visitor_impl< Visitor, Derived, Dynamic > | |
| vcg::VisShader< MESH_TYPE, MAXVIS > | |
| Collada::Tags::VisualSceneTag | |
| Eigen::internal::vml_assign_impl< Derived1, Derived2, UnaryOp, Traversal, Unrolling, VmlTraversal > | |
| Eigen::internal::vml_assign_impl< Derived1, Derived2, UnaryOp, Traversal, Unrolling, InnerVectorizedTraversal > | |
| Eigen::internal::vml_assign_impl< Derived1, Derived2, UnaryOp, Traversal, Unrolling, LinearVectorizedTraversal > | |
| Eigen::internal::vml_assign_traits< Dst, Src, UnaryOp > | |
| Eigen::internal::vml_call< Op > | |
| vcg::VoidType | Type that stands for "void". Useful for Parameter type of a point |
| Volume | |
| vcg::tri::VoronoiAtlas< MeshType >::VoroEdge | |
| vcg::tri::VoronoiAtlas< MeshType >::VoroFace | |
| vcg::tri::VoronoiAtlas< MeshType >::VoroMesh | |
| vcg::tri::VoronoiAtlas< MeshType > | |
| vcg::tri::VoronoiAtlas< MeshType >::VoronoiAtlasParam | |
| vcg::tri::VoronoiProcessing< MeshType, DistanceFunctor >::VoronoiEdge | |
| vcg::tri::VoronoiProcessing< MeshType, DistanceFunctor > | |
| vcg::tri::VoronoiProcessingParameter | |
| vcg::tri::VoronoiVolumeSampling< MeshType > | |
| vcg::tri::VoronoiAtlas< MeshType >::VoroUsedTypes | |
| VoroUsedTypes | |
| vcg::tri::VoronoiAtlas< MeshType >::VoroVertex | |
| vcg::Voxel | |
| vcg::tetra::VTAdj< T > | |
| vcg::vertex::VTAdj< T > | |
| vcg::tetra::VTIterator< MTTYPE > | |
| vcg::tri::Resampler< OldMeshType, NewMeshType, DISTFUNCTOR >::Walker | |
| Walker | |
| vcg::tri::PointCloudNormal< MeshType >::WArc | |
| vcg::tri::io::UtilDAE::WedgeAttribute | |
| vcg::face::WedgeColor< A, T > | |
| vcg::face::WedgeColor4b< T > | |
| vcg::face::WedgeColor4bOcf< T > | |
| vcg::face::WedgeColor4f< T > | |
| vcg::face::WedgeColorOcf< A, TT > | *-------------------------- WEDGE COLOR ----------------------------------*/ |
| vcg::face::vector_ocf< VALUE_TYPE >::WedgeColorTypePack | |
| vcg::face::WedgeNormal< T > | |
| vcg::face::WedgeNormal3dOcf< T > | |
| vcg::face::WedgeNormal3fOcf< T > | |
| vcg::face::WedgeNormal3sOcf< T > | |
| vcg::face::WedgeNormalOcf< A, TT > | *-------------------------- WEDGE NORMAL ----------------------------------*/ |
| vcg::face::vector_ocf< VALUE_TYPE >::WedgeNormalTypePack | |
| vcg::face::WedgeRealNormal< A, T > | |
| vcg::face::WedgeRealNormal3d< TT > | |
| vcg::face::WedgeRealNormal3f< TT > | |
| vcg::face::WedgeRealNormal3s< TT > | |
| vcg::face::WedgeTexCoord< A, T > | |
| vcg::face::WedgeTexCoord2d< TT > | |
| vcg::face::WedgeTexCoord2f< TT > | |
| vcg::face::WedgeTexCoord2s< TT > | |
| vcg::face::WedgeTexCoordfOcc< T > | |
| vcg::face::WedgeTexCoordfOcf< T > | |
| vcg::face::WedgeTexCoordOcc< A, T > | *-------------------------- WedgeTexCoordOcc ----------------------------------------*/ |
| vcg::face::WedgeTexCoordOcf< A, TT > | *-------------------------- WEDGE TEXCOORD ----------------------------------*/ |
| vcg::face::vector_ocf< VALUE_TYPE >::WedgeTexTypePack | |
| vcg::tri::Hole< MESH >::Weight | |
| Window | |
| Eigen::WithFormat< ExpressionType > | Pseudo expression providing matrix output with given format |
| Eigen::NumTraits< T >::wrong_type | |
| XMLDocument | |
| XMLDocumentWriter | |
| XMLInteriorNode | |
| XMLLeafNode | |
| XMLLeafTag | |
| XMLNode | |
| XMLTag | |
| XMLTree | |
| XMLVisitor | |
| vcg::ZMode | The Z-directional manipulator |
| vcg::tri::Zonohedron< Scalar > | |