[MERGE]

src/common/WPropertyTypes.h

@@ -27,6 +27,11 @@
 
 #include <stdint.h>
 
+#include <string>
+#include <vector>
+
+#include <boost/lexical_cast.hpp>
+
 #include <string>
 #include <list>
 #include <utility>
@@ -35,7 +40,7 @@
 #include <boost/lexical_cast.hpp>
 
 #include "math/WPosition.h"
-#include "math/WMatrix4x4.h"
+#include "math/WMatrix.h"
 #include "WItemSelector.h"
 #include "WColor.h"
 
@@ -98,9 +103,9 @@ namespace WPVBaseTypes
     typedef std::string                                     PV_STRING;      //!< base type used for every WPVString
     typedef boost::filesystem::path                         PV_PATH;        //!< base type used for every WPVFilename
     typedef WItemSelector                                   PV_SELECTION;   //!< base type used for every WPVSelection
-    typedef WPosition                                PV_POSITION;    //!< base type used for every WPVPosition
+    typedef WPosition                                       PV_POSITION;    //!< base type used for every WPVPosition
     typedef WColor                                          PV_COLOR;       //!< base type used for every WPVColor
-    typedef WMatrix4x4                               PV_MATRIX4X4;   //!< base type used for every WPVMatrix4X4
+    typedef WMatrix4x4_2                                    PV_MATRIX4X4;   //!< base type used for every WPVMatrix4X4
 
     /**
      * Enum denoting the possible trigger states. It is used for trigger properties.
@@ -543,7 +548,22 @@ namespace PROPERTY_TYPE_HELPER
          */
         WPVBaseTypes::PV_MATRIX4X4 create( const WPVBaseTypes::PV_MATRIX4X4& /*old*/, const std::string str )
         {
-            return fromString( str );
+            WMatrix4x4_2 c;
+            std::vector< std::string > tokens;
+            tokens = string_utils::tokenize( str, ";" );
+            WAssert( tokens.size() >= 16, "There weren't 16 values for a 4x4 Matrix" );
+
+            size_t idx = 0;
+            for ( size_t row = 0; row < 4; ++row )
+            {
+                for ( size_t col = 0; col < 4; ++col )
+                {
+                    c( row, col ) = boost::lexical_cast< double >( tokens[ idx ] );
+                    idx++;
+                }
+            }
+
+            return c;
         }
 
         /**
@@ -555,7 +575,64 @@ namespace PROPERTY_TYPE_HELPER
          */
         std::string asString( const WPVBaseTypes::PV_MATRIX4X4& v )
         {
-            return toString( v );
+            std::ostringstream out;
+            for ( size_t row = 0; row < 4; ++row )
+            {
+                for ( size_t col = 0; col < 4; ++col )
+                {
+                    out << v( row, col ) << ";";
+                }
+            }
+            return out.str();
+        }
+    };
+
+    /**
+     * Class helping to create a new instance of the property content from an old one. Selections need this special care since they contain not
+     * serializable content which needs to be acquired from its predecessor instance.
+     */
+    template<>
+    class WStringConversion< WPVBaseTypes::PV_POSITION >
+    {
+    public:
+        /**
+         * Creates a new instance of the type from a given string. Some classes need a predecessor which is also specified here.
+         *
+         * \param str the new value as string
+         *
+         * \return the new instance
+         */
+        WPVBaseTypes::PV_POSITION create( const WPVBaseTypes::PV_POSITION& /*old*/, const std::string str )
+        {
+            WPVBaseTypes::PV_POSITION c;
+            std::vector< std::string > tokens;
+            tokens = string_utils::tokenize( str, ";" );
+            WAssert( tokens.size() >= 3, "There weren't 3 values for a 3D vector" );
+
+            size_t idx = 0;
+            for ( size_t col = 0; col < 3; ++col )
+            {
+                c[ col ] = boost::lexical_cast< double >( tokens[ idx ] );
+                idx++;
+            }
+            return c;
+        }
+
+        /**
+         * Creates a string from the specified value.
+         *
+         * \param v the value to convert
+         *
+         * \return the string representation
+         */
+        std::string asString( const WPVBaseTypes::PV_POSITION& v )
+        {
+            std::ostringstream out;
+            for ( size_t col = 0; col < 3; ++col )
+            {
+                out << v[ col ] << ";";
+            }
+            return out.str();
         }
     };
 }

