From f0238cfb6997c4acfc2bd200de7295f3fa36968f Mon Sep 17 00:00:00 2001 From: Stanislaw Halik Date: Sun, 3 Mar 2019 21:09:10 +0100 Subject: don't index Eigen --- eigen/Eigen/src/Geometry/Homogeneous.h | 497 --------------------------------- 1 file changed, 497 deletions(-) delete mode 100644 eigen/Eigen/src/Geometry/Homogeneous.h (limited to 'eigen/Eigen/src/Geometry/Homogeneous.h') diff --git a/eigen/Eigen/src/Geometry/Homogeneous.h b/eigen/Eigen/src/Geometry/Homogeneous.h deleted file mode 100644 index 5f0da1a..0000000 --- a/eigen/Eigen/src/Geometry/Homogeneous.h +++ /dev/null @@ -1,497 +0,0 @@ -// This file is part of Eigen, a lightweight C++ template library -// for linear algebra. -// -// Copyright (C) 2009-2010 Gael Guennebaud -// -// This Source Code Form is subject to the terms of the Mozilla -// Public License v. 2.0. If a copy of the MPL was not distributed -// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. - -#ifndef EIGEN_HOMOGENEOUS_H -#define EIGEN_HOMOGENEOUS_H - -namespace Eigen { - -/** \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 ref_selector::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 - }; -}; - -template struct homogeneous_left_product_impl; -template struct homogeneous_right_product_impl; - -} // end namespace internal - -template class Homogeneous - : public MatrixBase >, internal::no_assignment_operator -{ - public: - - typedef MatrixType NestedExpression; - enum { Direction = _Direction }; - - typedef MatrixBase Base; - EIGEN_DENSE_PUBLIC_INTERFACE(Homogeneous) - - EIGEN_DEVICE_FUNC explicit inline Homogeneous(const MatrixType& matrix) - : m_matrix(matrix) - {} - - EIGEN_DEVICE_FUNC inline Index rows() const { return m_matrix.rows() + (int(Direction)==Vertical ? 1 : 0); } - EIGEN_DEVICE_FUNC inline Index cols() const { return m_matrix.cols() + (int(Direction)==Horizontal ? 1 : 0); } - - EIGEN_DEVICE_FUNC const NestedExpression& nestedExpression() const { return m_matrix; } - - template - EIGEN_DEVICE_FUNC inline const Product - operator* (const MatrixBase& rhs) const - { - eigen_assert(int(Direction)==Horizontal); - return Product(*this,rhs.derived()); - } - - template friend - EIGEN_DEVICE_FUNC inline const Product - operator* (const MatrixBase& lhs, const Homogeneous& rhs) - { - eigen_assert(int(Direction)==Vertical); - return Product(lhs.derived(),rhs); - } - - template friend - EIGEN_DEVICE_FUNC inline const Product, Homogeneous > - operator* (const Transform& lhs, const Homogeneous& rhs) - { - eigen_assert(int(Direction)==Vertical); - return Product, Homogeneous>(lhs,rhs); - } - - template - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::result_of::type - redux(const Func& func) const - { - return func(m_matrix.redux(func), Scalar(1)); - } - - protected: - typename MatrixType::Nested m_matrix; -}; - -/** \geometry_module \ingroup Geometry_Module - * - * \returns a vector expression that is one longer than the vector argument, with the value 1 symbolically appended as the last coefficient. - * - * This can be used to convert affine coordinates to homogeneous coordinates. - * - * \only_for_vectors - * - * Example: \include MatrixBase_homogeneous.cpp - * Output: \verbinclude MatrixBase_homogeneous.out - * - * \sa VectorwiseOp::homogeneous(), class Homogeneous - */ -template -EIGEN_DEVICE_FUNC inline typename MatrixBase::HomogeneousReturnType -MatrixBase::homogeneous() const -{ - EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived); - return HomogeneousReturnType(derived()); -} - -/** \geometry_module \ingroup Geometry_Module - * - * \returns an expression where the value 1 is symbolically appended as the final coefficient to each column (or row) of the matrix. - * - * This can be used to convert affine coordinates to homogeneous coordinates. - * - * Example: \include VectorwiseOp_homogeneous.cpp - * Output: \verbinclude VectorwiseOp_homogeneous.out - * - * \sa MatrixBase::homogeneous(), class Homogeneous */ -template -EIGEN_DEVICE_FUNC inline Homogeneous -VectorwiseOp::homogeneous() const -{ - return HomogeneousReturnType(_expression()); -} - -/** \geometry_module \ingroup Geometry_Module - * - * \brief homogeneous normalization - * - * \returns a vector expression of the N-1 first coefficients of \c *this divided by that last coefficient. - * - * This can be used to convert homogeneous coordinates to affine coordinates. - * - * It is essentially a shortcut for: - * \code - this->head(this->size()-1)/this->coeff(this->size()-1); - \endcode - * - * Example: \include MatrixBase_hnormalized.cpp - * Output: \verbinclude MatrixBase_hnormalized.out - * - * \sa VectorwiseOp::hnormalized() */ -template -EIGEN_DEVICE_FUNC 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 \ingroup Geometry_Module - * - * \brief column or row-wise homogeneous normalization - * - * \returns an expression of the first N-1 coefficients of each column (or row) of \c *this divided by the last coefficient of each column (or row). - * - * This can be used to convert homogeneous coordinates to affine coordinates. - * - * It is conceptually equivalent to calling MatrixBase::hnormalized() to each column (or row) of \c *this. - * - * Example: \include DirectionWise_hnormalized.cpp - * Output: \verbinclude DirectionWise_hnormalized.out - * - * \sa MatrixBase::hnormalized() */ -template -EIGEN_DEVICE_FUNC 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; - EIGEN_DEVICE_FUNC static const type& run(const type &x) { return x; } -}; - -template -struct take_matrix_for_product > -{ - typedef Transform TransformType; - typedef typename internal::add_const::type type; - EIGEN_DEVICE_FUNC static type run (const TransformType& x) { return x.affine(); } -}; - -template -struct take_matrix_for_product > -{ - typedef Transform TransformType; - typedef typename TransformType::MatrixType type; - EIGEN_DEVICE_FUNC 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; - EIGEN_DEVICE_FUNC homogeneous_left_product_impl(const Lhs& lhs, const MatrixType& rhs) - : m_lhs(take_matrix_for_product::run(lhs)), - m_rhs(rhs) - {} - - EIGEN_DEVICE_FUNC inline Index rows() const { return m_lhs.rows(); } - EIGEN_DEVICE_FUNC inline Index cols() const { return m_rhs.cols(); } - - template EIGEN_DEVICE_FUNC 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()); - } - - typename LhsMatrixTypeCleaned::Nested m_lhs; - 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; - EIGEN_DEVICE_FUNC homogeneous_right_product_impl(const MatrixType& lhs, const Rhs& rhs) - : m_lhs(lhs), m_rhs(rhs) - {} - - EIGEN_DEVICE_FUNC inline Index rows() const { return m_lhs.rows(); } - EIGEN_DEVICE_FUNC inline Index cols() const { return m_rhs.cols(); } - - template EIGEN_DEVICE_FUNC 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()); - } - - typename MatrixType::Nested m_lhs; - typename Rhs::Nested m_rhs; -}; - -template -struct evaluator_traits > -{ - typedef typename storage_kind_to_evaluator_kind::Kind Kind; - typedef HomogeneousShape Shape; -}; - -template<> struct AssignmentKind { typedef Dense2Dense Kind; }; - - -template -struct unary_evaluator, IndexBased> - : evaluator::PlainObject > -{ - typedef Homogeneous XprType; - typedef typename XprType::PlainObject PlainObject; - typedef evaluator Base; - - EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op) - : Base(), m_temp(op) - { - ::new (static_cast(this)) Base(m_temp); - } - -protected: - PlainObject m_temp; -}; - -// dense = homogeneous -template< typename DstXprType, typename ArgType, typename Scalar> -struct Assignment, internal::assign_op, Dense2Dense> -{ - typedef Homogeneous SrcXprType; - EIGEN_DEVICE_FUNC static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op &) - { - Index dstRows = src.rows(); - Index dstCols = src.cols(); - if((dst.rows()!=dstRows) || (dst.cols()!=dstCols)) - dst.resize(dstRows, dstCols); - - dst.template topRows(src.nestedExpression().rows()) = src.nestedExpression(); - dst.row(dst.rows()-1).setOnes(); - } -}; - -// dense = homogeneous -template< typename DstXprType, typename ArgType, typename Scalar> -struct Assignment, internal::assign_op, Dense2Dense> -{ - typedef Homogeneous SrcXprType; - EIGEN_DEVICE_FUNC static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op &) - { - Index dstRows = src.rows(); - Index dstCols = src.cols(); - if((dst.rows()!=dstRows) || (dst.cols()!=dstCols)) - dst.resize(dstRows, dstCols); - - dst.template leftCols(src.nestedExpression().cols()) = src.nestedExpression(); - dst.col(dst.cols()-1).setOnes(); - } -}; - -template -struct generic_product_impl, Rhs, HomogeneousShape, DenseShape, ProductTag> -{ - template - EIGEN_DEVICE_FUNC static void evalTo(Dest& dst, const Homogeneous& lhs, const Rhs& rhs) - { - homogeneous_right_product_impl, Rhs>(lhs.nestedExpression(), rhs).evalTo(dst); - } -}; - -template -struct homogeneous_right_product_refactoring_helper -{ - enum { - Dim = Lhs::ColsAtCompileTime, - Rows = Lhs::RowsAtCompileTime - }; - typedef typename Rhs::template ConstNRowsBlockXpr::Type LinearBlockConst; - typedef typename remove_const::type LinearBlock; - typedef typename Rhs::ConstRowXpr ConstantColumn; - typedef Replicate ConstantBlock; - typedef Product LinearProduct; - typedef CwiseBinaryOp, const LinearProduct, const ConstantBlock> Xpr; -}; - -template -struct product_evaluator, ProductTag, HomogeneousShape, DenseShape> - : public evaluator::Xpr> -{ - typedef Product XprType; - typedef homogeneous_right_product_refactoring_helper helper; - typedef typename helper::ConstantBlock ConstantBlock; - typedef typename helper::Xpr RefactoredXpr; - typedef evaluator Base; - - EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr) - : Base( xpr.lhs().nestedExpression() .lazyProduct( xpr.rhs().template topRows(xpr.lhs().nestedExpression().cols()) ) - + ConstantBlock(xpr.rhs().row(xpr.rhs().rows()-1),xpr.lhs().rows(), 1) ) - {} -}; - -template -struct generic_product_impl, DenseShape, HomogeneousShape, ProductTag> -{ - template - EIGEN_DEVICE_FUNC static void evalTo(Dest& dst, const Lhs& lhs, const Homogeneous& rhs) - { - homogeneous_left_product_impl, Lhs>(lhs, rhs.nestedExpression()).evalTo(dst); - } -}; - -// TODO: the following specialization is to address a regression from 3.2 to 3.3 -// In the future, this path should be optimized. -template -struct generic_product_impl, TriangularShape, HomogeneousShape, ProductTag> -{ - template - static void evalTo(Dest& dst, const Lhs& lhs, const Homogeneous& rhs) - { - dst.noalias() = lhs * rhs.eval(); - } -}; - -template -struct homogeneous_left_product_refactoring_helper -{ - enum { - Dim = Rhs::RowsAtCompileTime, - Cols = Rhs::ColsAtCompileTime - }; - typedef typename Lhs::template ConstNColsBlockXpr::Type LinearBlockConst; - typedef typename remove_const::type LinearBlock; - typedef typename Lhs::ConstColXpr ConstantColumn; - typedef Replicate ConstantBlock; - typedef Product LinearProduct; - typedef CwiseBinaryOp, const LinearProduct, const ConstantBlock> Xpr; -}; - -template -struct product_evaluator, ProductTag, DenseShape, HomogeneousShape> - : public evaluator::Xpr> -{ - typedef Product XprType; - typedef homogeneous_left_product_refactoring_helper helper; - typedef typename helper::ConstantBlock ConstantBlock; - typedef typename helper::Xpr RefactoredXpr; - typedef evaluator Base; - - EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr) - : Base( xpr.lhs().template leftCols(xpr.rhs().nestedExpression().rows()) .lazyProduct( xpr.rhs().nestedExpression() ) - + ConstantBlock(xpr.lhs().col(xpr.lhs().cols()-1),1,xpr.rhs().cols()) ) - {} -}; - -template -struct generic_product_impl, Homogeneous, DenseShape, HomogeneousShape, ProductTag> -{ - typedef Transform TransformType; - template - EIGEN_DEVICE_FUNC static void evalTo(Dest& dst, const TransformType& lhs, const Homogeneous& rhs) - { - homogeneous_left_product_impl, TransformType>(lhs, rhs.nestedExpression()).evalTo(dst); - } -}; - -template -struct permutation_matrix_product - : public permutation_matrix_product -{}; - -} // end namespace internal - -} // end namespace Eigen - -#endif // EIGEN_HOMOGENEOUS_H -- cgit v1.2.3