* make std::vector specializations also for Transform and for Quaternion

* update test_stdvector
* Quaternion() does nothing (instead of bug)
* update test_geometry
* some renaming

Eigen/src/Core/Matrix.h

@@ -132,8 +132,6 @@ class Matrix
 
   protected:
     ei_matrix_storage<Scalar, MaxSizeAtCompileTime, RowsAtCompileTime, ColsAtCompileTime, Options> m_storage;
-    Matrix(ei_constructor_without_unaligned_array_assert)
-      : m_storage(ei_constructor_without_unaligned_array_assert()) {}
 
   public:
     enum { NeedsToAlign = (Options&AutoAlign) == AutoAlign
@@ -339,6 +337,9 @@ class Matrix
       ei_assert(RowsAtCompileTime > 0 && ColsAtCompileTime > 0);
     }
 
+    Matrix(ei_constructor_without_unaligned_array_assert)
+      : m_storage(ei_constructor_without_unaligned_array_assert()) {}
+
     /** Constructs a vector or row-vector with given dimension. \only_for_vectors
       *
       * Note that this is only useful for dynamic-size vectors. For fixed-size vectors,

Eigen/src/Core/util/Memory.h

@@ -303,7 +303,7 @@ inline static int ei_alignmentOffset(const Scalar* ptr, int maxOffset)
     EIGEN_WORKAROUND_FOR_QT_BUG_CALLING_WRONG_OPERATOR_NEW
 
 #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(true)
-#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE(Scalar,Size) \
+#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar,Size) \
   EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(((Size)!=Eigen::Dynamic) && ((sizeof(Scalar)*(Size))%16==0))
 
 /** Deprecated, use the EIGEN_MAKE_ALIGNED_OPERATOR_NEW macro instead in your own class */

Eigen/src/Geometry/AlignedBox.h

@@ -41,7 +41,7 @@ template <typename _Scalar, int _AmbientDim>
 class AlignedBox
 {
 public:
-EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE(_Scalar,_AmbientDim==Dynamic ? Dynamic : _AmbientDim+1)
+EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim==Dynamic ? Dynamic : _AmbientDim+1)
   enum { AmbientDimAtCompileTime = _AmbientDim };
   typedef _Scalar Scalar;
   typedef typename NumTraits<Scalar>::Real RealScalar;

Eigen/src/Geometry/Hyperplane.h

@@ -47,7 +47,7 @@ template <typename _Scalar, int _AmbientDim>
 class Hyperplane
 {
 public:
-  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE(_Scalar,_AmbientDim==Dynamic ? Dynamic : _AmbientDim+1)
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim==Dynamic ? Dynamic : _AmbientDim+1)
   enum { AmbientDimAtCompileTime = _AmbientDim };
   typedef _Scalar Scalar;
   typedef typename NumTraits<Scalar>::Real RealScalar;

Eigen/src/Geometry/ParametrizedLine.h

@@ -43,7 +43,7 @@ template <typename _Scalar, int _AmbientDim>
 class ParametrizedLine
 {
 public:
-  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE(_Scalar,_AmbientDim)
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim)
   enum { AmbientDimAtCompileTime = _AmbientDim };
   typedef _Scalar Scalar;
   typedef typename NumTraits<Scalar>::Real RealScalar;

Eigen/src/Geometry/Quaternion.h

@@ -61,17 +61,17 @@ template<typename _Scalar>
 class Quaternion : public RotationBase<Quaternion<_Scalar>,3>
 {
   typedef RotationBase<Quaternion<_Scalar>,3> Base;
-  typedef Matrix<_Scalar, 4, 1> Coefficients;
-  Coefficients m_coeffs;
-
+  
 public:
-  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE(_Scalar,4)
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,4)
 
   using Base::operator*;
-
+  
   /** the scalar type of the coefficients */
   typedef _Scalar Scalar;
 
+  /** the type of the Coefficients 4-vector */
+  typedef Matrix<Scalar, 4, 1> Coefficients;
   /** the type of a 3D vector */
   typedef Matrix<Scalar,3,1> Vector3;
   /** the equivalent rotation matrix type */