src/common/WSharedObject.h

@@ -83,7 +83,7 @@ public:
      *
      * \return the condition
      */
-    boost::shared_ptr< WCondition > getChangeCondition();
+    boost::shared_ptr< WCondition > getChangeCondition() const;
 
 protected:
 
@@ -122,7 +122,7 @@ WSharedObject< T >::~WSharedObject()
 }
 
 template < typename T >
-boost::shared_ptr< WCondition > WSharedObject< T >::getChangeCondition()
+boost::shared_ptr< WCondition > WSharedObject< T >::getChangeCondition() const
 {
     return m_changeCondition;
 }

src/common/math/WLinearAlgebraFunctions.cpp

@@ -24,17 +24,16 @@
 
 #include <vector>
 
+#include "../../ext/Eigen/SVD"
+
 #include "../WAssert.h"
+
 #include "WLinearAlgebraFunctions.h"
 #include "WMatrix.h"
 #include "WMatrix4x4.h"
 #include "WValue.h"
 #include "WVector3D.h"
 
-#ifdef OW_USE_OSSIM
-    #include "WOSSIMHelper.h"
-#endif
-
 WVector3D multMatrixWithVector3D( WMatrix<double> mat, WVector3D vec )
 {
     WVector3D result;
@@ -301,32 +300,32 @@ bool linearIndependent( const WVector3D& u, const WVector3D& v )
     return true;
 }
 
-void computeSVD( const WMatrix< double >& A,
-                        WMatrix< double >& U,
-                        WMatrix< double >& V,
-                        WValue< double >& S )
+void computeSVD( const WMatrix_2& A,
+                        WMatrix_2& U,
+                        WMatrix_2& V,
+                        WVector_2& S )
 {
-#ifdef OW_USE_OSSIM
-      WOSSIMHelper::computeSVD( A, U, V, S );
-#else
-      (void) A; (void) U; (void) V; (void) S; // NOLINT to prevent "unused variable" warnings
-      WAssert( false, "OpenWalnut must be compiled with OSSIM to support SVD." );
-#endif
+    Eigen::JacobiSVD<WMatrix_2> svd( A, Eigen::ComputeFullU | Eigen::ComputeFullV );
+    U = svd.matrixU();
+    V = svd.matrixV();
+    S = svd.singularValues();
 }
 
-WMatrix<double> pseudoInverse( const WMatrix<double>& input )
+WMatrix_2 pseudoInverse( const WMatrix_2& input )
 {
     // calc pseudo inverse
-    WMatrix< double > U( input.getNbRows(), input.getNbCols() );
-    WMatrix< double > V( input.getNbCols(), input.getNbCols() );
-    WValue< double > Svec( input.getNbCols() );
+    WMatrix_2 U( input.rows(), input.cols() );
+    WMatrix_2 V( input.cols(), input.cols() );
+    WVector_2 Svec( input.cols() );
     computeSVD( input, U, V, Svec );
 
     // create diagonal matrix S
-    WMatrix< double > S( input.getNbCols(), input.getNbCols() );
-
-    for ( size_t i = 0; i < Svec.size() && i < S.getNbRows() && i < S.getNbCols(); i++ )
-      S( i, i ) = ( Svec[ i ] == 0.0 ) ? 0.0 : 1.0 / Svec[ i ];
+    WMatrix_2 S( input.cols(), input.cols() );
+    S.setZero();
+    for ( int i = 0; i < Svec.size() && i < S.rows() && i < S.cols(); i++ )
+    {
+        S( i, i ) = ( Svec[ i ] == 0.0 ) ? 0.0 : 1.0 / Svec[ i ];
+    }
 
-    return WMatrix< double >( V*S*U.transposed() );
+    return WMatrix_2( V*S*U.transpose() );
 }

