Commit 874e625f authored by Sebastian Eichelbaum's avatar Sebastian Eichelbaum

[MERGE]

parents 8281c831 e1645ebf
......@@ -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();
}
};
}
......
......@@ -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;
}
......
......@@ -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() );
}
......@@ -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
......@@ -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:
/**
......
......@@ -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
......@@ -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
......@@ -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:
/**
......
......@@ -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;
}<