Homogeneous.h (20726B)
1 // This file is part of Eigen, a lightweight C++ template library 2 // for linear algebra. 3 // 4 // Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr> 5 // 6 // This Source Code Form is subject to the terms of the Mozilla 7 // Public License v. 2.0. If a copy of the MPL was not distributed 8 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 10 #ifndef EIGEN_HOMOGENEOUS_H 11 #define EIGEN_HOMOGENEOUS_H 12 13 namespace Eigen { 14 15 /** \geometry_module \ingroup Geometry_Module 16 * 17 * \class Homogeneous 18 * 19 * \brief Expression of one (or a set of) homogeneous vector(s) 20 * 21 * \param MatrixType the type of the object in which we are making homogeneous 22 * 23 * This class represents an expression of one (or a set of) homogeneous vector(s). 24 * It is the return type of MatrixBase::homogeneous() and most of the time 25 * this is the only way it is used. 26 * 27 * \sa MatrixBase::homogeneous() 28 */ 29 30 namespace internal { 31 32 template<typename MatrixType,int Direction> 33 struct traits<Homogeneous<MatrixType,Direction> > 34 : traits<MatrixType> 35 { 36 typedef typename traits<MatrixType>::StorageKind StorageKind; 37 typedef typename ref_selector<MatrixType>::type MatrixTypeNested; 38 typedef typename remove_reference<MatrixTypeNested>::type _MatrixTypeNested; 39 enum { 40 RowsPlusOne = (MatrixType::RowsAtCompileTime != Dynamic) ? 41 int(MatrixType::RowsAtCompileTime) + 1 : Dynamic, 42 ColsPlusOne = (MatrixType::ColsAtCompileTime != Dynamic) ? 43 int(MatrixType::ColsAtCompileTime) + 1 : Dynamic, 44 RowsAtCompileTime = Direction==Vertical ? RowsPlusOne : MatrixType::RowsAtCompileTime, 45 ColsAtCompileTime = Direction==Horizontal ? ColsPlusOne : MatrixType::ColsAtCompileTime, 46 MaxRowsAtCompileTime = RowsAtCompileTime, 47 MaxColsAtCompileTime = ColsAtCompileTime, 48 TmpFlags = _MatrixTypeNested::Flags & HereditaryBits, 49 Flags = ColsAtCompileTime==1 ? (TmpFlags & ~RowMajorBit) 50 : RowsAtCompileTime==1 ? (TmpFlags | RowMajorBit) 51 : TmpFlags 52 }; 53 }; 54 55 template<typename MatrixType,typename Lhs> struct homogeneous_left_product_impl; 56 template<typename MatrixType,typename Rhs> struct homogeneous_right_product_impl; 57 58 } // end namespace internal 59 60 template<typename MatrixType,int _Direction> class Homogeneous 61 : public MatrixBase<Homogeneous<MatrixType,_Direction> >, internal::no_assignment_operator 62 { 63 public: 64 65 typedef MatrixType NestedExpression; 66 enum { Direction = _Direction }; 67 68 typedef MatrixBase<Homogeneous> Base; 69 EIGEN_DENSE_PUBLIC_INTERFACE(Homogeneous) 70 71 EIGEN_DEVICE_FUNC explicit inline Homogeneous(const MatrixType& matrix) 72 : m_matrix(matrix) 73 {} 74 75 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR 76 inline Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows() + (int(Direction)==Vertical ? 1 : 0); } 77 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR 78 inline Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols() + (int(Direction)==Horizontal ? 1 : 0); } 79 80 EIGEN_DEVICE_FUNC const NestedExpression& nestedExpression() const { return m_matrix; } 81 82 template<typename Rhs> 83 EIGEN_DEVICE_FUNC inline const Product<Homogeneous,Rhs> 84 operator* (const MatrixBase<Rhs>& rhs) const 85 { 86 eigen_assert(int(Direction)==Horizontal); 87 return Product<Homogeneous,Rhs>(*this,rhs.derived()); 88 } 89 90 template<typename Lhs> friend 91 EIGEN_DEVICE_FUNC inline const Product<Lhs,Homogeneous> 92 operator* (const MatrixBase<Lhs>& lhs, const Homogeneous& rhs) 93 { 94 eigen_assert(int(Direction)==Vertical); 95 return Product<Lhs,Homogeneous>(lhs.derived(),rhs); 96 } 97 98 template<typename Scalar, int Dim, int Mode, int Options> friend 99 EIGEN_DEVICE_FUNC inline const Product<Transform<Scalar,Dim,Mode,Options>, Homogeneous > 100 operator* (const Transform<Scalar,Dim,Mode,Options>& lhs, const Homogeneous& rhs) 101 { 102 eigen_assert(int(Direction)==Vertical); 103 return Product<Transform<Scalar,Dim,Mode,Options>, Homogeneous>(lhs,rhs); 104 } 105 106 template<typename Func> 107 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::result_of<Func(Scalar,Scalar)>::type 108 redux(const Func& func) const 109 { 110 return func(m_matrix.redux(func), Scalar(1)); 111 } 112 113 protected: 114 typename MatrixType::Nested m_matrix; 115 }; 116 117 /** \geometry_module \ingroup Geometry_Module 118 * 119 * \returns a vector expression that is one longer than the vector argument, with the value 1 symbolically appended as the last coefficient. 120 * 121 * This can be used to convert affine coordinates to homogeneous coordinates. 122 * 123 * \only_for_vectors 124 * 125 * Example: \include MatrixBase_homogeneous.cpp 126 * Output: \verbinclude MatrixBase_homogeneous.out 127 * 128 * \sa VectorwiseOp::homogeneous(), class Homogeneous 129 */ 130 template<typename Derived> 131 EIGEN_DEVICE_FUNC inline typename MatrixBase<Derived>::HomogeneousReturnType 132 MatrixBase<Derived>::homogeneous() const 133 { 134 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived); 135 return HomogeneousReturnType(derived()); 136 } 137 138 /** \geometry_module \ingroup Geometry_Module 139 * 140 * \returns an expression where the value 1 is symbolically appended as the final coefficient to each column (or row) of the matrix. 141 * 142 * This can be used to convert affine coordinates to homogeneous coordinates. 143 * 144 * Example: \include VectorwiseOp_homogeneous.cpp 145 * Output: \verbinclude VectorwiseOp_homogeneous.out 146 * 147 * \sa MatrixBase::homogeneous(), class Homogeneous */ 148 template<typename ExpressionType, int Direction> 149 EIGEN_DEVICE_FUNC inline Homogeneous<ExpressionType,Direction> 150 VectorwiseOp<ExpressionType,Direction>::homogeneous() const 151 { 152 return HomogeneousReturnType(_expression()); 153 } 154 155 /** \geometry_module \ingroup Geometry_Module 156 * 157 * \brief homogeneous normalization 158 * 159 * \returns a vector expression of the N-1 first coefficients of \c *this divided by that last coefficient. 160 * 161 * This can be used to convert homogeneous coordinates to affine coordinates. 162 * 163 * It is essentially a shortcut for: 164 * \code 165 this->head(this->size()-1)/this->coeff(this->size()-1); 166 \endcode 167 * 168 * Example: \include MatrixBase_hnormalized.cpp 169 * Output: \verbinclude MatrixBase_hnormalized.out 170 * 171 * \sa VectorwiseOp::hnormalized() */ 172 template<typename Derived> 173 EIGEN_DEVICE_FUNC inline const typename MatrixBase<Derived>::HNormalizedReturnType 174 MatrixBase<Derived>::hnormalized() const 175 { 176 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived); 177 return ConstStartMinusOne(derived(),0,0, 178 ColsAtCompileTime==1?size()-1:1, 179 ColsAtCompileTime==1?1:size()-1) / coeff(size()-1); 180 } 181 182 /** \geometry_module \ingroup Geometry_Module 183 * 184 * \brief column or row-wise homogeneous normalization 185 * 186 * \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). 187 * 188 * This can be used to convert homogeneous coordinates to affine coordinates. 189 * 190 * It is conceptually equivalent to calling MatrixBase::hnormalized() to each column (or row) of \c *this. 191 * 192 * Example: \include DirectionWise_hnormalized.cpp 193 * Output: \verbinclude DirectionWise_hnormalized.out 194 * 195 * \sa MatrixBase::hnormalized() */ 196 template<typename ExpressionType, int Direction> 197 EIGEN_DEVICE_FUNC inline const typename VectorwiseOp<ExpressionType,Direction>::HNormalizedReturnType 198 VectorwiseOp<ExpressionType,Direction>::hnormalized() const 199 { 200 return HNormalized_Block(_expression(),0,0, 201 Direction==Vertical ? _expression().rows()-1 : _expression().rows(), 202 Direction==Horizontal ? _expression().cols()-1 : _expression().cols()).cwiseQuotient( 203 Replicate<HNormalized_Factors, 204 Direction==Vertical ? HNormalized_SizeMinusOne : 1, 205 Direction==Horizontal ? HNormalized_SizeMinusOne : 1> 206 (HNormalized_Factors(_expression(), 207 Direction==Vertical ? _expression().rows()-1:0, 208 Direction==Horizontal ? _expression().cols()-1:0, 209 Direction==Vertical ? 1 : _expression().rows(), 210 Direction==Horizontal ? 1 : _expression().cols()), 211 Direction==Vertical ? _expression().rows()-1 : 1, 212 Direction==Horizontal ? _expression().cols()-1 : 1)); 213 } 214 215 namespace internal { 216 217 template<typename MatrixOrTransformType> 218 struct take_matrix_for_product 219 { 220 typedef MatrixOrTransformType type; 221 EIGEN_DEVICE_FUNC static const type& run(const type &x) { return x; } 222 }; 223 224 template<typename Scalar, int Dim, int Mode,int Options> 225 struct take_matrix_for_product<Transform<Scalar, Dim, Mode, Options> > 226 { 227 typedef Transform<Scalar, Dim, Mode, Options> TransformType; 228 typedef typename internal::add_const<typename TransformType::ConstAffinePart>::type type; 229 EIGEN_DEVICE_FUNC static type run (const TransformType& x) { return x.affine(); } 230 }; 231 232 template<typename Scalar, int Dim, int Options> 233 struct take_matrix_for_product<Transform<Scalar, Dim, Projective, Options> > 234 { 235 typedef Transform<Scalar, Dim, Projective, Options> TransformType; 236 typedef typename TransformType::MatrixType type; 237 EIGEN_DEVICE_FUNC static const type& run (const TransformType& x) { return x.matrix(); } 238 }; 239 240 template<typename MatrixType,typename Lhs> 241 struct traits<homogeneous_left_product_impl<Homogeneous<MatrixType,Vertical>,Lhs> > 242 { 243 typedef typename take_matrix_for_product<Lhs>::type LhsMatrixType; 244 typedef typename remove_all<MatrixType>::type MatrixTypeCleaned; 245 typedef typename remove_all<LhsMatrixType>::type LhsMatrixTypeCleaned; 246 typedef typename make_proper_matrix_type< 247 typename traits<MatrixTypeCleaned>::Scalar, 248 LhsMatrixTypeCleaned::RowsAtCompileTime, 249 MatrixTypeCleaned::ColsAtCompileTime, 250 MatrixTypeCleaned::PlainObject::Options, 251 LhsMatrixTypeCleaned::MaxRowsAtCompileTime, 252 MatrixTypeCleaned::MaxColsAtCompileTime>::type ReturnType; 253 }; 254 255 template<typename MatrixType,typename Lhs> 256 struct homogeneous_left_product_impl<Homogeneous<MatrixType,Vertical>,Lhs> 257 : public ReturnByValue<homogeneous_left_product_impl<Homogeneous<MatrixType,Vertical>,Lhs> > 258 { 259 typedef typename traits<homogeneous_left_product_impl>::LhsMatrixType LhsMatrixType; 260 typedef typename remove_all<LhsMatrixType>::type LhsMatrixTypeCleaned; 261 typedef typename remove_all<typename LhsMatrixTypeCleaned::Nested>::type LhsMatrixTypeNested; 262 EIGEN_DEVICE_FUNC homogeneous_left_product_impl(const Lhs& lhs, const MatrixType& rhs) 263 : m_lhs(take_matrix_for_product<Lhs>::run(lhs)), 264 m_rhs(rhs) 265 {} 266 267 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR 268 inline Index rows() const EIGEN_NOEXCEPT { return m_lhs.rows(); } 269 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR 270 inline Index cols() const EIGEN_NOEXCEPT { return m_rhs.cols(); } 271 272 template<typename Dest> EIGEN_DEVICE_FUNC void evalTo(Dest& dst) const 273 { 274 // FIXME investigate how to allow lazy evaluation of this product when possible 275 dst = Block<const LhsMatrixTypeNested, 276 LhsMatrixTypeNested::RowsAtCompileTime, 277 LhsMatrixTypeNested::ColsAtCompileTime==Dynamic?Dynamic:LhsMatrixTypeNested::ColsAtCompileTime-1> 278 (m_lhs,0,0,m_lhs.rows(),m_lhs.cols()-1) * m_rhs; 279 dst += m_lhs.col(m_lhs.cols()-1).rowwise() 280 .template replicate<MatrixType::ColsAtCompileTime>(m_rhs.cols()); 281 } 282 283 typename LhsMatrixTypeCleaned::Nested m_lhs; 284 typename MatrixType::Nested m_rhs; 285 }; 286 287 template<typename MatrixType,typename Rhs> 288 struct traits<homogeneous_right_product_impl<Homogeneous<MatrixType,Horizontal>,Rhs> > 289 { 290 typedef typename make_proper_matrix_type<typename traits<MatrixType>::Scalar, 291 MatrixType::RowsAtCompileTime, 292 Rhs::ColsAtCompileTime, 293 MatrixType::PlainObject::Options, 294 MatrixType::MaxRowsAtCompileTime, 295 Rhs::MaxColsAtCompileTime>::type ReturnType; 296 }; 297 298 template<typename MatrixType,typename Rhs> 299 struct homogeneous_right_product_impl<Homogeneous<MatrixType,Horizontal>,Rhs> 300 : public ReturnByValue<homogeneous_right_product_impl<Homogeneous<MatrixType,Horizontal>,Rhs> > 301 { 302 typedef typename remove_all<typename Rhs::Nested>::type RhsNested; 303 EIGEN_DEVICE_FUNC homogeneous_right_product_impl(const MatrixType& lhs, const Rhs& rhs) 304 : m_lhs(lhs), m_rhs(rhs) 305 {} 306 307 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index rows() const EIGEN_NOEXCEPT { return m_lhs.rows(); } 308 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index cols() const EIGEN_NOEXCEPT { return m_rhs.cols(); } 309 310 template<typename Dest> EIGEN_DEVICE_FUNC void evalTo(Dest& dst) const 311 { 312 // FIXME investigate how to allow lazy evaluation of this product when possible 313 dst = m_lhs * Block<const RhsNested, 314 RhsNested::RowsAtCompileTime==Dynamic?Dynamic:RhsNested::RowsAtCompileTime-1, 315 RhsNested::ColsAtCompileTime> 316 (m_rhs,0,0,m_rhs.rows()-1,m_rhs.cols()); 317 dst += m_rhs.row(m_rhs.rows()-1).colwise() 318 .template replicate<MatrixType::RowsAtCompileTime>(m_lhs.rows()); 319 } 320 321 typename MatrixType::Nested m_lhs; 322 typename Rhs::Nested m_rhs; 323 }; 324 325 template<typename ArgType,int Direction> 326 struct evaluator_traits<Homogeneous<ArgType,Direction> > 327 { 328 typedef typename storage_kind_to_evaluator_kind<typename ArgType::StorageKind>::Kind Kind; 329 typedef HomogeneousShape Shape; 330 }; 331 332 template<> struct AssignmentKind<DenseShape,HomogeneousShape> { typedef Dense2Dense Kind; }; 333 334 335 template<typename ArgType,int Direction> 336 struct unary_evaluator<Homogeneous<ArgType,Direction>, IndexBased> 337 : evaluator<typename Homogeneous<ArgType,Direction>::PlainObject > 338 { 339 typedef Homogeneous<ArgType,Direction> XprType; 340 typedef typename XprType::PlainObject PlainObject; 341 typedef evaluator<PlainObject> Base; 342 343 EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op) 344 : Base(), m_temp(op) 345 { 346 ::new (static_cast<Base*>(this)) Base(m_temp); 347 } 348 349 protected: 350 PlainObject m_temp; 351 }; 352 353 // dense = homogeneous 354 template< typename DstXprType, typename ArgType, typename Scalar> 355 struct Assignment<DstXprType, Homogeneous<ArgType,Vertical>, internal::assign_op<Scalar,typename ArgType::Scalar>, Dense2Dense> 356 { 357 typedef Homogeneous<ArgType,Vertical> SrcXprType; 358 EIGEN_DEVICE_FUNC static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename ArgType::Scalar> &) 359 { 360 Index dstRows = src.rows(); 361 Index dstCols = src.cols(); 362 if((dst.rows()!=dstRows) || (dst.cols()!=dstCols)) 363 dst.resize(dstRows, dstCols); 364 365 dst.template topRows<ArgType::RowsAtCompileTime>(src.nestedExpression().rows()) = src.nestedExpression(); 366 dst.row(dst.rows()-1).setOnes(); 367 } 368 }; 369 370 // dense = homogeneous 371 template< typename DstXprType, typename ArgType, typename Scalar> 372 struct Assignment<DstXprType, Homogeneous<ArgType,Horizontal>, internal::assign_op<Scalar,typename ArgType::Scalar>, Dense2Dense> 373 { 374 typedef Homogeneous<ArgType,Horizontal> SrcXprType; 375 EIGEN_DEVICE_FUNC static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,typename ArgType::Scalar> &) 376 { 377 Index dstRows = src.rows(); 378 Index dstCols = src.cols(); 379 if((dst.rows()!=dstRows) || (dst.cols()!=dstCols)) 380 dst.resize(dstRows, dstCols); 381 382 dst.template leftCols<ArgType::ColsAtCompileTime>(src.nestedExpression().cols()) = src.nestedExpression(); 383 dst.col(dst.cols()-1).setOnes(); 384 } 385 }; 386 387 template<typename LhsArg, typename Rhs, int ProductTag> 388 struct generic_product_impl<Homogeneous<LhsArg,Horizontal>, Rhs, HomogeneousShape, DenseShape, ProductTag> 389 { 390 template<typename Dest> 391 EIGEN_DEVICE_FUNC static void evalTo(Dest& dst, const Homogeneous<LhsArg,Horizontal>& lhs, const Rhs& rhs) 392 { 393 homogeneous_right_product_impl<Homogeneous<LhsArg,Horizontal>, Rhs>(lhs.nestedExpression(), rhs).evalTo(dst); 394 } 395 }; 396 397 template<typename Lhs,typename Rhs> 398 struct homogeneous_right_product_refactoring_helper 399 { 400 enum { 401 Dim = Lhs::ColsAtCompileTime, 402 Rows = Lhs::RowsAtCompileTime 403 }; 404 typedef typename Rhs::template ConstNRowsBlockXpr<Dim>::Type LinearBlockConst; 405 typedef typename remove_const<LinearBlockConst>::type LinearBlock; 406 typedef typename Rhs::ConstRowXpr ConstantColumn; 407 typedef Replicate<const ConstantColumn,Rows,1> ConstantBlock; 408 typedef Product<Lhs,LinearBlock,LazyProduct> LinearProduct; 409 typedef CwiseBinaryOp<internal::scalar_sum_op<typename Lhs::Scalar,typename Rhs::Scalar>, const LinearProduct, const ConstantBlock> Xpr; 410 }; 411 412 template<typename Lhs, typename Rhs, int ProductTag> 413 struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, HomogeneousShape, DenseShape> 414 : public evaluator<typename homogeneous_right_product_refactoring_helper<typename Lhs::NestedExpression,Rhs>::Xpr> 415 { 416 typedef Product<Lhs, Rhs, LazyProduct> XprType; 417 typedef homogeneous_right_product_refactoring_helper<typename Lhs::NestedExpression,Rhs> helper; 418 typedef typename helper::ConstantBlock ConstantBlock; 419 typedef typename helper::Xpr RefactoredXpr; 420 typedef evaluator<RefactoredXpr> Base; 421 422 EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr) 423 : Base( xpr.lhs().nestedExpression() .lazyProduct( xpr.rhs().template topRows<helper::Dim>(xpr.lhs().nestedExpression().cols()) ) 424 + ConstantBlock(xpr.rhs().row(xpr.rhs().rows()-1),xpr.lhs().rows(), 1) ) 425 {} 426 }; 427 428 template<typename Lhs, typename RhsArg, int ProductTag> 429 struct generic_product_impl<Lhs, Homogeneous<RhsArg,Vertical>, DenseShape, HomogeneousShape, ProductTag> 430 { 431 template<typename Dest> 432 EIGEN_DEVICE_FUNC static void evalTo(Dest& dst, const Lhs& lhs, const Homogeneous<RhsArg,Vertical>& rhs) 433 { 434 homogeneous_left_product_impl<Homogeneous<RhsArg,Vertical>, Lhs>(lhs, rhs.nestedExpression()).evalTo(dst); 435 } 436 }; 437 438 // TODO: the following specialization is to address a regression from 3.2 to 3.3 439 // In the future, this path should be optimized. 440 template<typename Lhs, typename RhsArg, int ProductTag> 441 struct generic_product_impl<Lhs, Homogeneous<RhsArg,Vertical>, TriangularShape, HomogeneousShape, ProductTag> 442 { 443 template<typename Dest> 444 static void evalTo(Dest& dst, const Lhs& lhs, const Homogeneous<RhsArg,Vertical>& rhs) 445 { 446 dst.noalias() = lhs * rhs.eval(); 447 } 448 }; 449 450 template<typename Lhs,typename Rhs> 451 struct homogeneous_left_product_refactoring_helper 452 { 453 enum { 454 Dim = Rhs::RowsAtCompileTime, 455 Cols = Rhs::ColsAtCompileTime 456 }; 457 typedef typename Lhs::template ConstNColsBlockXpr<Dim>::Type LinearBlockConst; 458 typedef typename remove_const<LinearBlockConst>::type LinearBlock; 459 typedef typename Lhs::ConstColXpr ConstantColumn; 460 typedef Replicate<const ConstantColumn,1,Cols> ConstantBlock; 461 typedef Product<LinearBlock,Rhs,LazyProduct> LinearProduct; 462 typedef CwiseBinaryOp<internal::scalar_sum_op<typename Lhs::Scalar,typename Rhs::Scalar>, const LinearProduct, const ConstantBlock> Xpr; 463 }; 464 465 template<typename Lhs, typename Rhs, int ProductTag> 466 struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, DenseShape, HomogeneousShape> 467 : public evaluator<typename homogeneous_left_product_refactoring_helper<Lhs,typename Rhs::NestedExpression>::Xpr> 468 { 469 typedef Product<Lhs, Rhs, LazyProduct> XprType; 470 typedef homogeneous_left_product_refactoring_helper<Lhs,typename Rhs::NestedExpression> helper; 471 typedef typename helper::ConstantBlock ConstantBlock; 472 typedef typename helper::Xpr RefactoredXpr; 473 typedef evaluator<RefactoredXpr> Base; 474 475 EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr) 476 : Base( xpr.lhs().template leftCols<helper::Dim>(xpr.rhs().nestedExpression().rows()) .lazyProduct( xpr.rhs().nestedExpression() ) 477 + ConstantBlock(xpr.lhs().col(xpr.lhs().cols()-1),1,xpr.rhs().cols()) ) 478 {} 479 }; 480 481 template<typename Scalar, int Dim, int Mode,int Options, typename RhsArg, int ProductTag> 482 struct generic_product_impl<Transform<Scalar,Dim,Mode,Options>, Homogeneous<RhsArg,Vertical>, DenseShape, HomogeneousShape, ProductTag> 483 { 484 typedef Transform<Scalar,Dim,Mode,Options> TransformType; 485 template<typename Dest> 486 EIGEN_DEVICE_FUNC static void evalTo(Dest& dst, const TransformType& lhs, const Homogeneous<RhsArg,Vertical>& rhs) 487 { 488 homogeneous_left_product_impl<Homogeneous<RhsArg,Vertical>, TransformType>(lhs, rhs.nestedExpression()).evalTo(dst); 489 } 490 }; 491 492 template<typename ExpressionType, int Side, bool Transposed> 493 struct permutation_matrix_product<ExpressionType, Side, Transposed, HomogeneousShape> 494 : public permutation_matrix_product<ExpressionType, Side, Transposed, DenseShape> 495 {}; 496 497 } // end namespace internal 498 499 } // end namespace Eigen 500 501 #endif // EIGEN_HOMOGENEOUS_H