src/common/math/WLinearAlgebraFunctions.h

@@ -26,6 +26,7 @@
 #define WLINEARALGEBRAFUNCTIONS_H
 
 #include "../WExportCommon.h"
+#include "WMatrix.h"
 
 namespace osg
 {
@@ -115,8 +116,7 @@ bool OWCOMMON_EXPORT linearIndependent( const WVector3D& u, const WVector3D& v )
  *
  * \note This function needs the OSSIM library.
  */
-void OWCOMMON_EXPORT computeSVD( const WMatrix< double >& A, WMatrix< double >& U,
-        WMatrix< double >& V, WValue< double >& S );
+void OWCOMMON_EXPORT computeSVD( const WMatrix_2& A, WMatrix_2& U, WMatrix_2& V, WVector_2& S );
 
 /**
  * Calculates for a matrix the pseudo inverse.
@@ -126,6 +126,6 @@ void OWCOMMON_EXPORT computeSVD( const WMatrix< double >& A, WMatrix< double >&
  * \return Inverted Matrix
  *
  */
-WMatrix< double > OWCOMMON_EXPORT pseudoInverse( const WMatrix<double>& input );
+WMatrix_2 OWCOMMON_EXPORT pseudoInverse( const WMatrix_2& input );
 
 #endif  // WLINEARALGEBRAFUNCTIONS_H

src/common/math/WMatrix.h

@@ -31,12 +31,83 @@
 #include "WValue.h"
 #include "WVector3D.h"
 
+#include "../WDefines.h"
+#include "../../ext/Eigen/Core"
+#include "../../ext/Eigen/LU"
+
+/**
+ * A double 3 times 3 matrix. Stack-allocated. Column Major!
+ *
+ * Column Major indexes:
+ * [0 3 6
+ *  1 4 7
+ *  2 5 8]
+ * If you want to access coefficients using the operator( size_t, size_t ), the first parameter is still the row index, starting with 0.
+ *
+ * \see http://eigen.tuxfamily.org/dox/classEigen_1_1Matrix.html
+ * \see http://eigen.tuxfamily.org/dox/classEigen_1_1MatrixBase.html
+ */
+typedef Eigen::Matrix< double, 3, 3 > WMatrix3x3_2;
+
+/**
+ * A double 4 times 4 matrix. Stack-allocated. Column Major!
+ *
+ * Column Major indexes:
+ * [0 4 8  12
+ *  1 5 9  13
+ *  2 6 10 14
+ *  3 7 11 15]
+ * If you want to access coefficients using the operator( size_t, size_t ), the first parameter is still the row index, starting with 0.
+ *
+ * \see http://eigen.tuxfamily.org/dox/classEigen_1_1Matrix.html
+ * \see http://eigen.tuxfamily.org/dox/classEigen_1_1MatrixBase.html
+ */
+typedef Eigen::Matrix< double, 4, 4 > WMatrix4x4_2;
+
+/**
+ * A double matrix of dynamic size. Heap-allocated. Column Major!
+ * If you want to access coefficients using the operator( size_t, size_t ), the first parameter is still the row index, starting with 0.
+ *
+ * \see http://eigen.tuxfamily.org/dox/classEigen_1_1Matrix.html
+ * \see http://eigen.tuxfamily.org/dox/classEigen_1_1MatrixBase.html
+ */
+typedef Eigen::MatrixXd WMatrix_2;
+
+/**
+ * A complex double matrix of dynamic size. Heap-allocated.
+ * If you want to access coefficients using the operator( size_t, size_t ), the first parameter is still the row index, starting with 0.
+ *
+ * \see http://eigen.tuxfamily.org/dox/classEigen_1_1Matrix.html
+ * \see http://eigen.tuxfamily.org/dox/classEigen_1_1MatrixBase.html
+ */
+typedef Eigen::MatrixXcd WMatrixComplex_2;
+
+/**
+ * Converts a given WMatrix4x4_2 to an osg matrix.
+ *
+ * \param m the matrix to convert
+ *
+ * \return the converted matrix
+ */
+inline osg::Matrixd toOsgMatrixd( WMatrix4x4_2 m )
+{
+    osg::Matrixd m2;
+    for ( size_t row = 0; row < 4; ++row )
+    {
+        for ( size_t col = 0; col < 4; ++col )
+        {
+            m2( row, col ) = m( row, col );
+        }
+    }
+    return m2;
+}
+
 /**
  * Matrix template class with variable number of rows and columns.
  * The access function are row-major, which means that the rows
  * are the first parameter or index.
  */
-template< typename T > class WMatrix : public WValue< T >
+template< typename T > class OW_API_DEPRECATED WMatrix : public WValue< T >
 {
 public:
     /**

src/common/math/WMatrix4x4.h

@@ -36,10 +36,12 @@
 #include "../WAssert.h"
 #include "../WStringUtils.h"
 
+#include "../WDefines.h"
+
 /**
  * Use osg 4x4 matrices as WMatrix4x4
  */
-typedef osg::Matrixd WMatrix4x4;
+OW_API_DEPRECATED typedef osg::Matrixd WMatrix4x4;
 
 /**
  * Write a 4x4 matrix in string representation.
@@ -48,7 +50,7 @@ typedef osg::Matrixd WMatrix4x4;
  *
  * \return the matrix as string
  */
-inline std::string toString( const WMatrix4x4& c )
+/*inline std::string toString( const WMatrix4x4& c )
 {
     std::ostringstream out;
     for ( size_t row = 0; row < 4; ++row )
@@ -60,7 +62,7 @@ inline std::string toString( const WMatrix4x4& c )
     }
     return out.str();
 }
-
+*/
 /**
  * Read a 4x4 matrix in string representation from the given string.
  *
@@ -68,7 +70,7 @@ inline std::string toString( const WMatrix4x4& c )
  *
  * \return the matrix
  */
-inline WMatrix4x4 fromString( std::string str )
+/*inline WMatrix4x4 fromString( std::string str )
 {
     WMatrix4x4 c;
     std::vector< std::string > tokens;
@@ -86,6 +88,6 @@ inline WMatrix4x4 fromString( std::string str )
     }
 
     return c;
-}
+}*/
 
 #endif  // WMATRIX4X4_H

src/common/math/WSymmetricSphericalHarmonic.h

@@ -31,7 +31,7 @@
 #include "WMath.h"
 #include "WMatrix.h"
 #include "WUnitSphereCoordinates.h"
-#include "WValue.h"
+#include "WVector3D.h"
 
 /**
  * Class for symmetric spherical harmonics
@@ -50,7 +50,7 @@ public:
      * Constructor.
      * \param SHCoefficients the initial coefficients (stored like in the mentioned Descoteaux paper).
      */
-    explicit WSymmetricSphericalHarmonic( const WValue<double>& SHCoefficients );
+    explicit WSymmetricSphericalHarmonic( const WVector_2& SHCoefficients );
 
     /**
      * Destructor.
@@ -73,17 +73,17 @@ public:
     /**
      * Returns the used coefficients (stored like in the mentioned 2007 Descoteaux paper).
      */
-    const WValue<double>& getCoefficients() const;
+    const WVector_2& getCoefficients() const;
 
     /**
      * Returns the coefficients for Schultz' SH base.
      */
-    WValue< double > getCoefficientsSchultz() const;
+    WVector_2 getCoefficientsSchultz() const;
 
     /**
      * Returns the coefficients for the complex base.
      */
-    WValue< std::complex< double > > getCoefficientsComplex() const;
+    WVectorComplex_2 getCoefficientsComplex() const;
 
     /**
      * Applies the Funk-Radon-Transformation. This is faster than matrix multiplication.
@@ -91,7 +91,7 @@ public:
      *
      * \param frtMat the frt matrix as calculated by calcFRTMatrix()
      */
-    void applyFunkRadonTransformation( WMatrix< double > const& frtMat );
+    void applyFunkRadonTransformation( const WMatrix_2& frtMat );
 
     /**
      * Return the order of the spherical harmonic.
@@ -125,7 +125,7 @@ public:
      *
      * \return The generalized fractional anisotropy.
      */
-    double calcGFA( WMatrix< double > const& B ) const;
+    double calcGFA( const WMatrix_2& B ) const;
 
     /**
     * This calculates the transformation/fitting matrix T like in the 2007 Descoteaux paper. The orientations are given as WVector3D.
@@ -135,10 +135,10 @@ public:
     * \param withFRT include the Funk-Radon-Transformation?
     * \return Transformation matrix
     */
-    static WMatrix<double> getSHFittingMatrix( const std::vector< WVector3D >& orientations,
-                                                      int order,
-                                                      double lambda,
-                                                      bool withFRT );
+    static WMatrix_2 getSHFittingMatrix( const std::vector< WVector3D >& orientations,
+                                         int order,
+                                         double lambda,
+                                         bool withFRT );
 
     /**
     * This calculates the transformation/fitting matrix T like in the 2007 Descoteaux paper. The orientations are given as WUnitSphereCoordinates .
@@ -148,7 +148,7 @@ public:
     * \param withFRT include the Funk-Radon-Transformation?
     * \return Transformation matrix
     */
-    static WMatrix<double> getSHFittingMatrix( const std::vector< WUnitSphereCoordinates >& orientations,
+    static WMatrix_2 getSHFittingMatrix( const std::vector< WUnitSphereCoordinates >& orientations,
                                                       int order,
                                                       double lambda,
                                                       bool withFRT );
@@ -159,7 +159,7 @@ public:
     * \param order The order of the spherical harmonics intended to create
     * \return The base Matrix B
     */
-    static WMatrix<double> calcBaseMatrix( const std::vector< WUnitSphereCoordinates >& orientations, int order );
+    static WMatrix_2 calcBaseMatrix( const std::vector< WUnitSphereCoordinates >& orientations, int order );
 
     /**
     * Calculates the base matrix B for the complex spherical harmonics.
@@ -167,7 +167,7 @@ public:
     * \param order The order of the spherical harmonics intended to create
     * \return The base Matrix B
     */
-    static WMatrix< std::complex< double > > calcComplexBaseMatrix( std::vector< WUnitSphereCoordinates > const& orientations,
+    static WMatrixComplex_2 calcComplexBaseMatrix( std::vector< WUnitSphereCoordinates > const& orientations,
                                                                            int order );
 
     /**
@@ -175,14 +175,14 @@ public:
     * \param order The order of the spherical harmonic
     * \return The smoothing matrix L
     */
-    static WMatrix<double> calcSmoothingMatrix( size_t order );
+    static WMatrix_2 calcSmoothingMatrix( size_t order );
 
     /**
     * Calculates the Funk-Radon-Transformation-Matrix P from the 2007 Descoteaux Paper "Regularized, Fast, and Robust Analytical Q-Ball Imaging"
     * \param order The order of the spherical harmonic
     * \return The Funk-Radon-Matrix P
     */
-    static WMatrix<double> calcFRTMatrix( size_t order );
+    static WMatrix_2 calcFRTMatrix( size_t order );
 
 #ifdef OW_USE_OSSIM
     /**
@@ -191,8 +191,9 @@ public:
      * \param order The order of the symmetric tensor.
      * \param orientations A vector of at least (orderTensor+1) * (orderTensor+2) / 2 orientations.
      */
-    static WMatrix< double > calcSHToTensorSymMatrix( std::size_t order, const std::vector< WUnitSphereCoordinates >& orientations );
+    static WMatrix_2 calcSHToTensorSymMatrix( std::size_t order, const std::vector< WUnitSphereCoordinates >& orientations );
 #endif  // OW_USE_OSSIM
+    void normalize();
 
 protected:
 
@@ -201,7 +202,7 @@ private:
     size_t m_order;
 
     /** coefficients of the spherical harmonic */
-    WValue<double> m_SHCoefficients;
+    WVector_2 m_SHCoefficients;
 };
 
 #endif  // WSYMMETRICSPHERICALHARMONIC_H

src/common/math/WValue.h

@@ -31,6 +31,7 @@
 
 #include "../WAssert.h"
 #include "../WStringUtils.h"
+#include "WVector3D.h"
 
 /**
  * Base class for all higher level values like tensors, vectors, matrices and so on.
@@ -77,6 +78,19 @@ public:
         }
     }
 
+    /**
+     * Create a WValue from the given WVector_2.
+     * \param newValues The WVector_2 with the values..
+     */
+    explicit WValue( const WVector_2& newValues )
+        : m_components( static_cast< std::size_t >( newValues.size() ) )
+    {
+        for ( std::size_t i = 0; i < m_components.size(); ++i )
+        {
+            m_components[ i ] = static_cast< T >( newValues( i ) );
+        }
+    }
+
     /**
      * Get number of components the value consists of.
      */
@@ -320,6 +334,19 @@ public:
         m_components.resize( size );
     }
 
+    /**
+     * Returns this WValue as WVector_2.
+     */
+    WVector_2 toWVector()
+    {
+        WVector_2 result( m_components.size() );
+        for ( size_t i = 0; i < m_components.size(); ++i )
+        {
+            result( i ) = static_cast<double>( m_components[ i ] );
+        }
+        return result;
+    }
+
 protected:
 private:
     /**

src/common/math/WVector3D.cpp

@@ -23,3 +23,127 @@
 //---------------------------------------------------------------------------
 
 #include "WVector3D.h"
+
+osg::Vec3f toOsgVec3f( const WVector3D_2& v )
+{
+    return osg::Vec3f( v( 0 ), v( 1 ), v( 2 ) );
+}
+
+WVector3D toWVector3D( const WVector3D_2& v )
+{
+    return WVector3D( v( 0 ), v( 1 ), v( 2 ) );
+}
+
+WVector3D_2 toWVector3D_2( const WVector3D& v )
+{
+    return WVector3D_2( v[ 0 ], v[ 1 ], v[ 2 ] );
+}
+
+WVector3D_2 toWVector3D_2( const osg::Vec3f& v )
+{
+    return WVector3D_2( v[ 0 ], v[ 1 ], v[ 2 ] );
+}
+
+WVector3D::WVector3D( osg::Vec3d vec ) :
+    osg::Vec3d( vec )
+{
+}
+
+WVector3D::WVector3D() :
+    osg::Vec3d()
+{
+}
+
+WVector3D::WVector3D( osg::Vec3d::value_type x, osg::Vec3d::value_type y, osg::Vec3d::value_type z ) :
+    osg::Vec3d( x, y, z )
+{
+}
+
+const WVector3D WVector3D::operator+( const WVector3D& addend ) const
+{
+    WVector3D result( *this );
+    result += addend;
+    return result;
+}
+
+const WVector3D WVector3D::operator-( const WVector3D& subtrahend ) const
+{
+    WVector3D result( *this );
+    result -= subtrahend;
+    return result;
+}
+
+size_t WVector3D::size() const
+{
+    return num_components;
+}
+
+osg::Vec3d::value_type WVector3D::normSquare() const
+{
+    return this->length2();
+}
+
+osg::Vec3d::value_type WVector3D::dotProduct( const WVector3D& factor2 ) const
+{
+    return *this * factor2;
+}<