@@ -110,8 +110,11 @@ public:
   inline Coefficients& coeffs() { return m_coeffs; }
 
   /** Default constructor and initializing an identity quaternion. */
-  inline Quaternion()
-  { m_coeffs << 0, 0, 0, 1; }
+  inline Quaternion() {}
+
+  inline Quaternion(ei_constructor_without_unaligned_array_assert)
+    : m_coeffs(ei_constructor_without_unaligned_array_assert()) {}
+
 
   /** Constructs and initializes the quaternion \f$ w+xi+yj+zk \f$ from
     * its four coefficients \a w, \a x, \a y and \a z.
@@ -149,7 +152,7 @@ public:
 
   /** \sa Quaternion::Identity(), MatrixBase::setIdentity()
     */
-  inline Quaternion& setIdentity() { m_coeffs << 1, 0, 0, 0; return *this; }
+  inline Quaternion& setIdentity() { m_coeffs << 0, 0, 0, 1; return *this; }
 
   /** \returns the squared norm of the quaternion's coefficients
     * \sa Quaternion::norm(), MatrixBase::squaredNorm()
@@ -214,6 +217,8 @@ public:
   bool isApprox(const Quaternion& other, typename NumTraits<Scalar>::Real prec = precision<Scalar>()) const
   { return m_coeffs.isApprox(other.m_coeffs, prec); }
 
+protected: 
+  Coefficients m_coeffs;
 };
 
 /** \ingroup GeometryModule

Eigen/src/Geometry/Scaling.h

@@ -43,7 +43,7 @@ template<typename _Scalar, int _Dim>
 class Scaling
 {
 public:
-  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE(_Scalar,_Dim)
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_Dim)
   /** dimension of the space */
   enum { Dim = _Dim };
   /** the scalar type of the coefficients */

Eigen/src/Geometry/Transform.h

