From 4a04f7206914a49f5f95adc5eb786237f1a9f547 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Sun, 23 Oct 2011 17:52:20 +0000 Subject: remove $Id: tags after discussion on the mailign list: http://markmail.org/message/fp7ozcywxum3ar7n --- extern/Eigen3/Eigen/src/Geometry/Homogeneous.h | 318 +++++++++++++++++++++++++ 1 file changed, 318 insertions(+) create mode 100644 extern/Eigen3/Eigen/src/Geometry/Homogeneous.h (limited to 'extern/Eigen3/Eigen/src/Geometry/Homogeneous.h') diff --git a/extern/Eigen3/Eigen/src/Geometry/Homogeneous.h b/extern/Eigen3/Eigen/src/Geometry/Homogeneous.h new file mode 100644 index 00000000000..2bc4f7e87e3 --- /dev/null +++ b/extern/Eigen3/Eigen/src/Geometry/Homogeneous.h @@ -0,0 +1,318 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009-2010 Gael Guennebaud +// +// Eigen is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// Alternatively, you can redistribute it and/or +// modify it under the terms of the GNU General Public License as +// published by the Free Software Foundation; either version 2 of +// the License, or (at your option) any later version. +// +// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and a copy of the GNU General Public License along with +// Eigen. If not, see . + +#ifndef EIGEN_HOMOGENEOUS_H +#define EIGEN_HOMOGENEOUS_H + +/** \geometry_module \ingroup Geometry_Module + * + * \class Homogeneous + * + * \brief Expression of one (or a set of) homogeneous vector(s) + * + * \param MatrixType the type of the object in which we are making homogeneous + * + * This class represents an expression of one (or a set of) homogeneous vector(s). + * It is the return type of MatrixBase::homogeneous() and most of the time + * this is the only way it is used. + * + * \sa MatrixBase::homogeneous() + */ + +namespace internal { + +template +struct traits > + : traits +{ + typedef typename traits::StorageKind StorageKind; + typedef typename nested::type MatrixTypeNested; + typedef typename remove_reference::type _MatrixTypeNested; + enum { + RowsPlusOne = (MatrixType::RowsAtCompileTime != Dynamic) ? + int(MatrixType::RowsAtCompileTime) + 1 : Dynamic, + ColsPlusOne = (MatrixType::ColsAtCompileTime != Dynamic) ? + int(MatrixType::ColsAtCompileTime) + 1 : Dynamic, + RowsAtCompileTime = Direction==Vertical ? RowsPlusOne : MatrixType::RowsAtCompileTime, + ColsAtCompileTime = Direction==Horizontal ? ColsPlusOne : MatrixType::ColsAtCompileTime, + MaxRowsAtCompileTime = RowsAtCompileTime, + MaxColsAtCompileTime = ColsAtCompileTime, + TmpFlags = _MatrixTypeNested::Flags & HereditaryBits, + Flags = ColsAtCompileTime==1 ? (TmpFlags & ~RowMajorBit) + : RowsAtCompileTime==1 ? (TmpFlags | RowMajorBit) + : TmpFlags, + CoeffReadCost = _MatrixTypeNested::CoeffReadCost + }; +}; + +template struct homogeneous_left_product_impl; +template struct homogeneous_right_product_impl; + +} // end namespace internal + +template class Homogeneous + : public MatrixBase > +{ + public: + + enum { Direction = _Direction }; + + typedef MatrixBase Base; + EIGEN_DENSE_PUBLIC_INTERFACE(Homogeneous) + + inline Homogeneous(const MatrixType& matrix) + : m_matrix(matrix) + {} + + inline Index rows() const { return m_matrix.rows() + (int(Direction)==Vertical ? 1 : 0); } + inline Index cols() const { return m_matrix.cols() + (int(Direction)==Horizontal ? 1 : 0); } + + inline Scalar coeff(Index row, Index col) const + { + if( (int(Direction)==Vertical && row==m_matrix.rows()) + || (int(Direction)==Horizontal && col==m_matrix.cols())) + return 1; + return m_matrix.coeff(row, col); + } + + template + inline const internal::homogeneous_right_product_impl + operator* (const MatrixBase& rhs) const + { + eigen_assert(int(Direction)==Horizontal); + return internal::homogeneous_right_product_impl(m_matrix,rhs.derived()); + } + + template friend + inline const internal::homogeneous_left_product_impl + operator* (const MatrixBase& lhs, const Homogeneous& rhs) + { + eigen_assert(int(Direction)==Vertical); + return internal::homogeneous_left_product_impl(lhs.derived(),rhs.m_matrix); + } + + template friend + inline const internal::homogeneous_left_product_impl > + operator* (const Transform& lhs, const Homogeneous& rhs) + { + eigen_assert(int(Direction)==Vertical); + return internal::homogeneous_left_product_impl >(lhs,rhs.m_matrix); + } + + protected: + const typename MatrixType::Nested m_matrix; +}; + +/** \geometry_module + * + * \return an expression of the equivalent homogeneous vector + * + * \only_for_vectors + * + * Example: \include MatrixBase_homogeneous.cpp + * Output: \verbinclude MatrixBase_homogeneous.out + * + * \sa class Homogeneous + */ +template +inline typename MatrixBase::HomogeneousReturnType +MatrixBase::homogeneous() const +{ + EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived); + return derived(); +} + +/** \geometry_module + * + * \returns a matrix expression of homogeneous column (or row) vectors + * + * Example: \include VectorwiseOp_homogeneous.cpp + * Output: \verbinclude VectorwiseOp_homogeneous.out + * + * \sa MatrixBase::homogeneous() */ +template +inline Homogeneous +VectorwiseOp::homogeneous() const +{ + return _expression(); +} + +/** \geometry_module + * + * \returns an expression of the homogeneous normalized vector of \c *this + * + * Example: \include MatrixBase_hnormalized.cpp + * Output: \verbinclude MatrixBase_hnormalized.out + * + * \sa VectorwiseOp::hnormalized() */ +template +inline const typename MatrixBase::HNormalizedReturnType +MatrixBase::hnormalized() const +{ + EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived); + return ConstStartMinusOne(derived(),0,0, + ColsAtCompileTime==1?size()-1:1, + ColsAtCompileTime==1?1:size()-1) / coeff(size()-1); +} + +/** \geometry_module + * + * \returns an expression of the homogeneous normalized vector of \c *this + * + * Example: \include DirectionWise_hnormalized.cpp + * Output: \verbinclude DirectionWise_hnormalized.out + * + * \sa MatrixBase::hnormalized() */ +template +inline const typename VectorwiseOp::HNormalizedReturnType +VectorwiseOp::hnormalized() const +{ + return HNormalized_Block(_expression(),0,0, + Direction==Vertical ? _expression().rows()-1 : _expression().rows(), + Direction==Horizontal ? _expression().cols()-1 : _expression().cols()).cwiseQuotient( + Replicate + (HNormalized_Factors(_expression(), + Direction==Vertical ? _expression().rows()-1:0, + Direction==Horizontal ? _expression().cols()-1:0, + Direction==Vertical ? 1 : _expression().rows(), + Direction==Horizontal ? 1 : _expression().cols()), + Direction==Vertical ? _expression().rows()-1 : 1, + Direction==Horizontal ? _expression().cols()-1 : 1)); +} + +namespace internal { + +template +struct take_matrix_for_product +{ + typedef MatrixOrTransformType type; + static const type& run(const type &x) { return x; } +}; + +template +struct take_matrix_for_product > +{ + typedef Transform TransformType; + typedef typename TransformType::ConstAffinePart type; + static const type run (const TransformType& x) { return x.affine(); } +}; + +template +struct take_matrix_for_product > +{ + typedef Transform TransformType; + typedef typename TransformType::MatrixType type; + static const type& run (const TransformType& x) { return x.matrix(); } +}; + +template +struct traits,Lhs> > +{ + typedef typename take_matrix_for_product::type LhsMatrixType; + typedef typename remove_all::type MatrixTypeCleaned; + typedef typename remove_all::type LhsMatrixTypeCleaned; + typedef typename make_proper_matrix_type< + typename traits::Scalar, + LhsMatrixTypeCleaned::RowsAtCompileTime, + MatrixTypeCleaned::ColsAtCompileTime, + MatrixTypeCleaned::PlainObject::Options, + LhsMatrixTypeCleaned::MaxRowsAtCompileTime, + MatrixTypeCleaned::MaxColsAtCompileTime>::type ReturnType; +}; + +template +struct homogeneous_left_product_impl,Lhs> + : public ReturnByValue,Lhs> > +{ + typedef typename traits::LhsMatrixType LhsMatrixType; + typedef typename remove_all::type LhsMatrixTypeCleaned; + typedef typename remove_all::type LhsMatrixTypeNested; + typedef typename MatrixType::Index Index; + homogeneous_left_product_impl(const Lhs& lhs, const MatrixType& rhs) + : m_lhs(take_matrix_for_product::run(lhs)), + m_rhs(rhs) + {} + + inline Index rows() const { return m_lhs.rows(); } + inline Index cols() const { return m_rhs.cols(); } + + template void evalTo(Dest& dst) const + { + // FIXME investigate how to allow lazy evaluation of this product when possible + dst = Block + (m_lhs,0,0,m_lhs.rows(),m_lhs.cols()-1) * m_rhs; + dst += m_lhs.col(m_lhs.cols()-1).rowwise() + .template replicate(m_rhs.cols()); + } + + const typename LhsMatrixTypeCleaned::Nested m_lhs; + const typename MatrixType::Nested m_rhs; +}; + +template +struct traits,Rhs> > +{ + typedef typename make_proper_matrix_type::Scalar, + MatrixType::RowsAtCompileTime, + Rhs::ColsAtCompileTime, + MatrixType::PlainObject::Options, + MatrixType::MaxRowsAtCompileTime, + Rhs::MaxColsAtCompileTime>::type ReturnType; +}; + +template +struct homogeneous_right_product_impl,Rhs> + : public ReturnByValue,Rhs> > +{ + typedef typename remove_all::type RhsNested; + typedef typename MatrixType::Index Index; + homogeneous_right_product_impl(const MatrixType& lhs, const Rhs& rhs) + : m_lhs(lhs), m_rhs(rhs) + {} + + inline Index rows() const { return m_lhs.rows(); } + inline Index cols() const { return m_rhs.cols(); } + + template void evalTo(Dest& dst) const + { + // FIXME investigate how to allow lazy evaluation of this product when possible + dst = m_lhs * Block + (m_rhs,0,0,m_rhs.rows()-1,m_rhs.cols()); + dst += m_rhs.row(m_rhs.rows()-1).colwise() + .template replicate(m_lhs.rows()); + } + + const typename MatrixType::Nested m_lhs; + const typename Rhs::Nested m_rhs; +}; + +} // end namespace internal + +#endif // EIGEN_HOMOGENEOUS_H -- cgit v1.2.3