mirror of
https://github.com/OpenCMT/uLib.git
synced 2025-12-06 07:21:31 +01:00
422 lines
15 KiB
C++
422 lines
15 KiB
C++
/*//////////////////////////////////////////////////////////////////////////////
|
|
// CMT Cosmic Muon Tomography project //////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
|
|
All rights reserved
|
|
|
|
Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
|
|
|
|
------------------------------------------------------------------
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 3.0 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with this library.
|
|
|
|
//////////////////////////////////////////////////////////////////////////////*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
* <one line to give the program's name and a brief idea of what it does.>
|
|
* Copyright (C) 2012 Andrea Rigoni Garola <andrea@pcimg05>
|
|
*
|
|
* This library is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as
|
|
* published by the Free Software Foundation; either version 2.1 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
* 02110-1301 USA
|
|
*
|
|
*/
|
|
|
|
|
|
#ifndef ULIB_DENSEMATRIX_H
|
|
#define ULIB_DENSEMATRIX_H
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <Eigen/Core>
|
|
#include <Eigen/Dense>
|
|
|
|
#include "Core/Types.h"
|
|
#include "Core/Serializable.h"
|
|
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// NEW PART //
|
|
|
|
|
|
|
|
namespace uLib {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// DENSE MATRIX DEFINITION /////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
using Eigen::Matrix;
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// DENSE TYPES DEFINITIONS /////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, Size, SizeSuffix) \
|
|
typedef Eigen::Matrix<Type, Size, Size> Matrix##SizeSuffix##TypeSuffix; \
|
|
typedef Eigen::Matrix<Type, Size, 1> Vector##SizeSuffix##TypeSuffix; \
|
|
typedef Eigen::Matrix<Type, 1, Size> RowVector##SizeSuffix##TypeSuffix; \
|
|
// /* IMPORT INTERFACES */ \
|
|
// typedef Interface::DenseMatrix<Type, mpl::int_<Size>, mpl::int_<Size> > IMatrix##SizeSuffix##TypeSuffix; \
|
|
// typedef Interface::DenseArray<Type, mpl::int_<Size> > IVector##SizeSuffix##TypeSuffix; \
|
|
// typedef Interface::DenseArray<Type, mpl::int_<Size> > IRowVector##SizeSuffix##TypeSuffix;
|
|
|
|
|
|
#define EIGEN_MAKE_TYPEDEFS_ALL_SIZES(Type, TypeSuffix) \
|
|
EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 2, 2) \
|
|
EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 3, 3) \
|
|
EIGEN_MAKE_TYPEDEFS(Type, TypeSuffix, 4, 4)
|
|
|
|
EIGEN_MAKE_TYPEDEFS_ALL_SIZES(int, i)
|
|
EIGEN_MAKE_TYPEDEFS_ALL_SIZES(float, f)
|
|
EIGEN_MAKE_TYPEDEFS_ALL_SIZES(double, d)
|
|
EIGEN_MAKE_TYPEDEFS_ALL_SIZES(std::complex<float>, cf)
|
|
EIGEN_MAKE_TYPEDEFS_ALL_SIZES(std::complex<double>, cd)
|
|
|
|
#undef EIGEN_MAKE_TYPEDEFS_ALL_SIZES
|
|
#undef EIGEN_MAKE_TYPEDEFS
|
|
|
|
|
|
|
|
|
|
//#define EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, Size, SizeSuffix) \
|
|
///** \ingroup arraytypedefs */ \
|
|
//typedef Eigen::Array<Type, Size, Size> Array##SizeSuffix##SizeSuffix##TypeSuffix; \
|
|
///** \ingroup arraytypedefs */ \
|
|
//typedef Eigen::Array<Type, Size, 1> Array##SizeSuffix##TypeSuffix;
|
|
|
|
//#define EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, Size) \
|
|
///** \ingroup arraytypedefs */ \
|
|
//typedef Eigen::Array<Type, Size, Dynamic> Array##Size##X##TypeSuffix; \
|
|
///** \ingroup arraytypedefs */ \
|
|
//typedef Eigen::Array<Type, Dynamic, Size> Array##X##Size##TypeSuffix;
|
|
|
|
//#define EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(Type, TypeSuffix) \
|
|
//EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 2, 2) \
|
|
//EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 3, 3) \
|
|
//EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, 4, 4) \
|
|
//EIGEN_MAKE_ARRAY_TYPEDEFS(Type, TypeSuffix, Dynamic, X) \
|
|
//EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 2) \
|
|
//EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 3) \
|
|
//EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Type, TypeSuffix, 4)
|
|
|
|
//EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(int, i)
|
|
//EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(float, f)
|
|
//EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(double, d)
|
|
//EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(std::complex<float>, cf)
|
|
//EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(std::complex<double>, cd)
|
|
|
|
//#undef EIGEN_MAKE_ARRAY_TYPEDEFS_ALL_SIZES
|
|
//#undef EIGEN_MAKE_ARRAY_TYPEDEFS
|
|
//#undef EIGEN_MAKE_ARRAY_TYPEDEFS_LARGE
|
|
|
|
//#define EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, SizeSuffix) \
|
|
//using Eigen::Matrix##SizeSuffix##TypeSuffix; \
|
|
//using Eigen::Vector##SizeSuffix##TypeSuffix; \
|
|
//using Eigen::RowVector##SizeSuffix##TypeSuffix;
|
|
|
|
//#define EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(TypeSuffix) \
|
|
//EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 2) \
|
|
//EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 3) \
|
|
//EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, 4) \
|
|
//EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE_AND_SIZE(TypeSuffix, X) \
|
|
|
|
//#define EIGEN_USING_ARRAY_TYPEDEFS \
|
|
//EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(i) \
|
|
//EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(f) \
|
|
//EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(d) \
|
|
//EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(cf) \
|
|
//EIGEN_USING_ARRAY_TYPEDEFS_FOR_TYPE(cd)
|
|
|
|
|
|
|
|
|
|
} // uLib
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// OLD PART //
|
|
|
|
//// BOOST SERIALIZATION ///////////////////////////////////////////////////////
|
|
|
|
#include <boost/algorithm/string.hpp>
|
|
#include <boost/algorithm/string/split.hpp>
|
|
#include <boost/algorithm/string/trim.hpp>
|
|
#include <boost/lexical_cast.hpp>
|
|
#include <boost/serialization/string.hpp>
|
|
#include <boost/serialization/array.hpp>
|
|
|
|
|
|
namespace boost {
|
|
namespace serialization {
|
|
|
|
template<class Archive, class Scalar, int RowsAtCompileTime, int ColsAtCompileTime>
|
|
void serialize(Archive & ar, ::Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime> & m, const unsigned int /*version*/) {
|
|
ar & boost::serialization::make_array(m.data(), RowsAtCompileTime * ColsAtCompileTime);
|
|
}
|
|
|
|
} // serialization
|
|
} // boost
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// EIGEN VECTOR STREAM INTERACTIONS ////////////////////////////////////////////
|
|
// this is needed by boost::lexical_cast to cope with Eigens Vectors ///////////
|
|
namespace Eigen {
|
|
|
|
template <typename C, typename T, int size>
|
|
std::istream & operator >> (std::basic_istream<C> &is, Eigen::Matrix<T,size,1> &vec) {
|
|
std::basic_string<C> str;
|
|
for( unsigned int i=0; i<size; i++) {
|
|
is >> std::skipws >> str;
|
|
if(is.fail()) vec(i) = 0;
|
|
else vec(i) = boost::lexical_cast<T>(str);
|
|
}
|
|
return is;
|
|
}
|
|
|
|
template <typename C, typename T, int size>
|
|
Eigen::Matrix<T,size,1> & operator >> (const std::basic_string<C> &str, Eigen::Matrix<T,size,1> &vec) {
|
|
std::stringstream ss(str);
|
|
ss >> vec;
|
|
return vec;
|
|
}
|
|
|
|
template <typename C, typename T, int size>
|
|
std::basic_ostream<C> & operator << (std::basic_ostream<C> &os, const Eigen::Matrix<T,size,1> &vec) {
|
|
// os << "[" << vec.transpose() << "]T"; // TODO: read and write Transposition with a proper symbol
|
|
os << vec.transpose();
|
|
return os;
|
|
}
|
|
|
|
template <typename C, typename T, int size>
|
|
std::basic_string<C> & operator << (std::basic_string<C> &str, const Eigen::Matrix<T,size,1> &vec) {
|
|
std::basic_stringstream<C> ss;
|
|
ss << vec;
|
|
str += ss.str();
|
|
return str;
|
|
}
|
|
|
|
|
|
} // Eigen
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
namespace uLib {
|
|
|
|
|
|
typedef int Scalari;
|
|
typedef unsigned int Scalarui;
|
|
typedef long Scalarl;
|
|
typedef unsigned long Scalarul;
|
|
typedef float Scalarf;
|
|
typedef double Scalard;
|
|
|
|
} // uLib
|
|
|
|
//typedef Eigen::Matrix<int,1,1> Matrix1i;
|
|
//typedef Eigen::Matrix2i Matrix2i;
|
|
//typedef Eigen::Matrix3i Matrix3i;
|
|
//typedef Eigen::Matrix4i Matrix4i;
|
|
|
|
//typedef Eigen::Matrix<float,1,1> Matrix1f;
|
|
//typedef Eigen::Matrix2f Matrix2f;
|
|
//typedef Eigen::Matrix3f Matrix3f;
|
|
//typedef Eigen::Matrix4f Matrix4f;
|
|
|
|
//typedef Eigen::Matrix<int,1,1> Vector1i;
|
|
//typedef Eigen::Vector2i Vector2i;
|
|
//typedef Eigen::Vector3i Vector3i;
|
|
//typedef Eigen::Vector4i Vector4i;
|
|
|
|
//typedef Eigen::Matrix<float,1,1> Vector1f;
|
|
//typedef Eigen::Vector2f Vector2f;
|
|
//typedef Eigen::Vector3f Vector3f;
|
|
//typedef Eigen::Vector4f Vector4f;
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Vector String interaction ///////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
///*! Given a string consisting of a series of doubles with some
|
|
//* delimiter, return an Eigen::Vector populated with those
|
|
//* values, in the same order as they are given in the string.
|
|
//*
|
|
//* \param vec A double vector to be populated with the results
|
|
//* \param str A string to be parsed as a series of doubles.
|
|
//* \param delim Delimiters of the text (a typical default is " ," for comma and space-delimited text
|
|
//*
|
|
//*/
|
|
//template <typename T, int size>
|
|
//void VectorxT_StringTo(Eigen::Matrix<T,size,1> &vec, std::string str, const char *delim = " ,;\t\n") {
|
|
// std::vector<std::string> strvec;
|
|
|
|
// boost::algorithm::trim_if( str, boost::algorithm::is_any_of(delim));
|
|
// boost::algorithm::split(strvec,str,boost::algorithm::is_any_of(delim), boost::algorithm::token_compress_on);
|
|
|
|
// for( unsigned int i=0; i<size; i++) {
|
|
// vec(i) = boost::lexical_cast<T>(strvec[i]);
|
|
// }
|
|
//}
|
|
|
|
//template <typename T, int size>
|
|
//std::string VectorxT_ToString(const Eigen::Matrix<T,size,1> &vec) {
|
|
// std::stringstream sst;
|
|
// sst << vec.transpose();
|
|
// return sst.str();
|
|
//}
|
|
|
|
|
|
////template <typename T, int size>
|
|
////Eigen::Matrix<T,size,1> & operator >> (std::istream &is, Eigen::Matrix<T,size,1> &vec) {
|
|
////}
|
|
|
|
//template <typename T, int size>
|
|
//void operator>> (std::string& str, Eigen::Matrix<T,size,1> &vec){
|
|
// VectorxT_StringTo(vec,str);
|
|
//}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
////// HOMOGENEOUS VECTORS //////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//template <bool p>
|
|
//class _HPoint3f : public Eigen::Matrix< Scalarf,4,1 > {
|
|
//public:
|
|
// typedef Eigen::Matrix< Scalarf,4,1 > BaseClass;
|
|
|
|
// _HPoint3f<p>() : BaseClass(0,0,0,p) {}
|
|
// _HPoint3f<p>(float x,float y,float z) : BaseClass(x,y,z,p) {}
|
|
// _HPoint3f<p>(Vector3f &in) : BaseClass(in.homogeneous()) { this->w = p; }
|
|
|
|
// // This constructor allows to construct MyVectorType from Eigen expressions
|
|
// template<typename OtherDerived>
|
|
// inline _HPoint3f<p>(const Eigen::MatrixBase<OtherDerived>& other)
|
|
// : BaseClass(other)
|
|
// { }
|
|
|
|
// // This method allows to assign Eigen expressions to Vector3H
|
|
// template<typename OtherDerived>
|
|
// inline _HPoint3f<p> & operator= (const Eigen::MatrixBase <OtherDerived>& other)
|
|
// {
|
|
// this->BaseClass::operator=(other);
|
|
// return *this;
|
|
// }
|
|
|
|
//};
|
|
//typedef _HPoint3f<false> Vector4f;
|
|
//typedef _HPoint3f<true> HPoint3f;
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
////// HOMOGENEOUS LINE //////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
//struct _HLine3f
|
|
//{
|
|
// HPoint3f origin;
|
|
// Vector4f direction;
|
|
//};
|
|
//typedef struct _HLine3f HLine3f;
|
|
|
|
//inline std::ostream&
|
|
//operator<< (std::ostream& stream, const HLine3f &line) {
|
|
// stream << "HLine3f(" << "pt[" << line.origin.transpose() <<"] , dr[" << line.direction.transpose() << "]) ";
|
|
// return stream;
|
|
//}
|
|
|
|
|
|
|
|
|
|
//struct _HError3f
|
|
//{
|
|
// Vector4f position_error;
|
|
// Vector4f direction_error;
|
|
//};
|
|
//typedef struct _HError3f HError3f;
|
|
|
|
//inline std::ostream&
|
|
//operator<< (std::ostream& stream, const HError3f &err) {
|
|
// stream << "HError3f(" << "ept[" << err.position_error.transpose() <<"] , edr[" << err.direction_error.transpose() << "]) ";
|
|
// return stream;
|
|
//}
|
|
|
|
|
|
//}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// SERIALIZTION //
|
|
|
|
// NEW //
|
|
ULIB_SERIALIZABLE(uLib::Vector2i)
|
|
ULIB_SERIALIZABLE(uLib::Vector3i)
|
|
ULIB_SERIALIZABLE(uLib::Vector4i)
|
|
ULIB_SERIALIZABLE(uLib::Vector2f)
|
|
ULIB_SERIALIZABLE(uLib::Vector3f)
|
|
ULIB_SERIALIZABLE(uLib::Vector4f)
|
|
ULIB_SERIALIZABLE(uLib::Vector2d)
|
|
ULIB_SERIALIZABLE(uLib::Vector3d)
|
|
ULIB_SERIALIZABLE(uLib::Vector4d)
|
|
|
|
|
|
|
|
//ULIB_SERIALIZABLE(uLib::HPoint3f)
|
|
//ULIB_SERIALIZABLE(uLib::Vector4f)
|
|
//ULIB_SERIALIZABLE(uLib::HLine3f)
|
|
//ULIB_SERIALIZABLE(uLib::HError3f)
|
|
|
|
|
|
|
|
|
|
|
|
#endif // U_DENSEMATRIX_H
|