@@ -63,7 +63,7 @@ template<typename _Scalar, int _Dim>
 class Transform
 {
 public:
-  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE(_Scalar,_Dim==Dynamic ? Dynamic : (_Dim+1)*(_Dim+1))
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_Dim==Dynamic ? Dynamic : (_Dim+1)*(_Dim+1))
   enum {
     Dim = _Dim,     ///< space dimension in which the transformation holds
     HDim = _Dim+1   ///< size of a respective homogeneous vector
@@ -94,6 +94,9 @@ public:
   /** Default constructor without initialization of the coefficients. */
   inline Transform() { }
 
+  inline Transform(ei_constructor_without_unaligned_array_assert)
+    : m_matrix(ei_constructor_without_unaligned_array_assert()) {}
+
   inline Transform(const Transform& other)
   { 
     m_matrix = other.m_matrix;

Eigen/src/Geometry/Translation.h

@@ -43,7 +43,7 @@ template<typename _Scalar, int _Dim>
 class Translation
 {
 public:
-  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE(_Scalar,_Dim)
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_Dim)
   /** dimension of the space */
   enum { Dim = _Dim };
   /** the scalar type of the coefficients */

Eigen/src/StdVector/StdVector.h

@@ -26,6 +26,20 @@
 #ifndef EIGEN_STDVECTOR_H
 #define EIGEN_STDVECTOR_H
 
+#define EIGEN_STD_VECTOR_SPECIALIZATION_BODY \
+  typedef Eigen::aligned_allocator<value_type> allocator_type; \
+  typedef vector<value_type, allocator_type > unaligned_base; \
+  typedef typename unaligned_base::size_type size_type; \
+  typedef typename unaligned_base::iterator iterator; \
+  explicit vector(const allocator_type& __a = allocator_type()) : unaligned_base(__a) {} \
+  vector(const vector& c) : unaligned_base(c) {} \
+  vector(size_type num, const value_type& val = value_type()) : unaligned_base(num, val) {}\
+  vector(iterator start, iterator end) : unaligned_base(start, end) {} \
+  vector& operator=(const vector& __x) { \
+    unaligned_base::operator=(__x); \
+    return *this; \
+  }
+
 template <typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols, typename _Alloc>
 class vector<Eigen::Matrix<_Scalar,_Rows,_Cols,_Options,_MaxRows,_MaxCols>, _Alloc>
   : public vector<Eigen::ei_unaligned_type<Eigen::Matrix<_Scalar,_Rows,_Cols,_Options,_MaxRows,_MaxCols> >,
@@ -33,19 +47,27 @@ class vector<Eigen::Matrix<_Scalar,_Rows,_Cols,_Options,_MaxRows,_MaxCols>, _All
 {
 public:
   typedef Eigen::ei_unaligned_type<Eigen::Matrix<_Scalar,_Rows,_Cols,_Options,_MaxRows,_MaxCols> > value_type;
-  typedef Eigen::aligned_allocator<value_type> allocator_type;
-  typedef vector<value_type, allocator_type > unaligned_base;
-  typedef typename unaligned_base::size_type size_type;
-  typedef typename unaligned_base::iterator iterator;
+  EIGEN_STD_VECTOR_SPECIALIZATION_BODY
+};
 
-  explicit vector(const allocator_type& __a = allocator_type()) : unaligned_base(__a) {}
-  vector(const vector& c) : unaligned_base(c) {}
-  vector(size_type num, const value_type& val = value_type()) : unaligned_base(num, val) {}
-  vector(iterator start, iterator end) : unaligned_base(start, end) {}
-  vector& operator=(const vector& __x) {
-    unaligned_base::operator=(__x);
-    return *this;
-  }
+template <typename _Scalar, int _Dim, typename _Alloc>
+class vector<Eigen::Transform<_Scalar,_Dim>, _Alloc>
+  : public vector<Eigen::ei_unaligned_type<Eigen::Transform<_Scalar,_Dim> >,
+                  Eigen::aligned_allocator<Eigen::ei_unaligned_type<Eigen::Transform<_Scalar,_Dim> > > >
+{
+public:
+  typedef Eigen::ei_unaligned_type<Eigen::Transform<_Scalar,_Dim> > value_type;
+  EIGEN_STD_VECTOR_SPECIALIZATION_BODY
+};
+
+template <typename _Scalar, typename _Alloc>
+class vector<Eigen::Quaternion<_Scalar>, _Alloc>
+  : public vector<Eigen::ei_unaligned_type<Eigen::Quaternion<_Scalar> >,
+                  Eigen::aligned_allocator<Eigen::ei_unaligned_type<Eigen::Quaternion<_Scalar> > > >
+{
+public:
+  typedef Eigen::ei_unaligned_type<Eigen::Quaternion<_Scalar> > value_type;
+  EIGEN_STD_VECTOR_SPECIALIZATION_BODY
 };
 
 #endif // EIGEN_STDVECTOR_H

Eigen/src/StdVector/UnalignedType.h

@@ -35,12 +35,42 @@ class ei_unaligned_type<Matrix<_Scalar,_Rows,_Cols,_Options,_MaxRows,_MaxCols> >
   public:
     typedef Matrix<_Scalar,_Rows,_Cols,_Options,_MaxRows,_MaxCols> aligned_base;
     ei_unaligned_type() : aligned_base(ei_constructor_without_unaligned_array_assert()) {}
-    ei_unaligned_type(const aligned_base& other)
-      : aligned_base(ei_constructor_without_unaligned_array_assert())
+    ei_unaligned_type(const aligned_base& other) : aligned_base(ei_constructor_without_unaligned_array_assert())
     {
       resize(other.rows(), other.cols());
       ei_assign_impl<ei_unaligned_type,aligned_base,NoVectorization>::run(*this, other);
     }
 };
 
+template<typename _Scalar, int _Dim>
+class ei_unaligned_type<Transform<_Scalar,_Dim> >
+  : public Transform<_Scalar,_Dim>
+{
+  public:
+    typedef Transform<_Scalar,_Dim> aligned_base;
+    typedef typename aligned_base::MatrixType MatrixType;
+    ei_unaligned_type() : aligned_base(ei_constructor_without_unaligned_array_assert()) {}
+    ei_unaligned_type(const aligned_base& other) : aligned_base(ei_constructor_without_unaligned_array_assert())
+    {
+      // no resizing here, it's fixed-size anyway
+      ei_assign_impl<MatrixType,MatrixType,NoVectorization>::run(this->matrix(), other.matrix());
+    }
+};
+
+template<typename _Scalar>
+class ei_unaligned_type<Quaternion<_Scalar> >
+  : public Quaternion<_Scalar>
+{
+  public:
+    typedef Quaternion<_Scalar> aligned_base;
+    typedef typename aligned_base::Coefficients Coefficients;
+    ei_unaligned_type() : aligned_base(ei_constructor_without_unaligned_array_assert()) {}
+    ei_unaligned_type(const aligned_base& other) : aligned_base(ei_constructor_without_unaligned_array_assert())
+    {
+      // no resizing here, it's fixed-size anyway
+      ei_assign_impl<Coefficients,Coefficients,NoVectorization>::run(this->coeffs(), other.coeffs());
+    }
+};
+
+
 #endif // EIGEN_UNALIGNEDTYPE_H

test/geometry.cpp

@@ -52,7 +52,6 @@ template<typename Scalar> void geometry(void)
   if (ei_is_same_type<Scalar,float>::ret)
     largeEps = 1e-3f;
 
-  Quaternionx q1, q2;
   Vector3 v0 = Vector3::Random(),
     v1 = Vector3::Random(),
     v2 = Vector3::Random();
@@ -69,6 +68,13 @@ template<typename Scalar> void geometry(void)
       (v0.cross(v1).cross(v0)).normalized();
   VERIFY(m.isUnitary());
 
+  // Quaternion: Identity(), setIdentity();
+  Quaternionx q1, q2;
+  q2.setIdentity();
+  VERIFY_IS_APPROX(Quaternionx(Quaternionx::Identity()).coeffs(), q2.coeffs());
+  q1.coeffs().setRandom();
+  VERIFY_IS_APPROX(q1.coeffs(), (q1*q2).coeffs());
+
   // unitOrthogonal
   VERIFY_IS_MUCH_SMALLER_THAN(u0.unitOrthogonal().dot(u0), Scalar(1));
   VERIFY_IS_MUCH_SMALLER_THAN(v0.unitOrthogonal().dot(v0), Scalar(1));

test/stdvector.cpp

@@ -24,9 +24,10 @@
 
 #include "main.h"
 #include <Eigen/StdVector>
+#include <Eigen/Geometry>
 
 template<typename MatrixType>
-void check_stdvector(const MatrixType& m)
+void check_stdvector_matrix(const MatrixType& m)
 {
   int rows = m.rows();
   int cols = m.cols();
@@ -61,22 +62,102 @@ void check_stdvector(const MatrixType& m)
   }
 }
 
+template<typename TransformType>
+void check_stdvector_transform(const TransformType&)
+{
+  typedef typename TransformType::MatrixType MatrixType;
+  TransformType x(MatrixType::Random()), y(MatrixType::Random());
+  std::vector<TransformType> v(10), w(20, y);
+  v[5] = x;
+  w[6] = v[5];
+  VERIFY_IS_APPROX(w[6], v[5]);
+  v = w;
+  for(int i = 0; i < 20; i++)
+  {
+    VERIFY_IS_APPROX(w[i], v[i]);
+  }
+
+  v.resize(21);
+  v[20] = x;
+  VERIFY_IS_APPROX(v[20], x);
+  v.resize(22,y);
+  VERIFY_IS_APPROX(v[21], y);
+  v.push_back(x);
+  VERIFY_IS_APPROX(v[22], x);
+  VERIFY((size_t)&(v[22]) == (size_t)&(v[21]) + sizeof(TransformType));
+
+  // do a lot of push_back such that the vector gets internally resized
+  // (with memory reallocation)
+  TransformType* ref = &w[0];
+  for(int i=0; i<30 || ((ref==&w[0]) && i<300); ++i)
+    v.push_back(w[i%w.size()]);
+  for(unsigned int i=23; i<v.size(); ++i)
+  {
+    VERIFY(v[i].matrix()==w[(i-23)%w.size()].matrix());
+  }
+}
+
+template<typename QuaternionType>
+void check_stdvector_quaternion(const QuaternionType&)
+{
+  typedef typename QuaternionType::Coefficients Coefficients;
+  QuaternionType x(Coefficients::Random()), y(Coefficients::Random());
+  std::vector<QuaternionType> v(10), w(20, y);
+  v[5] = x;
+  w[6] = v[5];
+  VERIFY_IS_APPROX(w[6], v[5]);
+  v = w;
+  for(int i = 0; i < 20; i++)
+  {
+    VERIFY_IS_APPROX(w[i], v[i]);
+  }
+
+  v.resize(21);
+  v[20] = x;
+  VERIFY_IS_APPROX(v[20], x);
+  v.resize(22,y);
+  VERIFY_IS_APPROX(v[21], y);
+  v.push_back(x);
+  VERIFY_IS_APPROX(v[22], x);
+  VERIFY((size_t)&(v[22]) == (size_t)&(v[21]) + sizeof(QuaternionType));
+
+  // do a lot of push_back such that the vector gets internally resized
+  // (with memory reallocation)
+  QuaternionType* ref = &w[0];
+  for(int i=0; i<30 || ((ref==&w[0]) && i<300); ++i)
+    v.push_back(w[i%w.size()]);
+  for(unsigned int i=23; i<v.size(); ++i)
+  {
+    VERIFY(v[i].coeffs()==w[(i-23)%w.size()].coeffs());
+  }
+}
+
 void test_stdvector()
 {
   // some non vectorizable fixed sizes
-  CALL_SUBTEST(check_stdvector(Vector2f()));
-  CALL_SUBTEST(check_stdvector(Matrix3f()));
-  CALL_SUBTEST(check_stdvector(Matrix3d()));
+  CALL_SUBTEST(check_stdvector_matrix(Vector2f()));
+  CALL_SUBTEST(check_stdvector_matrix(Matrix3f()));
+  CALL_SUBTEST(check_stdvector_matrix(Matrix3d()));
 
   // some vectorizable fixed sizes
-  CALL_SUBTEST(check_stdvector(Matrix2f()));
-  CALL_SUBTEST(check_stdvector(Vector4f()));
-  CALL_SUBTEST(check_stdvector(Matrix4f()));
-  CALL_SUBTEST(check_stdvector(Matrix4d()));
+  CALL_SUBTEST(check_stdvector_matrix(Matrix2f()));
+  CALL_SUBTEST(check_stdvector_matrix(Vector4f()));
+  CALL_SUBTEST(check_stdvector_matrix(Matrix4f()));
+  CALL_SUBTEST(check_stdvector_matrix(Matrix4d()));
 
   // some dynamic sizes
-  CALL_SUBTEST(check_stdvector(MatrixXd(1,1)));
-  CALL_SUBTEST(check_stdvector(VectorXd(20)));
-  CALL_SUBTEST(check_stdvector(RowVectorXf(20)));
-  CALL_SUBTEST(check_stdvector(MatrixXcf(10,10)));
+  CALL_SUBTEST(check_stdvector_matrix(MatrixXd(1,1)));
+  CALL_SUBTEST(check_stdvector_matrix(VectorXd(20)));
+  CALL_SUBTEST(check_stdvector_matrix(RowVectorXf(20)));
+  CALL_SUBTEST(check_stdvector_matrix(MatrixXcf(10,10)));
+
+  // some Transform
+  CALL_SUBTEST(check_stdvector_transform(Transform2f()));
+  CALL_SUBTEST(check_stdvector_transform(Transform3f()));
+  CALL_SUBTEST(check_stdvector_transform(Transform3d()));
+  //CALL_SUBTEST(check_stdvector_transform(Transform4d()));
+
+  // some Quaternion
+  CALL_SUBTEST(check_stdvector_quaternion(Quaternionf()));
+  CALL_SUBTEST(check_stdvector_quaternion(Quaternionf()));
 }