├── CMakeLists.txt ├── Examples ├── Lafida │ ├── InteriorOrientationFisheye0.yaml │ ├── InteriorOrientationFisheye1.yaml │ ├── InteriorOrientationFisheye2.yaml │ ├── MultiCamSys_Calibration.yaml │ ├── Slam_Settings_indoor1.yaml │ ├── Slam_Settings_indoor2.yaml │ ├── Slam_Settings_indoor3.yaml │ ├── Slam_Settings_indoor4.yaml │ ├── mult_col_slam_lafida.cpp │ └── multi_col_slam_lafida └── small_orb_omni_voc_9_6.yml ├── README.md ├── ThirdParty ├── DBoW2 │ ├── CMakeLists.txt │ ├── DBoW2 │ │ ├── BowVector.cpp │ │ ├── BowVector.h │ │ ├── FClass.h │ │ ├── FORB.cpp │ │ ├── FORB.h │ │ ├── FeatureVector.cpp │ │ ├── FeatureVector.h │ │ ├── ScoringObject.cpp │ │ ├── ScoringObject.h │ │ └── TemplatedVocabulary.h │ ├── DUtils │ │ ├── Random.cpp │ │ ├── Random.h │ │ ├── Timestamp.cpp │ │ └── Timestamp.h │ ├── LICENSE.txt │ ├── README.txt │ └── lib │ │ └── libDBoW2.so ├── Eigen │ ├── CMakeLists.txt │ ├── COPYING.BSD │ ├── COPYING.GPL │ ├── COPYING.LGPL │ ├── COPYING.MINPACK │ ├── COPYING.MPL2 │ ├── COPYING.README │ ├── Eigen │ │ ├── Array │ │ ├── CMakeLists.txt │ │ ├── Cholesky │ │ ├── CholmodSupport │ │ ├── Core │ │ ├── Dense │ │ ├── Eigen │ │ ├── Eigen2Support │ │ ├── Eigenvalues │ │ ├── Geometry │ │ ├── Householder │ │ ├── IterativeLinearSolvers │ │ ├── Jacobi │ │ ├── LU │ │ ├── LeastSquares │ │ ├── MetisSupport │ │ ├── OrderingMethods │ │ ├── PaStiXSupport │ │ ├── PardisoSupport │ │ ├── QR │ │ ├── QtAlignedMalloc │ │ ├── SPQRSupport │ │ ├── SVD │ │ ├── Sparse │ │ ├── SparseCholesky │ │ ├── SparseCore │ │ ├── SparseLU │ │ ├── SparseQR │ │ ├── StdDeque │ │ ├── StdList │ │ ├── StdVector │ │ ├── SuperLUSupport │ │ ├── UmfPackSupport │ │ └── src │ │ │ ├── CMakeLists.txt │ │ │ ├── Cholesky │ │ │ ├── CMakeLists.txt │ │ │ ├── LDLT.h │ │ │ ├── LLT.h │ │ │ └── LLT_MKL.h │ │ │ ├── CholmodSupport │ │ │ ├── CMakeLists.txt │ │ │ └── CholmodSupport.h │ │ │ ├── Core │ │ │ ├── Array.h │ │ │ ├── ArrayBase.h │ │ │ ├── ArrayWrapper.h │ │ │ ├── Assign.h │ │ │ ├── Assign_MKL.h │ │ │ ├── BandMatrix.h │ │ │ ├── Block.h │ │ │ ├── BooleanRedux.h │ │ │ ├── CMakeLists.txt │ │ │ ├── CommaInitializer.h │ │ │ ├── CoreIterators.h │ │ │ ├── CwiseBinaryOp.h │ │ │ ├── CwiseNullaryOp.h │ │ │ ├── CwiseUnaryOp.h │ │ │ ├── CwiseUnaryView.h │ │ │ ├── DenseBase.h │ │ │ ├── DenseCoeffsBase.h │ │ │ ├── DenseStorage.h │ │ │ ├── Diagonal.h │ │ │ ├── DiagonalMatrix.h │ │ │ ├── DiagonalProduct.h │ │ │ ├── Dot.h │ │ │ ├── EigenBase.h │ │ │ ├── Flagged.h │ │ │ ├── ForceAlignedAccess.h │ │ │ ├── Functors.h │ │ │ ├── Fuzzy.h │ │ │ ├── GeneralProduct.h │ │ │ ├── GenericPacketMath.h │ │ │ ├── GlobalFunctions.h │ │ │ ├── IO.h │ │ │ ├── Map.h │ │ │ ├── MapBase.h │ │ │ ├── MathFunctions.h │ │ │ ├── Matrix.h │ │ │ ├── MatrixBase.h │ │ │ ├── NestByValue.h │ │ │ ├── NoAlias.h │ │ │ ├── NumTraits.h │ │ │ ├── PermutationMatrix.h │ │ │ ├── PlainObjectBase.h │ │ │ ├── ProductBase.h │ │ │ ├── Random.h │ │ │ ├── Redux.h │ │ │ ├── Ref.h │ │ │ ├── Replicate.h │ │ │ ├── ReturnByValue.h │ │ │ ├── Reverse.h │ │ │ ├── Select.h │ │ │ ├── SelfAdjointView.h │ │ │ ├── SelfCwiseBinaryOp.h │ │ │ ├── SolveTriangular.h │ │ │ ├── StableNorm.h │ │ │ ├── Stride.h │ │ │ ├── Swap.h │ │ │ ├── Transpose.h │ │ │ ├── Transpositions.h │ │ │ ├── TriangularMatrix.h │ │ │ ├── VectorBlock.h │ │ │ ├── VectorwiseOp.h │ │ │ ├── Visitor.h │ │ │ ├── arch │ │ │ │ ├── AltiVec │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── Complex.h │ │ │ │ │ └── PacketMath.h │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── Default │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ └── Settings.h │ │ │ │ ├── NEON │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── Complex.h │ │ │ │ │ └── PacketMath.h │ │ │ │ └── SSE │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── Complex.h │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ └── PacketMath.h │ │ │ ├── products │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── CoeffBasedProduct.h │ │ │ │ ├── GeneralBlockPanelKernel.h │ │ │ │ ├── GeneralMatrixMatrix.h │ │ │ │ ├── GeneralMatrixMatrixTriangular.h │ │ │ │ ├── GeneralMatrixMatrixTriangular_MKL.h │ │ │ │ ├── GeneralMatrixMatrix_MKL.h │ │ │ │ ├── GeneralMatrixVector.h │ │ │ │ ├── GeneralMatrixVector_MKL.h │ │ │ │ ├── Parallelizer.h │ │ │ │ ├── SelfadjointMatrixMatrix.h │ │ │ │ ├── SelfadjointMatrixMatrix_MKL.h │ │ │ │ ├── SelfadjointMatrixVector.h │ │ │ │ ├── SelfadjointMatrixVector_MKL.h │ │ │ │ ├── SelfadjointProduct.h │ │ │ │ ├── SelfadjointRank2Update.h │ │ │ │ ├── TriangularMatrixMatrix.h │ │ │ │ ├── TriangularMatrixMatrix_MKL.h │ │ │ │ ├── TriangularMatrixVector.h │ │ │ │ ├── TriangularMatrixVector_MKL.h │ │ │ │ ├── TriangularSolverMatrix.h │ │ │ │ ├── TriangularSolverMatrix_MKL.h │ │ │ │ └── TriangularSolverVector.h │ │ │ └── util │ │ │ │ ├── BlasUtil.h │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── Constants.h │ │ │ │ ├── DisableStupidWarnings.h │ │ │ │ ├── ForwardDeclarations.h │ │ │ │ ├── MKL_support.h │ │ │ │ ├── Macros.h │ │ │ │ ├── Memory.h │ │ │ │ ├── Meta.h │ │ │ │ ├── NonMPL2.h │ │ │ │ ├── ReenableStupidWarnings.h │ │ │ │ ├── StaticAssert.h │ │ │ │ └── XprHelper.h │ │ │ ├── Eigen2Support │ │ │ ├── Block.h │ │ │ ├── CMakeLists.txt │ │ │ ├── Cwise.h │ │ │ ├── CwiseOperators.h │ │ │ ├── Geometry │ │ │ │ ├── AlignedBox.h │ │ │ │ ├── All.h │ │ │ │ ├── AngleAxis.h │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── Hyperplane.h │ │ │ │ ├── ParametrizedLine.h │ │ │ │ ├── Quaternion.h │ │ │ │ ├── Rotation2D.h │ │ │ │ ├── RotationBase.h │ │ │ │ ├── Scaling.h │ │ │ │ ├── Transform.h │ │ │ │ └── Translation.h │ │ │ ├── LU.h │ │ │ ├── Lazy.h │ │ │ ├── LeastSquares.h │ │ │ ├── Macros.h │ │ │ ├── MathFunctions.h │ │ │ ├── Memory.h │ │ │ ├── Meta.h │ │ │ ├── Minor.h │ │ │ ├── QR.h │ │ │ ├── SVD.h │ │ │ ├── TriangularSolver.h │ │ │ └── VectorBlock.h │ │ │ ├── Eigenvalues │ │ │ ├── CMakeLists.txt │ │ │ ├── ComplexEigenSolver.h │ │ │ ├── ComplexSchur.h │ │ │ ├── ComplexSchur_MKL.h │ │ │ ├── EigenSolver.h │ │ │ ├── GeneralizedEigenSolver.h │ │ │ ├── GeneralizedSelfAdjointEigenSolver.h │ │ │ ├── HessenbergDecomposition.h │ │ │ ├── MatrixBaseEigenvalues.h │ │ │ ├── RealQZ.h │ │ │ ├── RealSchur.h │ │ │ ├── RealSchur_MKL.h │ │ │ ├── SelfAdjointEigenSolver.h │ │ │ ├── SelfAdjointEigenSolver_MKL.h │ │ │ └── Tridiagonalization.h │ │ │ ├── Geometry │ │ │ ├── AlignedBox.h │ │ │ ├── AngleAxis.h │ │ │ ├── CMakeLists.txt │ │ │ ├── EulerAngles.h │ │ │ ├── Homogeneous.h │ │ │ ├── Hyperplane.h │ │ │ ├── OrthoMethods.h │ │ │ ├── ParametrizedLine.h │ │ │ ├── Quaternion.h │ │ │ ├── Rotation2D.h │ │ │ ├── RotationBase.h │ │ │ ├── Scaling.h │ │ │ ├── Transform.h │ │ │ ├── Translation.h │ │ │ ├── Umeyama.h │ │ │ └── arch │ │ │ │ ├── CMakeLists.txt │ │ │ │ └── Geometry_SSE.h │ │ │ ├── Householder │ │ │ ├── BlockHouseholder.h │ │ │ ├── CMakeLists.txt │ │ │ ├── Householder.h │ │ │ └── HouseholderSequence.h │ │ │ ├── IterativeLinearSolvers │ │ │ ├── BasicPreconditioners.h │ │ │ ├── BiCGSTAB.h │ │ │ ├── CMakeLists.txt │ │ │ ├── ConjugateGradient.h │ │ │ ├── IncompleteLUT.h │ │ │ └── IterativeSolverBase.h │ │ │ ├── Jacobi │ │ │ ├── CMakeLists.txt │ │ │ └── Jacobi.h │ │ │ ├── LU │ │ │ ├── CMakeLists.txt │ │ │ ├── Determinant.h │ │ │ ├── FullPivLU.h │ │ │ ├── Inverse.h │ │ │ ├── PartialPivLU.h │ │ │ ├── PartialPivLU_MKL.h │ │ │ └── arch │ │ │ │ ├── CMakeLists.txt │ │ │ │ └── Inverse_SSE.h │ │ │ ├── MetisSupport │ │ │ ├── CMakeLists.txt │ │ │ └── MetisSupport.h │ │ │ ├── OrderingMethods │ │ │ ├── Amd.h │ │ │ ├── CMakeLists.txt │ │ │ ├── Eigen_Colamd.h │ │ │ └── Ordering.h │ │ │ ├── PaStiXSupport │ │ │ ├── CMakeLists.txt │ │ │ └── PaStiXSupport.h │ │ │ ├── PardisoSupport │ │ │ ├── CMakeLists.txt │ │ │ └── PardisoSupport.h │ │ │ ├── QR │ │ │ ├── CMakeLists.txt │ │ │ ├── ColPivHouseholderQR.h │ │ │ ├── ColPivHouseholderQR_MKL.h │ │ │ ├── FullPivHouseholderQR.h │ │ │ ├── HouseholderQR.h │ │ │ └── HouseholderQR_MKL.h │ │ │ ├── SPQRSupport │ │ │ ├── CMakeLists.txt │ │ │ └── SuiteSparseQRSupport.h │ │ │ ├── SVD │ │ │ ├── CMakeLists.txt │ │ │ ├── JacobiSVD.h │ │ │ ├── JacobiSVD_MKL.h │ │ │ └── UpperBidiagonalization.h │ │ │ ├── SparseCholesky │ │ │ ├── CMakeLists.txt │ │ │ ├── SimplicialCholesky.h │ │ │ └── SimplicialCholesky_impl.h │ │ │ ├── SparseCore │ │ │ ├── AmbiVector.h │ │ │ ├── CMakeLists.txt │ │ │ ├── CompressedStorage.h │ │ │ ├── ConservativeSparseSparseProduct.h │ │ │ ├── MappedSparseMatrix.h │ │ │ ├── SparseBlock.h │ │ │ ├── SparseColEtree.h │ │ │ ├── SparseCwiseBinaryOp.h │ │ │ ├── SparseCwiseUnaryOp.h │ │ │ ├── SparseDenseProduct.h │ │ │ ├── SparseDiagonalProduct.h │ │ │ ├── SparseDot.h │ │ │ ├── SparseFuzzy.h │ │ │ ├── SparseMatrix.h │ │ │ ├── SparseMatrixBase.h │ │ │ ├── SparsePermutation.h │ │ │ ├── SparseProduct.h │ │ │ ├── SparseRedux.h │ │ │ ├── SparseSelfAdjointView.h │ │ │ ├── SparseSparseProductWithPruning.h │ │ │ ├── SparseTranspose.h │ │ │ ├── SparseTriangularView.h │ │ │ ├── SparseUtil.h │ │ │ ├── SparseVector.h │ │ │ ├── SparseView.h │ │ │ └── TriangularSolver.h │ │ │ ├── SparseLU │ │ │ ├── CMakeLists.txt │ │ │ ├── SparseLU.h │ │ │ ├── SparseLUImpl.h │ │ │ ├── SparseLU_Memory.h │ │ │ ├── SparseLU_Structs.h │ │ │ ├── SparseLU_SupernodalMatrix.h │ │ │ ├── SparseLU_Utils.h │ │ │ ├── SparseLU_column_bmod.h │ │ │ ├── SparseLU_column_dfs.h │ │ │ ├── SparseLU_copy_to_ucol.h │ │ │ ├── SparseLU_gemm_kernel.h │ │ │ ├── SparseLU_heap_relax_snode.h │ │ │ ├── SparseLU_kernel_bmod.h │ │ │ ├── SparseLU_panel_bmod.h │ │ │ ├── SparseLU_panel_dfs.h │ │ │ ├── SparseLU_pivotL.h │ │ │ ├── SparseLU_pruneL.h │ │ │ └── SparseLU_relax_snode.h │ │ │ ├── SparseQR │ │ │ ├── CMakeLists.txt │ │ │ └── SparseQR.h │ │ │ ├── StlSupport │ │ │ ├── CMakeLists.txt │ │ │ ├── StdDeque.h │ │ │ ├── StdList.h │ │ │ ├── StdVector.h │ │ │ └── details.h │ │ │ ├── SuperLUSupport │ │ │ ├── CMakeLists.txt │ │ │ └── SuperLUSupport.h │ │ │ ├── UmfPackSupport │ │ │ ├── CMakeLists.txt │ │ │ └── UmfPackSupport.h │ │ │ ├── misc │ │ │ ├── CMakeLists.txt │ │ │ ├── Image.h │ │ │ ├── Kernel.h │ │ │ ├── Solve.h │ │ │ ├── SparseSolve.h │ │ │ └── blas.h │ │ │ └── plugins │ │ │ ├── ArrayCwiseBinaryOps.h │ │ │ ├── ArrayCwiseUnaryOps.h │ │ │ ├── BlockMethods.h │ │ │ ├── CMakeLists.txt │ │ │ ├── CommonCwiseBinaryOps.h │ │ │ ├── CommonCwiseUnaryOps.h │ │ │ ├── MatrixCwiseBinaryOps.h │ │ │ └── MatrixCwiseUnaryOps.h │ ├── cmake │ │ ├── EigenConfigureTesting.cmake │ │ ├── EigenDetermineOSVersion.cmake │ │ ├── EigenDetermineVSServicePack.cmake │ │ ├── EigenTesting.cmake │ │ ├── FindAdolc.cmake │ │ ├── FindBLAS.cmake │ │ ├── FindCholmod.cmake │ │ ├── FindEigen2.cmake │ │ ├── FindEigen3.cmake │ │ ├── FindFFTW.cmake │ │ ├── FindGLEW.cmake │ │ ├── FindGMP.cmake │ │ ├── FindGSL.cmake │ │ ├── FindGoogleHash.cmake │ │ ├── FindLAPACK.cmake │ │ ├── FindMPFR.cmake │ │ ├── FindMetis.cmake │ │ ├── FindPastix.cmake │ │ ├── FindSPQR.cmake │ │ ├── FindScotch.cmake │ │ ├── FindStandardMathLibrary.cmake │ │ ├── FindSuperLU.cmake │ │ ├── FindUmfpack.cmake │ │ ├── RegexUtils.cmake │ │ └── language_support.cmake │ └── unsupported │ │ ├── CMakeLists.txt │ │ ├── Eigen │ │ ├── AdolcForward │ │ ├── AlignedVector3 │ │ ├── ArpackSupport │ │ ├── AutoDiff │ │ ├── BVH │ │ ├── CMakeLists.txt │ │ ├── FFT │ │ ├── IterativeSolvers │ │ ├── KroneckerProduct │ │ ├── LevenbergMarquardt │ │ ├── MPRealSupport │ │ ├── MatrixFunctions │ │ ├── MoreVectorization │ │ ├── NonLinearOptimization │ │ ├── NumericalDiff │ │ ├── OpenGLSupport │ │ ├── Polynomials │ │ ├── SVD │ │ ├── Skyline │ │ ├── SparseExtra │ │ ├── Splines │ │ └── src │ │ │ ├── AutoDiff │ │ │ ├── AutoDiffJacobian.h │ │ │ ├── AutoDiffScalar.h │ │ │ ├── AutoDiffVector.h │ │ │ └── CMakeLists.txt │ │ │ ├── BVH │ │ │ ├── BVAlgorithms.h │ │ │ ├── CMakeLists.txt │ │ │ └── KdBVH.h │ │ │ ├── CMakeLists.txt │ │ │ ├── Eigenvalues │ │ │ ├── ArpackSelfAdjointEigenSolver.h │ │ │ └── CMakeLists.txt │ │ │ ├── FFT │ │ │ ├── CMakeLists.txt │ │ │ ├── ei_fftw_impl.h │ │ │ └── ei_kissfft_impl.h │ │ │ ├── IterativeSolvers │ │ │ ├── CMakeLists.txt │ │ │ ├── ConstrainedConjGrad.h │ │ │ ├── DGMRES.h │ │ │ ├── GMRES.h │ │ │ ├── IncompleteCholesky.h │ │ │ ├── IncompleteLU.h │ │ │ ├── IterationController.h │ │ │ ├── MINRES.h │ │ │ └── Scaling.h │ │ │ ├── KroneckerProduct │ │ │ ├── CMakeLists.txt │ │ │ └── KroneckerTensorProduct.h │ │ │ ├── LevenbergMarquardt │ │ │ ├── CMakeLists.txt │ │ │ ├── CopyrightMINPACK.txt │ │ │ ├── LMcovar.h │ │ │ ├── LMonestep.h │ │ │ ├── LMpar.h │ │ │ ├── LMqrsolv.h │ │ │ └── LevenbergMarquardt.h │ │ │ ├── MatrixFunctions │ │ │ ├── CMakeLists.txt │ │ │ ├── MatrixExponential.h │ │ │ ├── MatrixFunction.h │ │ │ ├── MatrixFunctionAtomic.h │ │ │ ├── MatrixLogarithm.h │ │ │ ├── MatrixPower.h │ │ │ ├── MatrixSquareRoot.h │ │ │ └── StemFunction.h │ │ │ ├── MoreVectorization │ │ │ ├── CMakeLists.txt │ │ │ └── MathFunctions.h │ │ │ ├── NonLinearOptimization │ │ │ ├── CMakeLists.txt │ │ │ ├── HybridNonLinearSolver.h │ │ │ ├── LevenbergMarquardt.h │ │ │ ├── chkder.h │ │ │ ├── covar.h │ │ │ ├── dogleg.h │ │ │ ├── fdjac1.h │ │ │ ├── lmpar.h │ │ │ ├── qrsolv.h │ │ │ ├── r1mpyq.h │ │ │ ├── r1updt.h │ │ │ └── rwupdt.h │ │ │ ├── NumericalDiff │ │ │ ├── CMakeLists.txt │ │ │ └── NumericalDiff.h │ │ │ ├── Polynomials │ │ │ ├── CMakeLists.txt │ │ │ ├── Companion.h │ │ │ ├── PolynomialSolver.h │ │ │ └── PolynomialUtils.h │ │ │ ├── SVD │ │ │ ├── BDCSVD.h │ │ │ ├── CMakeLists.txt │ │ │ ├── JacobiSVD.h │ │ │ ├── SVDBase.h │ │ │ ├── TODOBdcsvd.txt │ │ │ └── doneInBDCSVD.txt │ │ │ ├── Skyline │ │ │ ├── CMakeLists.txt │ │ │ ├── SkylineInplaceLU.h │ │ │ ├── SkylineMatrix.h │ │ │ ├── SkylineMatrixBase.h │ │ │ ├── SkylineProduct.h │ │ │ ├── SkylineStorage.h │ │ │ └── SkylineUtil.h │ │ │ ├── SparseExtra │ │ │ ├── BlockOfDynamicSparseMatrix.h │ │ │ ├── CMakeLists.txt │ │ │ ├── DynamicSparseMatrix.h │ │ │ ├── MarketIO.h │ │ │ ├── MatrixMarketIterator.h │ │ │ └── RandomSetter.h │ │ │ └── Splines │ │ │ ├── CMakeLists.txt │ │ │ ├── Spline.h │ │ │ ├── SplineFitting.h │ │ │ └── SplineFwd.h │ │ ├── README.txt │ │ ├── bench │ │ └── bench_svd.cpp │ │ ├── doc │ │ ├── CMakeLists.txt │ │ ├── Overview.dox │ │ ├── eigendoxy_layout.xml.in │ │ ├── examples │ │ │ ├── BVH_Example.cpp │ │ │ ├── CMakeLists.txt │ │ │ ├── FFT.cpp │ │ │ ├── MatrixExponential.cpp │ │ │ ├── MatrixFunction.cpp │ │ │ ├── MatrixLogarithm.cpp │ │ │ ├── MatrixPower.cpp │ │ │ ├── MatrixPower_optimal.cpp │ │ │ ├── MatrixSine.cpp │ │ │ ├── MatrixSinh.cpp │ │ │ ├── MatrixSquareRoot.cpp │ │ │ ├── PolynomialSolver1.cpp │ │ │ └── PolynomialUtils1.cpp │ │ └── snippets │ │ │ └── CMakeLists.txt │ │ └── test │ │ ├── BVH.cpp │ │ ├── CMakeLists.txt │ │ ├── FFT.cpp │ │ ├── FFTW.cpp │ │ ├── NonLinearOptimization.cpp │ │ ├── NumericalDiff.cpp │ │ ├── alignedvector3.cpp │ │ ├── autodiff.cpp │ │ ├── bdcsvd.cpp │ │ ├── dgmres.cpp │ │ ├── forward_adolc.cpp │ │ ├── gmres.cpp │ │ ├── jacobisvd.cpp │ │ ├── kronecker_product.cpp │ │ ├── levenberg_marquardt.cpp │ │ ├── matrix_exponential.cpp │ │ ├── matrix_function.cpp │ │ ├── matrix_functions.h │ │ ├── matrix_power.cpp │ │ ├── matrix_square_root.cpp │ │ ├── minres.cpp │ │ ├── mpreal │ │ └── mpreal.h │ │ ├── mpreal_support.cpp │ │ ├── openglsupport.cpp │ │ ├── polynomialsolver.cpp │ │ ├── polynomialutils.cpp │ │ ├── sparse_extra.cpp │ │ ├── splines.cpp │ │ └── svd_common.h ├── OpenGV │ ├── .gitignore │ ├── .travis.yml │ ├── CMakeLists.txt │ ├── Doxyfile │ ├── License.txt │ ├── Makefile.ros │ ├── README.txt │ ├── cmake │ │ ├── CXX11.cmake │ │ └── CheckCXXCompilerFlag.cmake │ ├── doc │ │ └── addons │ │ │ ├── 01_installation.dox │ │ │ ├── 02_how_to_use.dox │ │ │ ├── 03_matlab.dox │ │ │ ├── 04_how_to_contribute.dox │ │ │ ├── 05_contact.dox │ │ │ ├── 06_references.dox │ │ │ ├── images │ │ │ ├── absolute_central.dia │ │ │ ├── absolute_central.eps │ │ │ ├── absolute_central.pdf │ │ │ ├── absolute_central.png │ │ │ ├── absolute_noncentral.dia │ │ │ ├── absolute_noncentral.eps │ │ │ ├── absolute_noncentral.pdf │ │ │ ├── absolute_noncentral.png │ │ │ ├── central.dia │ │ │ ├── central.eps │ │ │ ├── central.pdf │ │ │ ├── central.png │ │ │ ├── multi_viewpoint.dia │ │ │ ├── multi_viewpoint.eps │ │ │ ├── multi_viewpoint.pdf │ │ │ ├── multi_viewpoint.png │ │ │ ├── noncentral.dia │ │ │ ├── noncentral.eps │ │ │ ├── noncentral.pdf │ │ │ ├── noncentral.png │ │ │ ├── nonoverlapping.dia │ │ │ ├── nonoverlapping.eps │ │ │ ├── nonoverlapping.pdf │ │ │ ├── nonoverlapping.png │ │ │ ├── point_cloud.dia │ │ │ ├── point_cloud.eps │ │ │ ├── point_cloud.pdf │ │ │ ├── point_cloud.png │ │ │ ├── relative_central.dia │ │ │ ├── relative_central.eps │ │ │ ├── relative_central.pdf │ │ │ ├── relative_central.png │ │ │ ├── relative_noncentral.dia │ │ │ ├── relative_noncentral.eps │ │ │ ├── relative_noncentral.pdf │ │ │ ├── relative_noncentral.png │ │ │ ├── reprojectionError.dia │ │ │ ├── reprojectionError.eps │ │ │ ├── reprojectionError.pdf │ │ │ ├── reprojectionError.png │ │ │ ├── triangulation_central.dia │ │ │ ├── triangulation_central.eps │ │ │ ├── triangulation_central.pdf │ │ │ ├── triangulation_central.png │ │ │ ├── triangulation_noncentral.dia │ │ │ ├── triangulation_noncentral.eps │ │ │ ├── triangulation_noncentral.pdf │ │ │ └── triangulation_noncentral.png │ │ │ └── mainpage.dox │ ├── include │ │ └── opengv │ │ │ ├── Indices.hpp │ │ │ ├── OptimizationFunctor.hpp │ │ │ ├── absolute_pose │ │ │ ├── AbsoluteAdapterBase.hpp │ │ │ ├── AbsoluteMultiAdapterBase.hpp │ │ │ ├── CentralAbsoluteAdapter.hpp │ │ │ ├── MACentralAbsolute.hpp │ │ │ ├── MANoncentralAbsolute.hpp │ │ │ ├── NoncentralAbsoluteAdapter.hpp │ │ │ ├── NoncentralAbsoluteMultiAdapter.hpp │ │ │ ├── methods.hpp │ │ │ └── modules │ │ │ │ ├── Epnp.hpp │ │ │ │ ├── gp3p │ │ │ │ └── modules.hpp │ │ │ │ ├── gpnp1 │ │ │ │ └── modules.hpp │ │ │ │ ├── gpnp2 │ │ │ │ └── modules.hpp │ │ │ │ ├── gpnp3 │ │ │ │ └── modules.hpp │ │ │ │ ├── gpnp4 │ │ │ │ └── modules.hpp │ │ │ │ ├── gpnp5 │ │ │ │ └── modules.hpp │ │ │ │ ├── main.hpp │ │ │ │ ├── mlpnp.hpp │ │ │ │ ├── upnp2.hpp │ │ │ │ └── upnp4.hpp │ │ │ ├── math │ │ │ ├── Sturm.hpp │ │ │ ├── arun.hpp │ │ │ ├── cayley.hpp │ │ │ ├── gauss_jordan.hpp │ │ │ ├── quaternion.hpp │ │ │ ├── rodrigues.hpp │ │ │ └── roots.hpp │ │ │ ├── point_cloud │ │ │ ├── MAPointCloud.hpp │ │ │ ├── PointCloudAdapter.hpp │ │ │ ├── PointCloudAdapterBase.hpp │ │ │ └── methods.hpp │ │ │ ├── relative_pose │ │ │ ├── CentralRelativeAdapter.hpp │ │ │ ├── CentralRelativeMultiAdapter.hpp │ │ │ ├── CentralRelativeWeightingAdapter.hpp │ │ │ ├── MACentralRelative.hpp │ │ │ ├── MANoncentralRelative.hpp │ │ │ ├── MANoncentralRelativeMulti.hpp │ │ │ ├── NoncentralRelativeAdapter.hpp │ │ │ ├── NoncentralRelativeMultiAdapter.hpp │ │ │ ├── RelativeAdapterBase.hpp │ │ │ ├── RelativeMultiAdapterBase.hpp │ │ │ ├── methods.hpp │ │ │ └── modules │ │ │ │ ├── eigensolver │ │ │ │ └── modules.hpp │ │ │ │ ├── fivept_kneip │ │ │ │ └── modules.hpp │ │ │ │ ├── fivept_nister │ │ │ │ └── modules.hpp │ │ │ │ ├── fivept_stewenius │ │ │ │ └── modules.hpp │ │ │ │ ├── ge │ │ │ │ └── modules.hpp │ │ │ │ ├── main.hpp │ │ │ │ ├── sixpt │ │ │ │ └── modules.hpp │ │ │ │ └── sixpt_ventura │ │ │ │ ├── Polynomial.hpp │ │ │ │ ├── PolynomialInternal.hpp │ │ │ │ └── approx_relpose_generalized_fast_computeA.h │ │ │ ├── sac │ │ │ ├── MultiRansac.hpp │ │ │ ├── MultiSampleConsensus.hpp │ │ │ ├── MultiSampleConsensusProblem.hpp │ │ │ ├── Ransac.hpp │ │ │ ├── SampleConsensus.hpp │ │ │ ├── SampleConsensusProblem.hpp │ │ │ └── implementation │ │ │ │ ├── MultiRansac.hpp │ │ │ │ ├── MultiSampleConsensus.hpp │ │ │ │ ├── MultiSampleConsensusProblem.hpp │ │ │ │ ├── Ransac.hpp │ │ │ │ ├── SampleConsensus.hpp │ │ │ │ └── SampleConsensusProblem.hpp │ │ │ ├── sac_problems │ │ │ ├── absolute_pose │ │ │ │ ├── AbsolutePoseSacProblem.hpp │ │ │ │ └── MultiNoncentralAbsolutePoseSacProblem.hpp │ │ │ ├── point_cloud │ │ │ │ └── PointCloudSacProblem.hpp │ │ │ └── relative_pose │ │ │ │ ├── CentralRelativePoseSacProblem.hpp │ │ │ │ ├── EigensolverSacProblem.hpp │ │ │ │ ├── MultiCentralRelativePoseSacProblem.hpp │ │ │ │ ├── MultiNoncentralRelativePoseSacProblem.hpp │ │ │ │ ├── NoncentralRelativePoseSacProblem.hpp │ │ │ │ ├── RotationOnlySacProblem.hpp │ │ │ │ └── TranslationOnlySacProblem.hpp │ │ │ ├── triangulation │ │ │ └── methods.hpp │ │ │ └── types.hpp │ ├── manifest.xml │ ├── matlab │ │ ├── UrbanRel.m │ │ ├── benchmark_absolute_pose.m │ │ ├── benchmark_absolute_pose_cov.m │ │ ├── benchmark_absolute_pose_execution_times.m │ │ ├── benchmark_absolute_pose_noncentral.m │ │ ├── benchmark_absolute_pose_noncentral_execution_timing.m │ │ ├── benchmark_relative_pose.m │ │ ├── benchmark_relative_pose_execution_times.m │ │ ├── benchmark_relative_pose_noncentral.m │ │ ├── benchmark_relative_pose_noncentral2.m │ │ ├── benchmark_relative_pose_noncentral_execution_times.m │ │ ├── benchmark_relative_pose_noncentral_execution_times2.m │ │ ├── compile_ogv_matlab_wrappers.m │ │ ├── helpers │ │ │ ├── addNoise.m │ │ │ ├── cayley2rot.m │ │ │ ├── create2D2DExperiment.m │ │ │ ├── create2D2DOmniExperiment.m │ │ │ ├── create2D3DExperiment.m │ │ │ ├── create2D3DExperimentCov1Cam.m │ │ │ ├── createMulti2D2DExperiment.m │ │ │ ├── createMulti2D2DOmniExperiment.m │ │ │ ├── evaluateRotationError.m │ │ │ ├── evaluateTransformationError.m │ │ │ ├── generateBoundedR.m │ │ │ ├── generateRandomR.m │ │ │ ├── perturb.m │ │ │ ├── rodrigues.m │ │ │ ├── rot2cayley.m │ │ │ └── transformEssentials.m │ │ ├── opengv.cpp │ │ ├── opengv.mexw64 │ │ ├── opengv_donotuse.cpp │ │ ├── opengv_experimental1.cpp │ │ ├── opengv_experimental2.cpp │ │ ├── ordinary3Dresults.mat │ │ ├── plot_arun_error.m │ │ ├── plot_expected_iterations.m │ │ ├── plot_ge_costfunction.m │ │ ├── ransac_experiment.m │ │ ├── ransac_experiment2.m │ │ ├── ransac_experiment3.m │ │ └── ransac_test.m │ ├── modules │ │ ├── FindEigen.cmake │ │ └── FindNumPy.cmake │ ├── python │ │ ├── CMakeLists.txt │ │ ├── pyopengv.cpp │ │ ├── tests.py │ │ └── types.hpp │ ├── src │ │ ├── absolute_pose │ │ │ ├── CentralAbsoluteAdapter.cpp │ │ │ ├── MACentralAbsolute.cpp │ │ │ ├── MANoncentralAbsolute.cpp │ │ │ ├── NoncentralAbsoluteAdapter.cpp │ │ │ ├── NoncentralAbsoluteMultiAdapter.cpp │ │ │ ├── methods.cpp │ │ │ └── modules │ │ │ │ ├── Epnp.cpp │ │ │ │ ├── gp3p │ │ │ │ ├── code.cpp │ │ │ │ ├── init.cpp │ │ │ │ ├── reductors.cpp │ │ │ │ └── spolynomials.cpp │ │ │ │ ├── gpnp1 │ │ │ │ ├── code.cpp │ │ │ │ ├── init.cpp │ │ │ │ ├── reductors.cpp │ │ │ │ └── spolynomials.cpp │ │ │ │ ├── gpnp2 │ │ │ │ ├── code.cpp │ │ │ │ ├── init.cpp │ │ │ │ ├── reductors.cpp │ │ │ │ └── spolynomials.cpp │ │ │ │ ├── gpnp3 │ │ │ │ ├── code.cpp │ │ │ │ ├── init.cpp │ │ │ │ ├── reductors.cpp │ │ │ │ └── spolynomials.cpp │ │ │ │ ├── gpnp4 │ │ │ │ ├── code.cpp │ │ │ │ ├── init.cpp │ │ │ │ ├── reductors.cpp │ │ │ │ └── spolynomials.cpp │ │ │ │ ├── gpnp5 │ │ │ │ ├── code.cpp │ │ │ │ ├── init.cpp │ │ │ │ ├── reductors.cpp │ │ │ │ └── spolynomials.cpp │ │ │ │ ├── main.cpp │ │ │ │ ├── mlpnp │ │ │ │ ├── mlpnp.cpp │ │ │ │ └── mlpnp_lm.cpp │ │ │ │ ├── upnp2.cpp │ │ │ │ └── upnp4.cpp │ │ ├── math │ │ │ ├── Sturm.cpp │ │ │ ├── arun.cpp │ │ │ ├── cayley.cpp │ │ │ ├── gauss_jordan.cpp │ │ │ ├── quaternion.cpp │ │ │ ├── rodrigues.cpp │ │ │ └── roots.cpp │ │ ├── point_cloud │ │ │ ├── MAPointCloud.cpp │ │ │ ├── PointCloudAdapter.cpp │ │ │ └── methods.cpp │ │ ├── relative_pose │ │ │ ├── CentralRelativeAdapter.cpp │ │ │ ├── CentralRelativeMultiAdapter.cpp │ │ │ ├── CentralRelativeWeightingAdapter.cpp │ │ │ ├── MACentralRelative.cpp │ │ │ ├── MANoncentralRelative.cpp │ │ │ ├── MANoncentralRelativeMulti.cpp │ │ │ ├── NoncentralRelativeAdapter.cpp │ │ │ ├── NoncentralRelativeMultiAdapter.cpp │ │ │ ├── methods.cpp │ │ │ └── modules │ │ │ │ ├── eigensolver │ │ │ │ └── modules.cpp │ │ │ │ ├── fivept_kneip │ │ │ │ ├── code.cpp │ │ │ │ ├── init.cpp │ │ │ │ ├── reductors.cpp │ │ │ │ └── spolynomials.cpp │ │ │ │ ├── fivept_nister │ │ │ │ └── modules.cpp │ │ │ │ ├── fivept_stewenius │ │ │ │ └── modules.cpp │ │ │ │ ├── ge │ │ │ │ └── modules.cpp │ │ │ │ ├── main.cpp │ │ │ │ ├── sixpt │ │ │ │ └── modules2.cpp │ │ │ │ └── sixpt_ventura │ │ │ │ └── approx_relpose_generalized_fast_computeA.cpp │ │ ├── sac_problems │ │ │ ├── absolute_pose │ │ │ │ ├── AbsolutePoseSacProblem.cpp │ │ │ │ └── MultiNoncentralAbsolutePoseSacProblem.cpp │ │ │ ├── point_cloud │ │ │ │ └── PointCloudSacProblem.cpp │ │ │ └── relative_pose │ │ │ │ ├── CentralRelativePoseSacProblem.cpp │ │ │ │ ├── EigensolverSacProblem.cpp │ │ │ │ ├── MultiCentralRelativePoseSacProblem.cpp │ │ │ │ ├── MultiNoncentralRelativePoseSacProblem.cpp │ │ │ │ ├── NoncentralRelativePoseSacProblem.cpp │ │ │ │ ├── RotationOnlySacProblem.cpp │ │ │ │ └── TranslationOnlySacProblem.cpp │ │ └── triangulation │ │ │ └── methods.cpp │ ├── test │ │ ├── experiment_helpers.cpp │ │ ├── experiment_helpers.hpp │ │ ├── random_generators.cpp │ │ ├── random_generators.hpp │ │ ├── test_Sturm.cpp │ │ ├── test_absolute_pose.cpp │ │ ├── test_absolute_pose_sac.cpp │ │ ├── test_eigensolver.cpp │ │ ├── test_eigensolver_sac.cpp │ │ ├── test_multi_noncentral_absolute_pose_sac.cpp │ │ ├── test_multi_noncentral_relative_pose_sac.cpp │ │ ├── test_noncentral_absolute_pose.cpp │ │ ├── test_noncentral_absolute_pose_sac.cpp │ │ ├── test_noncentral_relative_pose.cpp │ │ ├── test_noncentral_relative_pose_sac.cpp │ │ ├── test_point_cloud.cpp │ │ ├── test_point_cloud_sac.cpp │ │ ├── test_relative_pose.cpp │ │ ├── test_relative_pose_rotationOnly.cpp │ │ ├── test_relative_pose_rotationOnly_sac.cpp │ │ ├── test_relative_pose_sac.cpp │ │ ├── test_triangulation.cpp │ │ ├── time_measurement.cpp │ │ └── time_measurement.hpp │ └── third_party │ │ ├── Eigen │ │ ├── Array │ │ ├── CMakeLists.txt │ │ ├── Cholesky │ │ ├── CholmodSupport │ │ ├── Core │ │ ├── Dense │ │ ├── Eigen │ │ ├── Eigen2Support │ │ ├── Eigenvalues │ │ ├── Geometry │ │ ├── Householder │ │ ├── IterativeLinearSolvers │ │ ├── Jacobi │ │ ├── LU │ │ ├── LeastSquares │ │ ├── MetisSupport │ │ ├── OrderingMethods │ │ ├── PaStiXSupport │ │ ├── PardisoSupport │ │ ├── QR │ │ ├── QtAlignedMalloc │ │ ├── SPQRSupport │ │ ├── SVD │ │ ├── Sparse │ │ ├── SparseCholesky │ │ ├── SparseCore │ │ ├── SparseLU │ │ ├── SparseQR │ │ ├── StdDeque │ │ ├── StdList │ │ ├── StdVector │ │ ├── SuperLUSupport │ │ ├── UmfPackSupport │ │ └── src │ │ │ ├── CMakeLists.txt │ │ │ ├── Cholesky │ │ │ ├── CMakeLists.txt │ │ │ ├── LDLT.h │ │ │ ├── LLT.h │ │ │ └── LLT_MKL.h │ │ │ ├── CholmodSupport │ │ │ ├── CMakeLists.txt │ │ │ └── CholmodSupport.h │ │ │ ├── Core │ │ │ ├── Array.h │ │ │ ├── ArrayBase.h │ │ │ ├── ArrayWrapper.h │ │ │ ├── Assign.h │ │ │ ├── Assign_MKL.h │ │ │ ├── BandMatrix.h │ │ │ ├── Block.h │ │ │ ├── BooleanRedux.h │ │ │ ├── CMakeLists.txt │ │ │ ├── CommaInitializer.h │ │ │ ├── CoreIterators.h │ │ │ ├── CwiseBinaryOp.h │ │ │ ├── CwiseNullaryOp.h │ │ │ ├── CwiseUnaryOp.h │ │ │ ├── CwiseUnaryView.h │ │ │ ├── DenseBase.h │ │ │ ├── DenseCoeffsBase.h │ │ │ ├── DenseStorage.h │ │ │ ├── Diagonal.h │ │ │ ├── DiagonalMatrix.h │ │ │ ├── DiagonalProduct.h │ │ │ ├── Dot.h │ │ │ ├── EigenBase.h │ │ │ ├── Flagged.h │ │ │ ├── ForceAlignedAccess.h │ │ │ ├── Functors.h │ │ │ ├── Fuzzy.h │ │ │ ├── GeneralProduct.h │ │ │ ├── GenericPacketMath.h │ │ │ ├── GlobalFunctions.h │ │ │ ├── IO.h │ │ │ ├── Map.h │ │ │ ├── MapBase.h │ │ │ ├── MathFunctions.h │ │ │ ├── Matrix.h │ │ │ ├── MatrixBase.h │ │ │ ├── NestByValue.h │ │ │ ├── NoAlias.h │ │ │ ├── NumTraits.h │ │ │ ├── PermutationMatrix.h │ │ │ ├── PlainObjectBase.h │ │ │ ├── ProductBase.h │ │ │ ├── Random.h │ │ │ ├── Redux.h │ │ │ ├── Ref.h │ │ │ ├── Replicate.h │ │ │ ├── ReturnByValue.h │ │ │ ├── Reverse.h │ │ │ ├── Select.h │ │ │ ├── SelfAdjointView.h │ │ │ ├── SelfCwiseBinaryOp.h │ │ │ ├── SolveTriangular.h │ │ │ ├── StableNorm.h │ │ │ ├── Stride.h │ │ │ ├── Swap.h │ │ │ ├── Transpose.h │ │ │ ├── Transpositions.h │ │ │ ├── TriangularMatrix.h │ │ │ ├── VectorBlock.h │ │ │ ├── VectorwiseOp.h │ │ │ ├── Visitor.h │ │ │ ├── arch │ │ │ │ ├── AltiVec │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── Complex.h │ │ │ │ │ └── PacketMath.h │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── Default │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ └── Settings.h │ │ │ │ ├── NEON │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── Complex.h │ │ │ │ │ └── PacketMath.h │ │ │ │ └── SSE │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── Complex.h │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ └── PacketMath.h │ │ │ ├── products │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── CoeffBasedProduct.h │ │ │ │ ├── GeneralBlockPanelKernel.h │ │ │ │ ├── GeneralMatrixMatrix.h │ │ │ │ ├── GeneralMatrixMatrixTriangular.h │ │ │ │ ├── GeneralMatrixMatrixTriangular_MKL.h │ │ │ │ ├── GeneralMatrixMatrix_MKL.h │ │ │ │ ├── GeneralMatrixVector.h │ │ │ │ ├── GeneralMatrixVector_MKL.h │ │ │ │ ├── Parallelizer.h │ │ │ │ ├── SelfadjointMatrixMatrix.h │ │ │ │ ├── SelfadjointMatrixMatrix_MKL.h │ │ │ │ ├── SelfadjointMatrixVector.h │ │ │ │ ├── SelfadjointMatrixVector_MKL.h │ │ │ │ ├── SelfadjointProduct.h │ │ │ │ ├── SelfadjointRank2Update.h │ │ │ │ ├── TriangularMatrixMatrix.h │ │ │ │ ├── TriangularMatrixMatrix_MKL.h │ │ │ │ ├── TriangularMatrixVector.h │ │ │ │ ├── TriangularMatrixVector_MKL.h │ │ │ │ ├── TriangularSolverMatrix.h │ │ │ │ ├── TriangularSolverMatrix_MKL.h │ │ │ │ └── TriangularSolverVector.h │ │ │ └── util │ │ │ │ ├── BlasUtil.h │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── Constants.h │ │ │ │ ├── DisableStupidWarnings.h │ │ │ │ ├── ForwardDeclarations.h │ │ │ │ ├── MKL_support.h │ │ │ │ ├── Macros.h │ │ │ │ ├── Memory.h │ │ │ │ ├── Meta.h │ │ │ │ ├── NonMPL2.h │ │ │ │ ├── ReenableStupidWarnings.h │ │ │ │ ├── StaticAssert.h │ │ │ │ └── XprHelper.h │ │ │ ├── Eigen2Support │ │ │ ├── Block.h │ │ │ ├── CMakeLists.txt │ │ │ ├── Cwise.h │ │ │ ├── CwiseOperators.h │ │ │ ├── Geometry │ │ │ │ ├── AlignedBox.h │ │ │ │ ├── All.h │ │ │ │ ├── AngleAxis.h │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── Hyperplane.h │ │ │ │ ├── ParametrizedLine.h │ │ │ │ ├── Quaternion.h │ │ │ │ ├── Rotation2D.h │ │ │ │ ├── RotationBase.h │ │ │ │ ├── Scaling.h │ │ │ │ ├── Transform.h │ │ │ │ └── Translation.h │ │ │ ├── LU.h │ │ │ ├── Lazy.h │ │ │ ├── LeastSquares.h │ │ │ ├── Macros.h │ │ │ ├── MathFunctions.h │ │ │ ├── Memory.h │ │ │ ├── Meta.h │ │ │ ├── Minor.h │ │ │ ├── QR.h │ │ │ ├── SVD.h │ │ │ ├── TriangularSolver.h │ │ │ └── VectorBlock.h │ │ │ ├── Eigenvalues │ │ │ ├── CMakeLists.txt │ │ │ ├── ComplexEigenSolver.h │ │ │ ├── ComplexSchur.h │ │ │ ├── ComplexSchur_MKL.h │ │ │ ├── EigenSolver.h │ │ │ ├── GeneralizedEigenSolver.h │ │ │ ├── GeneralizedSelfAdjointEigenSolver.h │ │ │ ├── HessenbergDecomposition.h │ │ │ ├── MatrixBaseEigenvalues.h │ │ │ ├── RealQZ.h │ │ │ ├── RealSchur.h │ │ │ ├── RealSchur_MKL.h │ │ │ ├── SelfAdjointEigenSolver.h │ │ │ ├── SelfAdjointEigenSolver_MKL.h │ │ │ └── Tridiagonalization.h │ │ │ ├── Geometry │ │ │ ├── AlignedBox.h │ │ │ ├── AngleAxis.h │ │ │ ├── CMakeLists.txt │ │ │ ├── EulerAngles.h │ │ │ ├── Homogeneous.h │ │ │ ├── Hyperplane.h │ │ │ ├── OrthoMethods.h │ │ │ ├── ParametrizedLine.h │ │ │ ├── Quaternion.h │ │ │ ├── Rotation2D.h │ │ │ ├── RotationBase.h │ │ │ ├── Scaling.h │ │ │ ├── Transform.h │ │ │ ├── Translation.h │ │ │ ├── Umeyama.h │ │ │ └── arch │ │ │ │ ├── CMakeLists.txt │ │ │ │ └── Geometry_SSE.h │ │ │ ├── Householder │ │ │ ├── BlockHouseholder.h │ │ │ ├── CMakeLists.txt │ │ │ ├── Householder.h │ │ │ └── HouseholderSequence.h │ │ │ ├── IterativeLinearSolvers │ │ │ ├── BasicPreconditioners.h │ │ │ ├── BiCGSTAB.h │ │ │ ├── CMakeLists.txt │ │ │ ├── ConjugateGradient.h │ │ │ ├── IncompleteLUT.h │ │ │ └── IterativeSolverBase.h │ │ │ ├── Jacobi │ │ │ ├── CMakeLists.txt │ │ │ └── Jacobi.h │ │ │ ├── LU │ │ │ ├── CMakeLists.txt │ │ │ ├── Determinant.h │ │ │ ├── FullPivLU.h │ │ │ ├── Inverse.h │ │ │ ├── PartialPivLU.h │ │ │ ├── PartialPivLU_MKL.h │ │ │ └── arch │ │ │ │ ├── CMakeLists.txt │ │ │ │ └── Inverse_SSE.h │ │ │ ├── MetisSupport │ │ │ ├── CMakeLists.txt │ │ │ └── MetisSupport.h │ │ │ ├── OrderingMethods │ │ │ ├── Amd.h │ │ │ ├── CMakeLists.txt │ │ │ ├── Eigen_Colamd.h │ │ │ └── Ordering.h │ │ │ ├── PaStiXSupport │ │ │ ├── CMakeLists.txt │ │ │ └── PaStiXSupport.h │ │ │ ├── PardisoSupport │ │ │ ├── CMakeLists.txt │ │ │ └── PardisoSupport.h │ │ │ ├── QR │ │ │ ├── CMakeLists.txt │ │ │ ├── ColPivHouseholderQR.h │ │ │ ├── ColPivHouseholderQR_MKL.h │ │ │ ├── FullPivHouseholderQR.h │ │ │ ├── HouseholderQR.h │ │ │ └── HouseholderQR_MKL.h │ │ │ ├── SPQRSupport │ │ │ ├── CMakeLists.txt │ │ │ └── SuiteSparseQRSupport.h │ │ │ ├── SVD │ │ │ ├── CMakeLists.txt │ │ │ ├── JacobiSVD.h │ │ │ ├── JacobiSVD_MKL.h │ │ │ └── UpperBidiagonalization.h │ │ │ ├── SparseCholesky │ │ │ ├── CMakeLists.txt │ │ │ ├── SimplicialCholesky.h │ │ │ └── SimplicialCholesky_impl.h │ │ │ ├── SparseCore │ │ │ ├── AmbiVector.h │ │ │ ├── CMakeLists.txt │ │ │ ├── CompressedStorage.h │ │ │ ├── ConservativeSparseSparseProduct.h │ │ │ ├── MappedSparseMatrix.h │ │ │ ├── SparseBlock.h │ │ │ ├── SparseColEtree.h │ │ │ ├── SparseCwiseBinaryOp.h │ │ │ ├── SparseCwiseUnaryOp.h │ │ │ ├── SparseDenseProduct.h │ │ │ ├── SparseDiagonalProduct.h │ │ │ ├── SparseDot.h │ │ │ ├── SparseFuzzy.h │ │ │ ├── SparseMatrix.h │ │ │ ├── SparseMatrixBase.h │ │ │ ├── SparsePermutation.h │ │ │ ├── SparseProduct.h │ │ │ ├── SparseRedux.h │ │ │ ├── SparseSelfAdjointView.h │ │ │ ├── SparseSparseProductWithPruning.h │ │ │ ├── SparseTranspose.h │ │ │ ├── SparseTriangularView.h │ │ │ ├── SparseUtil.h │ │ │ ├── SparseVector.h │ │ │ ├── SparseView.h │ │ │ └── TriangularSolver.h │ │ │ ├── SparseLU │ │ │ ├── CMakeLists.txt │ │ │ ├── SparseLU.h │ │ │ ├── SparseLUImpl.h │ │ │ ├── SparseLU_Memory.h │ │ │ ├── SparseLU_Structs.h │ │ │ ├── SparseLU_SupernodalMatrix.h │ │ │ ├── SparseLU_Utils.h │ │ │ ├── SparseLU_column_bmod.h │ │ │ ├── SparseLU_column_dfs.h │ │ │ ├── SparseLU_copy_to_ucol.h │ │ │ ├── SparseLU_gemm_kernel.h │ │ │ ├── SparseLU_heap_relax_snode.h │ │ │ ├── SparseLU_kernel_bmod.h │ │ │ ├── SparseLU_panel_bmod.h │ │ │ ├── SparseLU_panel_dfs.h │ │ │ ├── SparseLU_pivotL.h │ │ │ ├── SparseLU_pruneL.h │ │ │ └── SparseLU_relax_snode.h │ │ │ ├── SparseQR │ │ │ ├── CMakeLists.txt │ │ │ └── SparseQR.h │ │ │ ├── StlSupport │ │ │ ├── CMakeLists.txt │ │ │ ├── StdDeque.h │ │ │ ├── StdList.h │ │ │ ├── StdVector.h │ │ │ └── details.h │ │ │ ├── SuperLUSupport │ │ │ ├── CMakeLists.txt │ │ │ └── SuperLUSupport.h │ │ │ ├── UmfPackSupport │ │ │ ├── CMakeLists.txt │ │ │ └── UmfPackSupport.h │ │ │ ├── misc │ │ │ ├── CMakeLists.txt │ │ │ ├── Image.h │ │ │ ├── Kernel.h │ │ │ ├── Solve.h │ │ │ ├── SparseSolve.h │ │ │ └── blas.h │ │ │ └── plugins │ │ │ ├── ArrayCwiseBinaryOps.h │ │ │ ├── ArrayCwiseUnaryOps.h │ │ │ ├── BlockMethods.h │ │ │ ├── CMakeLists.txt │ │ │ ├── CommonCwiseBinaryOps.h │ │ │ ├── CommonCwiseUnaryOps.h │ │ │ ├── MatrixCwiseBinaryOps.h │ │ │ └── MatrixCwiseUnaryOps.h │ │ └── eigen3 │ │ └── unsupported │ │ ├── CMakeLists.txt │ │ ├── Eigen │ │ ├── AdolcForward │ │ ├── AlignedVector3 │ │ ├── ArpackSupport │ │ ├── AutoDiff │ │ ├── BVH │ │ ├── CMakeLists.txt │ │ ├── FFT │ │ ├── IterativeSolvers │ │ ├── KroneckerProduct │ │ ├── LevenbergMarquardt │ │ ├── MPRealSupport │ │ ├── MatrixFunctions │ │ ├── MoreVectorization │ │ ├── NonLinearOptimization │ │ ├── NumericalDiff │ │ ├── OpenGLSupport │ │ ├── Polynomials │ │ ├── SVD │ │ ├── Skyline │ │ ├── SparseExtra │ │ ├── Splines │ │ └── src │ │ │ ├── AutoDiff │ │ │ ├── AutoDiffJacobian.h │ │ │ ├── AutoDiffScalar.h │ │ │ ├── AutoDiffVector.h │ │ │ └── CMakeLists.txt │ │ │ ├── BVH │ │ │ ├── BVAlgorithms.h │ │ │ ├── CMakeLists.txt │ │ │ └── KdBVH.h │ │ │ ├── CMakeLists.txt │ │ │ ├── Eigenvalues │ │ │ ├── ArpackSelfAdjointEigenSolver.h │ │ │ └── CMakeLists.txt │ │ │ ├── FFT │ │ │ ├── CMakeLists.txt │ │ │ ├── ei_fftw_impl.h │ │ │ └── ei_kissfft_impl.h │ │ │ ├── IterativeSolvers │ │ │ ├── CMakeLists.txt │ │ │ ├── ConstrainedConjGrad.h │ │ │ ├── DGMRES.h │ │ │ ├── GMRES.h │ │ │ ├── IncompleteCholesky.h │ │ │ ├── IncompleteLU.h │ │ │ ├── IterationController.h │ │ │ ├── MINRES.h │ │ │ └── Scaling.h │ │ │ ├── KroneckerProduct │ │ │ ├── CMakeLists.txt │ │ │ └── KroneckerTensorProduct.h │ │ │ ├── LevenbergMarquardt │ │ │ ├── CMakeLists.txt │ │ │ ├── CopyrightMINPACK.txt │ │ │ ├── LMcovar.h │ │ │ ├── LMonestep.h │ │ │ ├── LMpar.h │ │ │ ├── LMqrsolv.h │ │ │ └── LevenbergMarquardt.h │ │ │ ├── MatrixFunctions │ │ │ ├── CMakeLists.txt │ │ │ ├── MatrixExponential.h │ │ │ ├── MatrixFunction.h │ │ │ ├── MatrixFunctionAtomic.h │ │ │ ├── MatrixLogarithm.h │ │ │ ├── MatrixPower.h │ │ │ ├── MatrixSquareRoot.h │ │ │ └── StemFunction.h │ │ │ ├── MoreVectorization │ │ │ ├── CMakeLists.txt │ │ │ └── MathFunctions.h │ │ │ ├── NonLinearOptimization │ │ │ ├── CMakeLists.txt │ │ │ ├── HybridNonLinearSolver.h │ │ │ ├── LevenbergMarquardt.h │ │ │ ├── chkder.h │ │ │ ├── covar.h │ │ │ ├── dogleg.h │ │ │ ├── fdjac1.h │ │ │ ├── lmpar.h │ │ │ ├── qrsolv.h │ │ │ ├── r1mpyq.h │ │ │ ├── r1updt.h │ │ │ └── rwupdt.h │ │ │ ├── NumericalDiff │ │ │ ├── CMakeLists.txt │ │ │ └── NumericalDiff.h │ │ │ ├── Polynomials │ │ │ ├── CMakeLists.txt │ │ │ ├── Companion.h │ │ │ ├── PolynomialSolver.h │ │ │ └── PolynomialUtils.h │ │ │ ├── SVD │ │ │ ├── BDCSVD.h │ │ │ ├── CMakeLists.txt │ │ │ ├── JacobiSVD.h │ │ │ ├── SVDBase.h │ │ │ ├── TODOBdcsvd.txt │ │ │ └── doneInBDCSVD.txt │ │ │ ├── Skyline │ │ │ ├── CMakeLists.txt │ │ │ ├── SkylineInplaceLU.h │ │ │ ├── SkylineMatrix.h │ │ │ ├── SkylineMatrixBase.h │ │ │ ├── SkylineProduct.h │ │ │ ├── SkylineStorage.h │ │ │ └── SkylineUtil.h │ │ │ ├── SparseExtra │ │ │ ├── BlockOfDynamicSparseMatrix.h │ │ │ ├── CMakeLists.txt │ │ │ ├── DynamicSparseMatrix.h │ │ │ ├── MarketIO.h │ │ │ ├── MatrixMarketIterator.h │ │ │ └── RandomSetter.h │ │ │ └── Splines │ │ │ ├── CMakeLists.txt │ │ │ ├── Spline.h │ │ │ ├── SplineFitting.h │ │ │ └── SplineFwd.h │ │ ├── README.txt │ │ ├── bench │ │ └── bench_svd.cpp │ │ ├── doc │ │ ├── CMakeLists.txt │ │ ├── Overview.dox │ │ ├── eigendoxy_layout.xml.in │ │ ├── examples │ │ │ ├── BVH_Example.cpp │ │ │ ├── CMakeLists.txt │ │ │ ├── FFT.cpp │ │ │ ├── MatrixExponential.cpp │ │ │ ├── MatrixFunction.cpp │ │ │ ├── MatrixLogarithm.cpp │ │ │ ├── MatrixPower.cpp │ │ │ ├── MatrixPower_optimal.cpp │ │ │ ├── MatrixSine.cpp │ │ │ ├── MatrixSinh.cpp │ │ │ ├── MatrixSquareRoot.cpp │ │ │ ├── PolynomialSolver1.cpp │ │ │ └── PolynomialUtils1.cpp │ │ └── snippets │ │ │ └── CMakeLists.txt │ │ └── test │ │ ├── BVH.cpp │ │ ├── CMakeLists.txt │ │ ├── FFT.cpp │ │ ├── FFTW.cpp │ │ ├── NonLinearOptimization.cpp │ │ ├── NumericalDiff.cpp │ │ ├── alignedvector3.cpp │ │ ├── autodiff.cpp │ │ ├── bdcsvd.cpp │ │ ├── dgmres.cpp │ │ ├── forward_adolc.cpp │ │ ├── gmres.cpp │ │ ├── jacobisvd.cpp │ │ ├── kronecker_product.cpp │ │ ├── levenberg_marquardt.cpp │ │ ├── matrix_exponential.cpp │ │ ├── matrix_function.cpp │ │ ├── matrix_functions.h │ │ ├── matrix_power.cpp │ │ ├── matrix_square_root.cpp │ │ ├── minres.cpp │ │ ├── mpreal │ │ └── mpreal.h │ │ ├── mpreal_support.cpp │ │ ├── openglsupport.cpp │ │ ├── polynomialsolver.cpp │ │ ├── polynomialutils.cpp │ │ ├── sparse_extra.cpp │ │ ├── splines.cpp │ │ └── svd_common.h └── g2o │ ├── CMakeLists.txt │ ├── README.txt │ ├── cmake_modules │ ├── FindBLAS.cmake │ ├── FindEigen3.cmake │ └── FindLAPACK.cmake │ ├── config.h │ ├── config.h.in │ ├── g2o │ ├── config.h │ ├── core │ │ ├── CMakeLists.txt │ │ ├── base_binary_edge.h │ │ ├── base_binary_edge.hpp │ │ ├── base_edge.h │ │ ├── base_multi_edge.h │ │ ├── base_multi_edge.hpp │ │ ├── base_unary_edge.h │ │ ├── base_unary_edge.hpp │ │ ├── base_vertex.h │ │ ├── base_vertex.hpp │ │ ├── batch_stats.cpp │ │ ├── batch_stats.h │ │ ├── block_solver.h │ │ ├── block_solver.hpp │ │ ├── cache.cpp │ │ ├── cache.h │ │ ├── creators.h │ │ ├── eigen_types.h │ │ ├── estimate_propagator.cpp │ │ ├── estimate_propagator.h │ │ ├── factory.cpp │ │ ├── factory.h │ │ ├── g2o_core_api.h │ │ ├── hyper_dijkstra.cpp │ │ ├── hyper_dijkstra.h │ │ ├── hyper_graph.cpp │ │ ├── hyper_graph.h │ │ ├── hyper_graph_action.cpp │ │ ├── hyper_graph_action.h │ │ ├── jacobian_workspace.cpp │ │ ├── jacobian_workspace.h │ │ ├── linear_solver.h │ │ ├── marginal_covariance_cholesky.cpp │ │ ├── marginal_covariance_cholesky.h │ │ ├── matrix_operations.h │ │ ├── matrix_structure.cpp │ │ ├── matrix_structure.h │ │ ├── openmp_mutex.h │ │ ├── optimizable_graph.cpp │ │ ├── optimizable_graph.h │ │ ├── optimization_algorithm.cpp │ │ ├── optimization_algorithm.h │ │ ├── optimization_algorithm_dogleg.cpp │ │ ├── optimization_algorithm_dogleg.h │ │ ├── optimization_algorithm_factory.cpp │ │ ├── optimization_algorithm_factory.h │ │ ├── optimization_algorithm_gauss_newton.cpp │ │ ├── optimization_algorithm_gauss_newton.h │ │ ├── optimization_algorithm_levenberg.cpp │ │ ├── optimization_algorithm_levenberg.h │ │ ├── optimization_algorithm_property.h │ │ ├── optimization_algorithm_with_hessian.cpp │ │ ├── optimization_algorithm_with_hessian.h │ │ ├── parameter.cpp │ │ ├── parameter.h │ │ ├── parameter_container.cpp │ │ ├── parameter_container.h │ │ ├── robust_kernel.cpp │ │ ├── robust_kernel.h │ │ ├── robust_kernel_factory.cpp │ │ ├── robust_kernel_factory.h │ │ ├── robust_kernel_impl.cpp │ │ ├── robust_kernel_impl.h │ │ ├── solver.cpp │ │ ├── solver.h │ │ ├── sparse_block_matrix.h │ │ ├── sparse_block_matrix.hpp │ │ ├── sparse_block_matrix_ccs.h │ │ ├── sparse_block_matrix_diagonal.h │ │ ├── sparse_block_matrix_test.cpp │ │ ├── sparse_optimizer.cpp │ │ ├── sparse_optimizer.h │ │ ├── sparse_optimizer_terminate_action.cpp │ │ └── sparse_optimizer_terminate_action.h │ ├── solvers │ │ ├── linear_solver_dense.h │ │ └── linear_solver_eigen.h │ ├── stuff │ │ ├── color_macros.h │ │ ├── macros.h │ │ ├── misc.h │ │ ├── os_specific.c │ │ ├── os_specific.h │ │ ├── property.cpp │ │ ├── property.h │ │ ├── string_tools.cpp │ │ ├── string_tools.h │ │ ├── timeutil.cpp │ │ └── timeutil.h │ └── types │ │ ├── CMakeLists.txt │ │ ├── se3_ops.h │ │ ├── se3_ops.hpp │ │ ├── se3quat.h │ │ ├── sim3.h │ │ ├── types_sba.cpp │ │ ├── types_sba.h │ │ ├── types_seven_dof_expmap.cpp │ │ ├── types_seven_dof_expmap.h │ │ ├── types_six_dof_expmap.cpp │ │ └── types_six_dof_expmap.h │ ├── lib │ └── libg2o.so │ └── license-bsd.txt ├── build.sh ├── include ├── Utils.hpp ├── cConverter.h ├── cLocalMapping.h ├── cLoopClosing.h ├── cMap.h ├── cMapPoint.h ├── cMapPublisher.h ├── cMultiFrame.h ├── cMultiFramePublisher.h ├── cMultiInitializer.h ├── cMultiKeyFrame.h ├── cMultiKeyFrameDatabase.h ├── cORBVocabulary.h ├── cORBextractor.h ├── cORBmatcher.h ├── cOptimizer.h ├── cReadImage.h ├── cSim3Solver.h ├── cSystem.h ├── cTracking.h ├── cViewer.h ├── cam_model_omni.h ├── cam_system_omni.h ├── cuda │ ├── Allocator.hpp │ ├── Cuda.hpp │ ├── Fast.hpp │ └── Orb.hpp ├── g2o_MultiCol_sim3_expmap.h ├── g2o_MultiCol_vertices_edges.h ├── mdBRIEFextractor.h ├── mdBRIEFextractor1.h ├── mdBRIEFextractorCon.h ├── mdBRIEFextractorOct.h └── misc.h └── src ├── cConverter.cpp ├── cLocalMapping.cpp ├── cLoopClosing.cpp ├── cMap.cpp ├── cMapPoint.cpp ├── cMapPublisher.cpp ├── cMultiFrame.cpp ├── cMultiFramePublisher.cpp ├── cMultiInitializer.cpp ├── cMultiKeyFrame.cpp ├── cMultiKeyFrameDatabase.cpp ├── cORBmatcher.cpp ├── cOptimizer.cpp ├── cOptimizerLoopStuff.cpp ├── cReadImage.cpp ├── cSim3Solver.cpp ├── cSystem.cpp ├── cTracking.cpp ├── cViewer.cpp ├── cam_model_omni.cpp ├── cam_system_omni.cpp ├── cuda ├── Allocator_gpu.cu ├── Cuda.cu ├── Fast_gpu.cu ├── Frame_gpu.cu ├── Orb_gpu.cu └── test.cu ├── g2o_MultiCol_sim3_expmap.cpp ├── g2o_MultiCol_vertices_edges.cpp ├── mdBRIEFextractorCon.cpp ├── mdBRIEFextractorOct.cpp └── misc.cpp /Examples/Lafida/InteriorOrientationFisheye0.yaml: -------------------------------------------------------------------------------- 1 | %YAML:1.0 2 | 3 | # Camera Parameters. Adjust them! 4 | # Camera calibration parameters camera back 5 | Camera.Iw: 754 6 | Camera.Ih: 480 7 | 8 | # hyperparameters 9 | Camera.nrpol: 5 10 | Camera.nrinvpol: 12 11 | 12 | # forward polynomial f(\rho) 13 | Camera.a0: -209.200757992065 14 | Camera.a1: 0.0 15 | Camera.a2: 0.00213741670953883 16 | Camera.a3: -4.2203617319086e-06 17 | Camera.a4: 1.77146086919594e-08 18 | 19 | # backward polynomial rho(\theta) 20 | Camera.pol0: 293.667187375663 21 | Camera.pol1: 149.982043337335 22 | Camera.pol2: -10.448650568161 23 | Camera.pol3: 28.2295300683376 24 | Camera.pol4: 7.13365723186292 25 | Camera.pol5: 0.056303218962532 26 | Camera.pol6: 10.4144677485333 27 | Camera.pol7: 0.166354960773665 28 | Camera.pol8: -5.86858687381081 29 | Camera.pol9: 1.18165998645705 30 | Camera.pol10: 3.1108311354746 31 | Camera.pol11: 0.810799620714366 32 | 33 | # affine matrix 34 | Camera.c: 0.999626131079017 35 | Camera.d: -0.0034775192597376 36 | Camera.e: 0.00385134991673147 37 | 38 | # principal point 39 | Camera.u0: 392.219508388648 40 | Camera.v0: 243.494438476351 41 | 42 | # create a mirror mask for fisheye cameras 43 | Camera.mirrorMask: 1 44 | 45 | 46 | -------------------------------------------------------------------------------- /Examples/Lafida/InteriorOrientationFisheye1.yaml: -------------------------------------------------------------------------------- 1 | %YAML:1.0 2 | 3 | # Camera Parameters. Adjust them! 4 | # Camera calibration parameters cam right 5 | Camera.Iw: 754 6 | Camera.Ih: 480 7 | 8 | Camera.nrpol: 5 9 | Camera.nrinvpol: 12 10 | 11 | Camera.a0:-209.071570423477 12 | Camera.a1: 0.0 13 | Camera.a2: 0.00216428966944475 14 | Camera.a3: -4.82076123755912e-06 15 | Camera.a4: 1.91902225328321e-08 16 | 17 | Camera.pol0: 294.569975726124 18 | Camera.pol1: 148.608451179358 19 | Camera.pol2: -12.8584962393538 20 | Camera.pol3: 28.8889327437629 21 | Camera.pol4: 6.33883105861485 22 | Camera.pol5:-0.89043629163529 23 | Camera.pol6: 12.3786448516946 24 | Camera.pol7: 0.165754338732521 25 | Camera.pol8: -7.71927140996498 26 | Camera.pol9: 0.995360127219927 27 | Camera.pol10: 3.74959014924028 28 | Camera.pol11: 1.01240838118284 29 | 30 | Camera.c: 1.00025900216253 31 | Camera.d: -0.0123492665428806 32 | Camera.e: 0.012594227848688 33 | 34 | Camera.u0: 378.722262294544 35 | Camera.v0: 253.62515782861 36 | 37 | # create a mirror mask for fisheye cameras 38 | Camera.mirrorMask: 1 -------------------------------------------------------------------------------- /Examples/Lafida/InteriorOrientationFisheye2.yaml: -------------------------------------------------------------------------------- 1 | %YAML:1.0 2 | 3 | # Camera Parameters. Adjust them! 4 | # Camera calibration parameters cam left 5 | Camera.Iw: 754 6 | Camera.Ih: 480 7 | 8 | Camera.nrpol: 5 9 | Camera.nrinvpol: 12 10 | 11 | Camera.a0: -208.409533164304 12 | Camera.a1: 0.0 13 | Camera.a2: 0.00225243935068085 14 | Camera.a3: -5.55430532694086e-06 15 | Camera.a4: 2.07875001352451e-08 16 | 17 | Camera.pol0: 293.775776115273 18 | Camera.pol1: 147.35852428463 19 | Camera.pol2: -14.3964307215767 20 | Camera.pol3: 29.078338589251 21 | Camera.pol4: 6.03461468718202 22 | Camera.pol5:-2.07410652721192 23 | Camera.pol6: 13.4359111214281 24 | Camera.pol7: 0.984397095348803 25 | Camera.pol8: -8.64924421339311 26 | Camera.pol9: 0.491570292475276 27 | Camera.pol10: 3.92296807229949 28 | Camera.pol11: 1.10563269391099 29 | 30 | Camera.c: 0.99992772614797 31 | Camera.d: 0.0334716840387143 32 | Camera.e: -0.0332451389561491 33 | 34 | Camera.u0: 372.796912405235 35 | Camera.v0: 225.645071214684 36 | 37 | # create a mirror mask for fisheye cameras 38 | Camera.mirrorMask: 1 39 | -------------------------------------------------------------------------------- /Examples/Lafida/MultiCamSys_Calibration.yaml: -------------------------------------------------------------------------------- 1 | %YAML:1.0 2 | 3 | # Multi-camera calibration matrices (M_c) 4 | # rotation elements are in cayley parametrization 5 | CameraSystem.nrCams: 3 6 | # camera back 7 | CameraSystem.cam1_1: -0.0238361786473007 #r1 8 | CameraSystem.cam1_2: -2.05998171167958 #r2 9 | CameraSystem.cam1_3: 0.695126790868671 #r3 10 | CameraSystem.cam1_4: -0.140202124607334 #t1 11 | CameraSystem.cam1_5: 0.0219677971160655 #t2 12 | CameraSystem.cam1_6: -0.0226322662838432 #t3 13 | # camera right 14 | CameraSystem.cam2_1: -0.0103943566650926 #r1 15 | CameraSystem.cam2_2: 1.12505249943085 #r2 16 | CameraSystem.cam2_3: -0.402901183146028 #r3 17 | CameraSystem.cam2_4: 0.108753418890423 #t1 18 | CameraSystem.cam2_5: 0.0636197216520153 #t2 19 | CameraSystem.cam2_6: 0.0657911760105832 #t3 20 | # camera left 21 | CameraSystem.cam3_1: 0 #r1 22 | CameraSystem.cam3_2: 0 #r2 23 | CameraSystem.cam3_3: 0 #r3 24 | CameraSystem.cam3_4: -0.00157612288268783 #t1 25 | CameraSystem.cam3_5: 0.103615531247527 #t2 26 | CameraSystem.cam3_6: 0.201416323496156 #t3 27 | 28 | 29 | -------------------------------------------------------------------------------- /Examples/Lafida/mult_col_slam_lafida.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/Examples/Lafida/mult_col_slam_lafida.cpp -------------------------------------------------------------------------------- /Examples/Lafida/multi_col_slam_lafida: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/Examples/Lafida/multi_col_slam_lafida -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # GPU-based-feature-extraction-for-VINS-VIO 2 | 3 | This is a GPU based multi-camera visual SLAM. We adopt the SLAM system proposed in [MultiCol-SLAM](https://github.com/urbste/MultiCol-SLAM) and accelerate the feature extraction using CUDA. Our algorithm achieves 15 fps running on TX1. 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /ThirdParty/DBoW2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 2.8) 2 | project(DBoW2) 3 | 4 | IF(WIN32) 5 | SET (DBoW2_LIB_TYPE STATIC) 6 | ELSE() 7 | SET (DBoW2_LIB_TYPE SHARED) 8 | ENDIF(WIN32) 9 | 10 | set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -O3 -march=native ") 11 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -O3 -march=native") 12 | 13 | set(HDRS_DBOW2 14 | DBoW2/BowVector.h 15 | DBoW2/FORB.h 16 | DBoW2/FClass.h 17 | DBoW2/FeatureVector.h 18 | DBoW2/ScoringObject.h 19 | DBoW2/TemplatedVocabulary.h) 20 | set(SRCS_DBOW2 21 | DBoW2/BowVector.cpp 22 | DBoW2/FORB.cpp 23 | DBoW2/FeatureVector.cpp 24 | DBoW2/ScoringObject.cpp) 25 | 26 | set(HDRS_DUTILS 27 | DUtils/Random.h 28 | DUtils/Timestamp.h) 29 | set(SRCS_DUTILS 30 | DUtils/Random.cpp 31 | DUtils/Timestamp.cpp) 32 | 33 | find_package(OpenCV REQUIRED) 34 | 35 | set(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib) 36 | 37 | include_directories(${OpenCV_INCLUDE_DIRS}) 38 | add_library(DBoW2 ${DBoW2_LIB_TYPE} ${SRCS_DBOW2} ${SRCS_DUTILS}) 39 | target_link_libraries(DBoW2 ${OpenCV_LIBS}) 40 | 41 | -------------------------------------------------------------------------------- /ThirdParty/DBoW2/DBoW2/FeatureVector.h: -------------------------------------------------------------------------------- 1 | /** 2 | * File: FeatureVector.h 3 | * Date: November 2011 4 | * Author: Dorian Galvez-Lopez 5 | * Description: feature vector 6 | * License: see the LICENSE.txt file 7 | * 8 | */ 9 | 10 | #ifndef __D_T_FEATURE_VECTOR__ 11 | #define __D_T_FEATURE_VECTOR__ 12 | 13 | #include "BowVector.h" 14 | #include 15 | #include 16 | #include 17 | 18 | namespace DBoW2 { 19 | 20 | /// Vector of nodes with indexes of local features 21 | class FeatureVector: 22 | public std::map > 23 | { 24 | public: 25 | 26 | /** 27 | * Constructor 28 | */ 29 | FeatureVector(void); 30 | 31 | /** 32 | * Destructor 33 | */ 34 | ~FeatureVector(void); 35 | 36 | /** 37 | * Adds a feature to an existing node, or adds a new node with an initial 38 | * feature 39 | * @param id node id to add or to modify 40 | * @param i_feature index of feature to add to the given node 41 | */ 42 | void addFeature(NodeId id, unsigned int i_feature); 43 | 44 | /** 45 | * Sends a string versions of the feature vector through the stream 46 | * @param out stream 47 | * @param v feature vector 48 | */ 49 | friend std::ostream& operator<<(std::ostream &out, const FeatureVector &v); 50 | 51 | }; 52 | 53 | } // namespace DBoW2 54 | 55 | #endif 56 | 57 | -------------------------------------------------------------------------------- /ThirdParty/DBoW2/README.txt: -------------------------------------------------------------------------------- 1 | You should have received this DBoW2 version along with ORB-SLAM2 (https://github.com/raulmur/ORB_SLAM2). 2 | See the original DBoW2 library at: https://github.com/dorian3d/DBoW2 3 | All files included in this version are BSD, see LICENSE.txt 4 | 5 | We also use Random.h, Random.cpp, Timestamp.pp and Timestamp.h from DLib/DUtils. 6 | See the original DLib library at: https://github.com/dorian3d/DLib 7 | All files included in this version are BSD, see LICENSE.txt 8 | -------------------------------------------------------------------------------- /ThirdParty/DBoW2/lib/libDBoW2.so: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/DBoW2/lib/libDBoW2.so -------------------------------------------------------------------------------- /ThirdParty/Eigen/COPYING.BSD: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2011, Intel Corporation. All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without modification, 5 | are permitted provided that the following conditions are met: 6 | 7 | * Redistributions of source code must retain the above copyright notice, this 8 | list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above copyright notice, 10 | this list of conditions and the following disclaimer in the documentation 11 | and/or other materials provided with the distribution. 12 | * Neither the name of Intel Corporation nor the names of its contributors may 13 | be used to endorse or promote products derived from this software without 14 | specific prior written permission. 15 | 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 20 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 23 | ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 | */ -------------------------------------------------------------------------------- /ThirdParty/Eigen/COPYING.README: -------------------------------------------------------------------------------- 1 | Eigen is primarily MPL2 licensed. See COPYING.MPL2 and these links: 2 | http://www.mozilla.org/MPL/2.0/ 3 | http://www.mozilla.org/MPL/2.0/FAQ.html 4 | 5 | Some files contain third-party code under BSD or LGPL licenses, whence the other 6 | COPYING.* files here. 7 | 8 | All the LGPL code is either LGPL 2.1-only, or LGPL 2.1-or-later. 9 | For this reason, the COPYING.LGPL file contains the LGPL 2.1 text. 10 | 11 | If you want to guarantee that the Eigen code that you are #including is licensed 12 | under the MPL2 and possibly more permissive licenses (like BSD), #define this 13 | preprocessor symbol: 14 | EIGEN_MPL2_ONLY 15 | For example, with most compilers, you could add this to your project CXXFLAGS: 16 | -DEIGEN_MPL2_ONLY 17 | This will cause a compilation error to be generated if you #include any code that is 18 | LGPL licensed. 19 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/Array: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_ARRAY_MODULE_H 2 | #define EIGEN_ARRAY_MODULE_H 3 | 4 | // include Core first to handle Eigen2 support macros 5 | #include "Core" 6 | 7 | #ifndef EIGEN2_SUPPORT 8 | #error The Eigen/Array header does no longer exist in Eigen3. All that functionality has moved to Eigen/Core. 9 | #endif 10 | 11 | #endif // EIGEN_ARRAY_MODULE_H 12 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include(RegexUtils) 2 | test_escape_string_as_regex() 3 | 4 | file(GLOB Eigen_directory_files "*") 5 | 6 | escape_string_as_regex(ESCAPED_CMAKE_CURRENT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}") 7 | 8 | foreach(f ${Eigen_directory_files}) 9 | if(NOT f MATCHES "\\.txt" AND NOT f MATCHES "${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/[.].+" AND NOT f MATCHES "${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/src") 10 | list(APPEND Eigen_directory_files_to_install ${f}) 11 | endif() 12 | endforeach(f ${Eigen_directory_files}) 13 | 14 | install(FILES 15 | ${Eigen_directory_files_to_install} 16 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen COMPONENT Devel 17 | ) 18 | 19 | add_subdirectory(src) 20 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/Cholesky: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_CHOLESKY_MODULE_H 2 | #define EIGEN_CHOLESKY_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** \defgroup Cholesky_Module Cholesky module 9 | * 10 | * 11 | * 12 | * This module provides two variants of the Cholesky decomposition for selfadjoint (hermitian) matrices. 13 | * Those decompositions are accessible via the following MatrixBase methods: 14 | * - MatrixBase::llt(), 15 | * - MatrixBase::ldlt() 16 | * 17 | * \code 18 | * #include 19 | * \endcode 20 | */ 21 | 22 | #include "src/misc/Solve.h" 23 | #include "src/Cholesky/LLT.h" 24 | #include "src/Cholesky/LDLT.h" 25 | #ifdef EIGEN_USE_LAPACKE 26 | #include "src/Cholesky/LLT_MKL.h" 27 | #endif 28 | 29 | #include "src/Core/util/ReenableStupidWarnings.h" 30 | 31 | #endif // EIGEN_CHOLESKY_MODULE_H 32 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 33 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/Dense: -------------------------------------------------------------------------------- 1 | #include "Core" 2 | #include "LU" 3 | #include "Cholesky" 4 | #include "QR" 5 | #include "SVD" 6 | #include "Geometry" 7 | #include "Eigenvalues" 8 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/Eigen: -------------------------------------------------------------------------------- 1 | #include "Dense" 2 | //#include "Sparse" 3 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/Eigenvalues: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_EIGENVALUES_MODULE_H 2 | #define EIGEN_EIGENVALUES_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include "Cholesky" 9 | #include "Jacobi" 10 | #include "Householder" 11 | #include "LU" 12 | #include "Geometry" 13 | 14 | /** \defgroup Eigenvalues_Module Eigenvalues module 15 | * 16 | * 17 | * 18 | * This module mainly provides various eigenvalue solvers. 19 | * This module also provides some MatrixBase methods, including: 20 | * - MatrixBase::eigenvalues(), 21 | * - MatrixBase::operatorNorm() 22 | * 23 | * \code 24 | * #include 25 | * \endcode 26 | */ 27 | 28 | #include "src/Eigenvalues/Tridiagonalization.h" 29 | #include "src/Eigenvalues/RealSchur.h" 30 | #include "src/Eigenvalues/EigenSolver.h" 31 | #include "src/Eigenvalues/SelfAdjointEigenSolver.h" 32 | #include "src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h" 33 | #include "src/Eigenvalues/HessenbergDecomposition.h" 34 | #include "src/Eigenvalues/ComplexSchur.h" 35 | #include "src/Eigenvalues/ComplexEigenSolver.h" 36 | #include "src/Eigenvalues/RealQZ.h" 37 | #include "src/Eigenvalues/GeneralizedEigenSolver.h" 38 | #include "src/Eigenvalues/MatrixBaseEigenvalues.h" 39 | #ifdef EIGEN_USE_LAPACKE 40 | #include "src/Eigenvalues/RealSchur_MKL.h" 41 | #include "src/Eigenvalues/ComplexSchur_MKL.h" 42 | #include "src/Eigenvalues/SelfAdjointEigenSolver_MKL.h" 43 | #endif 44 | 45 | #include "src/Core/util/ReenableStupidWarnings.h" 46 | 47 | #endif // EIGEN_EIGENVALUES_MODULE_H 48 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 49 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/Householder: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_HOUSEHOLDER_MODULE_H 2 | #define EIGEN_HOUSEHOLDER_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** \defgroup Householder_Module Householder module 9 | * This module provides Householder transformations. 10 | * 11 | * \code 12 | * #include 13 | * \endcode 14 | */ 15 | 16 | #include "src/Householder/Householder.h" 17 | #include "src/Householder/HouseholderSequence.h" 18 | #include "src/Householder/BlockHouseholder.h" 19 | 20 | #include "src/Core/util/ReenableStupidWarnings.h" 21 | 22 | #endif // EIGEN_HOUSEHOLDER_MODULE_H 23 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 24 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/Jacobi: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_JACOBI_MODULE_H 2 | #define EIGEN_JACOBI_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** \defgroup Jacobi_Module Jacobi module 9 | * This module provides Jacobi and Givens rotations. 10 | * 11 | * \code 12 | * #include 13 | * \endcode 14 | * 15 | * In addition to listed classes, it defines the two following MatrixBase methods to apply a Jacobi or Givens rotation: 16 | * - MatrixBase::applyOnTheLeft() 17 | * - MatrixBase::applyOnTheRight(). 18 | */ 19 | 20 | #include "src/Jacobi/Jacobi.h" 21 | 22 | #include "src/Core/util/ReenableStupidWarnings.h" 23 | 24 | #endif // EIGEN_JACOBI_MODULE_H 25 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 26 | 27 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/LU: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_LU_MODULE_H 2 | #define EIGEN_LU_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** \defgroup LU_Module LU module 9 | * This module includes %LU decomposition and related notions such as matrix inversion and determinant. 10 | * This module defines the following MatrixBase methods: 11 | * - MatrixBase::inverse() 12 | * - MatrixBase::determinant() 13 | * 14 | * \code 15 | * #include 16 | * \endcode 17 | */ 18 | 19 | #include "src/misc/Solve.h" 20 | #include "src/misc/Kernel.h" 21 | #include "src/misc/Image.h" 22 | #include "src/LU/FullPivLU.h" 23 | #include "src/LU/PartialPivLU.h" 24 | #ifdef EIGEN_USE_LAPACKE 25 | #include "src/LU/PartialPivLU_MKL.h" 26 | #endif 27 | #include "src/LU/Determinant.h" 28 | #include "src/LU/Inverse.h" 29 | 30 | #if defined EIGEN_VECTORIZE_SSE 31 | #include "src/LU/arch/Inverse_SSE.h" 32 | #endif 33 | 34 | #ifdef EIGEN2_SUPPORT 35 | #include "src/Eigen2Support/LU.h" 36 | #endif 37 | 38 | #include "src/Core/util/ReenableStupidWarnings.h" 39 | 40 | #endif // EIGEN_LU_MODULE_H 41 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 42 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/LeastSquares: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_REGRESSION_MODULE_H 2 | #define EIGEN_REGRESSION_MODULE_H 3 | 4 | #ifndef EIGEN2_SUPPORT 5 | #error LeastSquares is only available in Eigen2 support mode (define EIGEN2_SUPPORT) 6 | #endif 7 | 8 | // exclude from normal eigen3-only documentation 9 | #ifdef EIGEN2_SUPPORT 10 | 11 | #include "Core" 12 | 13 | #include "src/Core/util/DisableStupidWarnings.h" 14 | 15 | #include "Eigenvalues" 16 | #include "Geometry" 17 | 18 | /** \defgroup LeastSquares_Module LeastSquares module 19 | * This module provides linear regression and related features. 20 | * 21 | * \code 22 | * #include 23 | * \endcode 24 | */ 25 | 26 | #include "src/Eigen2Support/LeastSquares.h" 27 | 28 | #include "src/Core/util/ReenableStupidWarnings.h" 29 | 30 | #endif // EIGEN2_SUPPORT 31 | 32 | #endif // EIGEN_REGRESSION_MODULE_H 33 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/MetisSupport: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_METISSUPPORT_MODULE_H 2 | #define EIGEN_METISSUPPORT_MODULE_H 3 | 4 | #include "SparseCore" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | extern "C" { 9 | #include 10 | } 11 | 12 | 13 | /** \ingroup Support_modules 14 | * \defgroup MetisSupport_Module MetisSupport module 15 | * 16 | * \code 17 | * #include 18 | * \endcode 19 | * This module defines an interface to the METIS reordering package (http://glaros.dtc.umn.edu/gkhome/views/metis). 20 | * It can be used just as any other built-in method as explained in \link OrderingMethods_Module here. \endlink 21 | */ 22 | 23 | 24 | #include "src/MetisSupport/MetisSupport.h" 25 | 26 | #include "src/Core/util/ReenableStupidWarnings.h" 27 | 28 | #endif // EIGEN_METISSUPPORT_MODULE_H 29 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/PardisoSupport: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_PARDISOSUPPORT_MODULE_H 2 | #define EIGEN_PARDISOSUPPORT_MODULE_H 3 | 4 | #include "SparseCore" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include 9 | 10 | #include 11 | 12 | /** \ingroup Support_modules 13 | * \defgroup PardisoSupport_Module PardisoSupport module 14 | * 15 | * This module brings support for the Intel(R) MKL PARDISO direct sparse solvers. 16 | * 17 | * \code 18 | * #include 19 | * \endcode 20 | * 21 | * In order to use this module, the MKL headers must be accessible from the include paths, and your binary must be linked to the MKL library and its dependencies. 22 | * See this \ref TopicUsingIntelMKL "page" for more information on MKL-Eigen integration. 23 | * 24 | */ 25 | 26 | #include "src/PardisoSupport/PardisoSupport.h" 27 | 28 | #include "src/Core/util/ReenableStupidWarnings.h" 29 | 30 | #endif // EIGEN_PARDISOSUPPORT_MODULE_H 31 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/QR: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_QR_MODULE_H 2 | #define EIGEN_QR_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include "Cholesky" 9 | #include "Jacobi" 10 | #include "Householder" 11 | 12 | /** \defgroup QR_Module QR module 13 | * 14 | * 15 | * 16 | * This module provides various QR decompositions 17 | * This module also provides some MatrixBase methods, including: 18 | * - MatrixBase::qr(), 19 | * 20 | * \code 21 | * #include 22 | * \endcode 23 | */ 24 | 25 | #include "src/misc/Solve.h" 26 | #include "src/QR/HouseholderQR.h" 27 | #include "src/QR/FullPivHouseholderQR.h" 28 | #include "src/QR/ColPivHouseholderQR.h" 29 | #ifdef EIGEN_USE_LAPACKE 30 | #include "src/QR/HouseholderQR_MKL.h" 31 | #include "src/QR/ColPivHouseholderQR_MKL.h" 32 | #endif 33 | 34 | #ifdef EIGEN2_SUPPORT 35 | #include "src/Eigen2Support/QR.h" 36 | #endif 37 | 38 | #include "src/Core/util/ReenableStupidWarnings.h" 39 | 40 | #ifdef EIGEN2_SUPPORT 41 | #include "Eigenvalues" 42 | #endif 43 | 44 | #endif // EIGEN_QR_MODULE_H 45 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 46 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/QtAlignedMalloc: -------------------------------------------------------------------------------- 1 | 2 | #ifndef EIGEN_QTMALLOC_MODULE_H 3 | #define EIGEN_QTMALLOC_MODULE_H 4 | 5 | #include "Core" 6 | 7 | #if (!EIGEN_MALLOC_ALREADY_ALIGNED) 8 | 9 | #include "src/Core/util/DisableStupidWarnings.h" 10 | 11 | void *qMalloc(size_t size) 12 | { 13 | return Eigen::internal::aligned_malloc(size); 14 | } 15 | 16 | void qFree(void *ptr) 17 | { 18 | Eigen::internal::aligned_free(ptr); 19 | } 20 | 21 | void *qRealloc(void *ptr, size_t size) 22 | { 23 | void* newPtr = Eigen::internal::aligned_malloc(size); 24 | memcpy(newPtr, ptr, size); 25 | Eigen::internal::aligned_free(ptr); 26 | return newPtr; 27 | } 28 | 29 | #include "src/Core/util/ReenableStupidWarnings.h" 30 | 31 | #endif 32 | 33 | #endif // EIGEN_QTMALLOC_MODULE_H 34 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 35 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/SPQRSupport: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_SPQRSUPPORT_MODULE_H 2 | #define EIGEN_SPQRSUPPORT_MODULE_H 3 | 4 | #include "SparseCore" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include "SuiteSparseQR.hpp" 9 | 10 | /** \ingroup Support_modules 11 | * \defgroup SPQRSupport_Module SuiteSparseQR module 12 | * 13 | * This module provides an interface to the SPQR library, which is part of the suitesparse package. 14 | * 15 | * \code 16 | * #include 17 | * \endcode 18 | * 19 | * In order to use this module, the SPQR headers must be accessible from the include paths, and your binary must be linked to the SPQR library and its dependencies (Cholmod, AMD, COLAMD,...). 20 | * For a cmake based project, you can use our FindSPQR.cmake and FindCholmod.Cmake modules 21 | * 22 | */ 23 | 24 | #include "src/misc/Solve.h" 25 | #include "src/misc/SparseSolve.h" 26 | #include "src/CholmodSupport/CholmodSupport.h" 27 | #include "src/SPQRSupport/SuiteSparseQRSupport.h" 28 | 29 | #endif 30 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/SVD: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_SVD_MODULE_H 2 | #define EIGEN_SVD_MODULE_H 3 | 4 | #include "QR" 5 | #include "Householder" 6 | #include "Jacobi" 7 | 8 | #include "src/Core/util/DisableStupidWarnings.h" 9 | 10 | /** \defgroup SVD_Module SVD module 11 | * 12 | * 13 | * 14 | * This module provides SVD decomposition for matrices (both real and complex). 15 | * This decomposition is accessible via the following MatrixBase method: 16 | * - MatrixBase::jacobiSvd() 17 | * 18 | * \code 19 | * #include 20 | * \endcode 21 | */ 22 | 23 | #include "src/misc/Solve.h" 24 | #include "src/SVD/JacobiSVD.h" 25 | #if defined(EIGEN_USE_LAPACKE) && !defined(EIGEN_USE_LAPACKE_STRICT) 26 | #include "src/SVD/JacobiSVD_MKL.h" 27 | #endif 28 | #include "src/SVD/UpperBidiagonalization.h" 29 | 30 | #ifdef EIGEN2_SUPPORT 31 | #include "src/Eigen2Support/SVD.h" 32 | #endif 33 | 34 | #include "src/Core/util/ReenableStupidWarnings.h" 35 | 36 | #endif // EIGEN_SVD_MODULE_H 37 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 38 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/Sparse: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_SPARSE_MODULE_H 2 | #define EIGEN_SPARSE_MODULE_H 3 | 4 | /** \defgroup Sparse_Module Sparse meta-module 5 | * 6 | * Meta-module including all related modules: 7 | * - \ref SparseCore_Module 8 | * - \ref OrderingMethods_Module 9 | * - \ref SparseCholesky_Module 10 | * - \ref SparseLU_Module 11 | * - \ref SparseQR_Module 12 | * - \ref IterativeLinearSolvers_Module 13 | * 14 | * \code 15 | * #include 16 | * \endcode 17 | */ 18 | 19 | #include "SparseCore" 20 | #include "OrderingMethods" 21 | #include "SparseCholesky" 22 | #include "SparseLU" 23 | #include "SparseQR" 24 | #include "IterativeLinearSolvers" 25 | 26 | #endif // EIGEN_SPARSE_MODULE_H 27 | 28 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/SparseQR: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_SPARSEQR_MODULE_H 2 | #define EIGEN_SPARSEQR_MODULE_H 3 | 4 | #include "SparseCore" 5 | #include "OrderingMethods" 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** \defgroup SparseQR_Module SparseQR module 9 | * \brief Provides QR decomposition for sparse matrices 10 | * 11 | * This module provides a simplicial version of the left-looking Sparse QR decomposition. 12 | * The columns of the input matrix should be reordered to limit the fill-in during the 13 | * decomposition. Built-in methods (COLAMD, AMD) or external methods (METIS) can be used to this end. 14 | * See the \link OrderingMethods_Module OrderingMethods\endlink module for the list 15 | * of built-in and external ordering methods. 16 | * 17 | * \code 18 | * #include 19 | * \endcode 20 | * 21 | * 22 | */ 23 | 24 | #include "src/misc/Solve.h" 25 | #include "src/misc/SparseSolve.h" 26 | 27 | #include "OrderingMethods" 28 | #include "src/SparseCore/SparseColEtree.h" 29 | #include "src/SparseQR/SparseQR.h" 30 | 31 | #include "src/Core/util/ReenableStupidWarnings.h" 32 | 33 | #endif 34 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/StdDeque: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009 Gael Guennebaud 5 | // Copyright (C) 2009 Hauke Heibel 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | #ifndef EIGEN_STDDEQUE_MODULE_H 12 | #define EIGEN_STDDEQUE_MODULE_H 13 | 14 | #include "Core" 15 | #include 16 | 17 | #if (defined(_MSC_VER) && defined(_WIN64)) /* MSVC auto aligns in 64 bit builds */ 18 | 19 | #define EIGEN_DEFINE_STL_DEQUE_SPECIALIZATION(...) 20 | 21 | #else 22 | 23 | #include "src/StlSupport/StdDeque.h" 24 | 25 | #endif 26 | 27 | #endif // EIGEN_STDDEQUE_MODULE_H 28 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/StdList: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009 Hauke Heibel 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_STDLIST_MODULE_H 11 | #define EIGEN_STDLIST_MODULE_H 12 | 13 | #include "Core" 14 | #include 15 | 16 | #if (defined(_MSC_VER) && defined(_WIN64)) /* MSVC auto aligns in 64 bit builds */ 17 | 18 | #define EIGEN_DEFINE_STL_LIST_SPECIALIZATION(...) 19 | 20 | #else 21 | 22 | #include "src/StlSupport/StdList.h" 23 | 24 | #endif 25 | 26 | #endif // EIGEN_STDLIST_MODULE_H 27 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/StdVector: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009 Gael Guennebaud 5 | // Copyright (C) 2009 Hauke Heibel 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | #ifndef EIGEN_STDVECTOR_MODULE_H 12 | #define EIGEN_STDVECTOR_MODULE_H 13 | 14 | #include "Core" 15 | #include 16 | 17 | #if (defined(_MSC_VER) && defined(_WIN64)) /* MSVC auto aligns in 64 bit builds */ 18 | 19 | #define EIGEN_DEFINE_STL_VECTOR_SPECIALIZATION(...) 20 | 21 | #else 22 | 23 | #include "src/StlSupport/StdVector.h" 24 | 25 | #endif 26 | 27 | #endif // EIGEN_STDVECTOR_MODULE_H 28 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/UmfPackSupport: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_UMFPACKSUPPORT_MODULE_H 2 | #define EIGEN_UMFPACKSUPPORT_MODULE_H 3 | 4 | #include "SparseCore" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | extern "C" { 9 | #include 10 | } 11 | 12 | /** \ingroup Support_modules 13 | * \defgroup UmfPackSupport_Module UmfPackSupport module 14 | * 15 | * This module provides an interface to the UmfPack library which is part of the suitesparse package. 16 | * It provides the following factorization class: 17 | * - class UmfPackLU: a multifrontal sequential LU factorization. 18 | * 19 | * \code 20 | * #include 21 | * \endcode 22 | * 23 | * In order to use this module, the umfpack headers must be accessible from the include paths, and your binary must be linked to the umfpack library and its dependencies. 24 | * The dependencies depend on how umfpack has been compiled. 25 | * For a cmake based project, you can use our FindUmfPack.cmake module to help you in this task. 26 | * 27 | */ 28 | 29 | #include "src/misc/Solve.h" 30 | #include "src/misc/SparseSolve.h" 31 | 32 | #include "src/UmfPackSupport/UmfPackSupport.h" 33 | 34 | #include "src/Core/util/ReenableStupidWarnings.h" 35 | 36 | #endif // EIGEN_UMFPACKSUPPORT_MODULE_H 37 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | file(GLOB Eigen_src_subdirectories "*") 2 | escape_string_as_regex(ESCAPED_CMAKE_CURRENT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}") 3 | foreach(f ${Eigen_src_subdirectories}) 4 | if(NOT f MATCHES "\\.txt" AND NOT f MATCHES "${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/[.].+" ) 5 | add_subdirectory(${f}) 6 | endif() 7 | endforeach() 8 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/Cholesky/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Cholesky_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Cholesky_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Cholesky COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/CholmodSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_CholmodSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_CholmodSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/CholmodSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/Core/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core COMPONENT Devel 6 | ) 7 | 8 | ADD_SUBDIRECTORY(products) 9 | ADD_SUBDIRECTORY(util) 10 | ADD_SUBDIRECTORY(arch) 11 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/Core/arch/AltiVec/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_arch_AltiVec_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_arch_AltiVec_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/AltiVec COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/Core/arch/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | ADD_SUBDIRECTORY(SSE) 2 | ADD_SUBDIRECTORY(AltiVec) 3 | ADD_SUBDIRECTORY(NEON) 4 | ADD_SUBDIRECTORY(Default) 5 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/Core/arch/Default/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_arch_Default_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_arch_Default_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/Default COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/Core/arch/NEON/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_arch_NEON_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_arch_NEON_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/NEON COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/Core/arch/SSE/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_arch_SSE_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_arch_SSE_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/SSE COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/Core/products/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_Product_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_Product_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/products COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/Core/util/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_util_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_util_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/util COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/Core/util/NonMPL2.h: -------------------------------------------------------------------------------- 1 | #ifdef EIGEN_MPL2_ONLY 2 | #error Including non-MPL2 code in EIGEN_MPL2_ONLY mode 3 | #endif 4 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/Core/util/ReenableStupidWarnings.h: -------------------------------------------------------------------------------- 1 | #ifdef EIGEN_WARNINGS_DISABLED 2 | #undef EIGEN_WARNINGS_DISABLED 3 | 4 | #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS 5 | #ifdef _MSC_VER 6 | #pragma warning( pop ) 7 | #elif defined __INTEL_COMPILER 8 | #pragma warning pop 9 | #elif defined __clang__ 10 | #pragma clang diagnostic pop 11 | #elif defined __GNUC__ && __GNUC__>=6 12 | #pragma GCC diagnostic pop 13 | #endif 14 | 15 | #endif 16 | 17 | #endif // EIGEN_WARNINGS_DISABLED 18 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/Eigen2Support/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Eigen2Support_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Eigen2Support_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Eigen2Support COMPONENT Devel 6 | ) 7 | 8 | ADD_SUBDIRECTORY(Geometry) -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/Eigen2Support/Geometry/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Eigen2Support_Geometry_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Eigen2Support_Geometry_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Eigen2Support/Geometry 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/Eigen2Support/Macros.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2011 Benoit Jacob 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 EIGEN2_MACROS_H 11 | #define EIGEN2_MACROS_H 12 | 13 | #define ei_assert eigen_assert 14 | #define ei_internal_assert eigen_internal_assert 15 | 16 | #define EIGEN_ALIGN_128 EIGEN_ALIGN16 17 | 18 | #define EIGEN_ARCH_WANTS_ALIGNMENT EIGEN_ALIGN_STATICALLY 19 | 20 | #endif // EIGEN2_MACROS_H 21 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/Eigenvalues/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_EIGENVALUES_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_EIGENVALUES_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Eigenvalues COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/Geometry/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Geometry_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Geometry_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Geometry COMPONENT Devel 6 | ) 7 | 8 | ADD_SUBDIRECTORY(arch) 9 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/Geometry/arch/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Geometry_arch_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Geometry_arch_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Geometry/arch COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/Householder/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Householder_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Householder_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Householder COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/IterativeLinearSolvers/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_IterativeLinearSolvers_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_IterativeLinearSolvers_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/IterativeLinearSolvers COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/Jacobi/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Jacobi_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Jacobi_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Jacobi COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/LU/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_LU_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_LU_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/LU COMPONENT Devel 6 | ) 7 | 8 | ADD_SUBDIRECTORY(arch) 9 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/LU/arch/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_LU_arch_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_LU_arch_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/LU/arch COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/MetisSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_MetisSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_MetisSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/MetisSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/OrderingMethods/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_OrderingMethods_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_OrderingMethods_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/OrderingMethods COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/PaStiXSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_PastixSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_PastixSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/PaStiXSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/PardisoSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_PardisoSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_PardisoSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/PardisoSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/QR/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_QR_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_QR_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/QR COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/SPQRSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SPQRSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SPQRSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SPQRSupport/ COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/SVD/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SVD_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SVD_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SVD COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/SparseCholesky/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SparseCholesky_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SparseCholesky_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SparseCholesky COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/SparseCore/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SparseCore_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SparseCore_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SparseCore COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/SparseCore/SparseFuzzy.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008 Gael Guennebaud 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_SPARSE_FUZZY_H 11 | #define EIGEN_SPARSE_FUZZY_H 12 | 13 | // template 14 | // template 15 | // bool SparseMatrixBase::isApprox( 16 | // const OtherDerived& other, 17 | // typename NumTraits::Real prec 18 | // ) const 19 | // { 20 | // const typename internal::nested::type nested(derived()); 21 | // const typename internal::nested::type otherNested(other.derived()); 22 | // return (nested - otherNested).cwise().abs2().sum() 23 | // <= prec * prec * (std::min)(nested.cwise().abs2().sum(), otherNested.cwise().abs2().sum()); 24 | // } 25 | 26 | #endif // EIGEN_SPARSE_FUZZY_H 27 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/SparseLU/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SparseLU_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SparseLU_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SparseLU COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/SparseQR/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SparseQR_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SparseQR_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SparseQR/ COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/StlSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_StlSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_StlSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/StlSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/SuperLUSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SuperLUSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SuperLUSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SuperLUSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/UmfPackSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_UmfPackSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_UmfPackSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/UmfPackSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/misc/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_misc_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_misc_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/misc COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/Eigen/src/plugins/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_plugins_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_plugins_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/plugins COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/cmake/EigenDetermineVSServicePack.cmake: -------------------------------------------------------------------------------- 1 | include(CMakeDetermineVSServicePack) 2 | 3 | # The code is almost identical to the CMake version. The only difference is that we remove 4 | # _DetermineVSServicePack_FastCheckVersionWithCompiler which lead to errors on some systems. 5 | function(EigenDetermineVSServicePack _pack) 6 | if(NOT DETERMINED_VS_SERVICE_PACK OR NOT ${_pack}) 7 | 8 | if(NOT DETERMINED_VS_SERVICE_PACK) 9 | _DetermineVSServicePack_CheckVersionWithTryCompile(DETERMINED_VS_SERVICE_PACK _cl_version) 10 | if(NOT DETERMINED_VS_SERVICE_PACK) 11 | _DetermineVSServicePack_CheckVersionWithTryRun(DETERMINED_VS_SERVICE_PACK _cl_version) 12 | endif() 13 | endif() 14 | 15 | if(DETERMINED_VS_SERVICE_PACK) 16 | 17 | if(_cl_version) 18 | # Call helper function to determine VS version 19 | _DetermineVSServicePackFromCompiler(_sp "${_cl_version}") 20 | if(_sp) 21 | set(${_pack} ${_sp} CACHE INTERNAL 22 | "The Visual Studio Release with Service Pack") 23 | endif() 24 | endif() 25 | endif() 26 | endif() 27 | endfunction() 28 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/cmake/FindAdolc.cmake: -------------------------------------------------------------------------------- 1 | 2 | if (ADOLC_INCLUDES AND ADOLC_LIBRARIES) 3 | set(ADOLC_FIND_QUIETLY TRUE) 4 | endif (ADOLC_INCLUDES AND ADOLC_LIBRARIES) 5 | 6 | find_path(ADOLC_INCLUDES 7 | NAMES 8 | adolc/adouble.h 9 | PATHS 10 | $ENV{ADOLCDIR} 11 | ${INCLUDE_INSTALL_DIR} 12 | ) 13 | 14 | find_library(ADOLC_LIBRARIES adolc PATHS $ENV{ADOLCDIR} ${LIB_INSTALL_DIR}) 15 | 16 | include(FindPackageHandleStandardArgs) 17 | find_package_handle_standard_args(ADOLC DEFAULT_MSG 18 | ADOLC_INCLUDES ADOLC_LIBRARIES) 19 | 20 | mark_as_advanced(ADOLC_INCLUDES ADOLC_LIBRARIES) 21 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/cmake/FindGMP.cmake: -------------------------------------------------------------------------------- 1 | # Try to find the GNU Multiple Precision Arithmetic Library (GMP) 2 | # See http://gmplib.org/ 3 | 4 | if (GMP_INCLUDES AND GMP_LIBRARIES) 5 | set(GMP_FIND_QUIETLY TRUE) 6 | endif (GMP_INCLUDES AND GMP_LIBRARIES) 7 | 8 | find_path(GMP_INCLUDES 9 | NAMES 10 | gmp.h 11 | PATHS 12 | $ENV{GMPDIR} 13 | ${INCLUDE_INSTALL_DIR} 14 | ) 15 | 16 | find_library(GMP_LIBRARIES gmp PATHS $ENV{GMPDIR} ${LIB_INSTALL_DIR}) 17 | 18 | include(FindPackageHandleStandardArgs) 19 | find_package_handle_standard_args(GMP DEFAULT_MSG 20 | GMP_INCLUDES GMP_LIBRARIES) 21 | mark_as_advanced(GMP_INCLUDES GMP_LIBRARIES) 22 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/cmake/FindGoogleHash.cmake: -------------------------------------------------------------------------------- 1 | 2 | if (GOOGLEHASH_INCLUDES AND GOOGLEHASH_LIBRARIES) 3 | set(GOOGLEHASH_FIND_QUIETLY TRUE) 4 | endif (GOOGLEHASH_INCLUDES AND GOOGLEHASH_LIBRARIES) 5 | 6 | find_path(GOOGLEHASH_INCLUDES 7 | NAMES 8 | google/dense_hash_map 9 | PATHS 10 | ${INCLUDE_INSTALL_DIR} 11 | ) 12 | 13 | if(GOOGLEHASH_INCLUDES) 14 | # let's make sure it compiles with the current compiler 15 | file(WRITE ${CMAKE_BINARY_DIR}/googlehash_test.cpp 16 | "#include \n#include \nint main(int argc, char** argv) { google::dense_hash_map a; google::sparse_hash_map b; return 0;}\n") 17 | try_compile(GOOGLEHASH_COMPILE ${CMAKE_BINARY_DIR} ${CMAKE_BINARY_DIR}/googlehash_test.cpp OUTPUT_VARIABLE GOOGLEHASH_COMPILE_RESULT) 18 | endif(GOOGLEHASH_INCLUDES) 19 | 20 | include(FindPackageHandleStandardArgs) 21 | find_package_handle_standard_args(GOOGLEHASH DEFAULT_MSG GOOGLEHASH_INCLUDES GOOGLEHASH_COMPILE) 22 | 23 | mark_as_advanced(GOOGLEHASH_INCLUDES) 24 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/cmake/FindPastix.cmake: -------------------------------------------------------------------------------- 1 | # Pastix lib requires linking to a blas library. 2 | # It is up to the user of this module to find a BLAS and link to it. 3 | # Pastix requires SCOTCH or METIS (partitioning and reordering tools) as well 4 | 5 | if (PASTIX_INCLUDES AND PASTIX_LIBRARIES) 6 | set(PASTIX_FIND_QUIETLY TRUE) 7 | endif (PASTIX_INCLUDES AND PASTIX_LIBRARIES) 8 | 9 | find_path(PASTIX_INCLUDES 10 | NAMES 11 | pastix_nompi.h 12 | PATHS 13 | $ENV{PASTIXDIR} 14 | ${INCLUDE_INSTALL_DIR} 15 | ) 16 | 17 | find_library(PASTIX_LIBRARIES pastix PATHS $ENV{PASTIXDIR} ${LIB_INSTALL_DIR}) 18 | 19 | 20 | 21 | include(FindPackageHandleStandardArgs) 22 | find_package_handle_standard_args(PASTIX DEFAULT_MSG 23 | PASTIX_INCLUDES PASTIX_LIBRARIES) 24 | 25 | mark_as_advanced(PASTIX_INCLUDES PASTIX_LIBRARIES) 26 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/cmake/FindSPQR.cmake: -------------------------------------------------------------------------------- 1 | # SPQR lib usually requires linking to a blas and lapack library. 2 | # It is up to the user of this module to find a BLAS and link to it. 3 | 4 | # SPQR lib requires Cholmod, colamd and amd as well. 5 | # FindCholmod.cmake can be used to find those packages before finding spqr 6 | 7 | if (SPQR_INCLUDES AND SPQR_LIBRARIES) 8 | set(SPQR_FIND_QUIETLY TRUE) 9 | endif (SPQR_INCLUDES AND SPQR_LIBRARIES) 10 | 11 | find_path(SPQR_INCLUDES 12 | NAMES 13 | SuiteSparseQR.hpp 14 | PATHS 15 | $ENV{SPQRDIR} 16 | ${INCLUDE_INSTALL_DIR} 17 | PATH_SUFFIXES 18 | suitesparse 19 | ufsparse 20 | ) 21 | 22 | find_library(SPQR_LIBRARIES spqr $ENV{SPQRDIR} ${LIB_INSTALL_DIR}) 23 | 24 | if(SPQR_LIBRARIES) 25 | 26 | find_library(SUITESPARSE_LIBRARY SuiteSparse PATHS $ENV{SPQRDIR} ${LIB_INSTALL_DIR}) 27 | if (SUITESPARSE_LIBRARY) 28 | set(SPQR_LIBRARIES ${SPQR_LIBRARIES} ${SUITESPARSE_LIBRARY}) 29 | endif() 30 | 31 | find_library(CHOLMOD_LIBRARY cholmod PATHS $ENV{UMFPACK_LIBDIR} $ENV{UMFPACKDIR} ${LIB_INSTALL_DIR}) 32 | if(CHOLMOD_LIBRARY) 33 | set(SPQR_LIBRARIES ${SPQR_LIBRARIES} ${CHOLMOD_LIBRARY}) 34 | endif() 35 | 36 | endif(SPQR_LIBRARIES) 37 | 38 | include(FindPackageHandleStandardArgs) 39 | find_package_handle_standard_args(SPQR DEFAULT_MSG SPQR_INCLUDES SPQR_LIBRARIES) 40 | 41 | mark_as_advanced(SPQR_INCLUDES SPQR_LIBRARIES) -------------------------------------------------------------------------------- /ThirdParty/Eigen/cmake/FindScotch.cmake: -------------------------------------------------------------------------------- 1 | # Pastix requires SCOTCH or METIS (partitioning and reordering tools) 2 | 3 | if (SCOTCH_INCLUDES AND SCOTCH_LIBRARIES) 4 | set(SCOTCH_FIND_QUIETLY TRUE) 5 | endif (SCOTCH_INCLUDES AND SCOTCH_LIBRARIES) 6 | 7 | find_path(SCOTCH_INCLUDES 8 | NAMES 9 | scotch.h 10 | PATHS 11 | $ENV{SCOTCHDIR} 12 | ${INCLUDE_INSTALL_DIR} 13 | PATH_SUFFIXES 14 | scotch 15 | ) 16 | 17 | 18 | find_library(SCOTCH_LIBRARIES scotch PATHS $ENV{SCOTCHDIR} ${LIB_INSTALL_DIR}) 19 | 20 | include(FindPackageHandleStandardArgs) 21 | find_package_handle_standard_args(SCOTCH DEFAULT_MSG 22 | SCOTCH_INCLUDES SCOTCH_LIBRARIES) 23 | 24 | mark_as_advanced(SCOTCH_INCLUDES SCOTCH_LIBRARIES) 25 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/cmake/FindSuperLU.cmake: -------------------------------------------------------------------------------- 1 | 2 | # Umfpack lib usually requires linking to a blas library. 3 | # It is up to the user of this module to find a BLAS and link to it. 4 | 5 | if (SUPERLU_INCLUDES AND SUPERLU_LIBRARIES) 6 | set(SUPERLU_FIND_QUIETLY TRUE) 7 | endif (SUPERLU_INCLUDES AND SUPERLU_LIBRARIES) 8 | 9 | find_path(SUPERLU_INCLUDES 10 | NAMES 11 | supermatrix.h 12 | PATHS 13 | $ENV{SUPERLUDIR} 14 | ${INCLUDE_INSTALL_DIR} 15 | PATH_SUFFIXES 16 | superlu 17 | SRC 18 | ) 19 | 20 | find_library(SUPERLU_LIBRARIES superlu PATHS $ENV{SUPERLUDIR} ${LIB_INSTALL_DIR} PATH_SUFFIXES lib) 21 | 22 | include(FindPackageHandleStandardArgs) 23 | find_package_handle_standard_args(SUPERLU DEFAULT_MSG 24 | SUPERLU_INCLUDES SUPERLU_LIBRARIES) 25 | 26 | mark_as_advanced(SUPERLU_INCLUDES SUPERLU_LIBRARIES) 27 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/cmake/RegexUtils.cmake: -------------------------------------------------------------------------------- 1 | function(escape_string_as_regex _str_out _str_in) 2 | STRING(REGEX REPLACE "\\\\" "\\\\\\\\" FILETEST2 "${_str_in}") 3 | STRING(REGEX REPLACE "([.$+*?|-])" "\\\\\\1" FILETEST2 "${FILETEST2}") 4 | STRING(REGEX REPLACE "\\^" "\\\\^" FILETEST2 "${FILETEST2}") 5 | STRING(REGEX REPLACE "\\(" "\\\\(" FILETEST2 "${FILETEST2}") 6 | STRING(REGEX REPLACE "\\)" "\\\\)" FILETEST2 "${FILETEST2}") 7 | STRING(REGEX REPLACE "\\[" "\\\\[" FILETEST2 "${FILETEST2}") 8 | STRING(REGEX REPLACE "\\]" "\\\\]" FILETEST2 "${FILETEST2}") 9 | SET(${_str_out} "${FILETEST2}" PARENT_SCOPE) 10 | endfunction() 11 | 12 | function(test_escape_string_as_regex) 13 | SET(test1 "\\.^$-+*()[]?|") 14 | escape_string_as_regex(test2 "${test1}") 15 | SET(testRef "\\\\\\.\\^\\$\\-\\+\\*\\(\\)\\[\\]\\?\\|") 16 | if(NOT test2 STREQUAL testRef) 17 | message("Error in the escape_string_for_regex function : \n ${test1} was escaped as ${test2}, should be ${testRef}") 18 | endif(NOT test2 STREQUAL testRef) 19 | endfunction() -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory(Eigen) 2 | add_subdirectory(doc EXCLUDE_FROM_ALL) 3 | if(EIGEN_LEAVE_TEST_IN_ALL_TARGET) 4 | add_subdirectory(test) # can't do EXCLUDE_FROM_ALL here, breaks CTest 5 | else() 6 | add_subdirectory(test EXCLUDE_FROM_ALL) 7 | endif() 8 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/ArpackSupport: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // 5 | // This Source Code Form is subject to the terms of the Mozilla 6 | // Public License v. 2.0. If a copy of the MPL was not distributed 7 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 8 | 9 | #ifndef EIGEN_ARPACKSUPPORT_MODULE_H 10 | #define EIGEN_ARPACKSUPPORT_MODULE_H 11 | 12 | #include 13 | 14 | #include 15 | 16 | /** \defgroup ArpackSupport_Module Arpack support module 17 | * 18 | * This module provides a wrapper to Arpack, a library for sparse eigenvalue decomposition. 19 | * 20 | * \code 21 | * #include 22 | * \endcode 23 | */ 24 | 25 | #include 26 | #include "src/Eigenvalues/ArpackSelfAdjointEigenSolver.h" 27 | 28 | #include 29 | 30 | #endif // EIGEN_ARPACKSUPPORT_MODULE_H 31 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 32 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/AutoDiff: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008-2009 Gael Guennebaud 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_AUTODIFF_MODULE 11 | #define EIGEN_AUTODIFF_MODULE 12 | 13 | namespace Eigen { 14 | 15 | /** 16 | * \defgroup AutoDiff_Module Auto Diff module 17 | * 18 | * This module features forward automatic differentation via a simple 19 | * templated scalar type wrapper AutoDiffScalar. 20 | * 21 | * Warning : this should NOT be confused with numerical differentiation, which 22 | * is a different method and has its own module in Eigen : \ref NumericalDiff_Module. 23 | * 24 | * \code 25 | * #include 26 | * \endcode 27 | */ 28 | //@{ 29 | 30 | } 31 | 32 | #include "src/AutoDiff/AutoDiffScalar.h" 33 | // #include "src/AutoDiff/AutoDiffVector.h" 34 | #include "src/AutoDiff/AutoDiffJacobian.h" 35 | 36 | namespace Eigen { 37 | //@} 38 | } 39 | 40 | #endif // EIGEN_AUTODIFF_MODULE 41 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(Eigen_HEADERS AdolcForward AlignedVector3 ArpackSupport AutoDiff BVH FFT IterativeSolvers KroneckerProduct LevenbergMarquardt 2 | MatrixFunctions MoreVectorization MPRealSupport NonLinearOptimization NumericalDiff OpenGLSupport Polynomials 3 | Skyline SparseExtra Splines 4 | ) 5 | 6 | install(FILES 7 | ${Eigen_HEADERS} 8 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen COMPONENT Devel 9 | ) 10 | 11 | add_subdirectory(src) 12 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/IterativeSolvers: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008-2009 Gael Guennebaud 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_ITERATIVE_SOLVERS_MODULE_H 11 | #define EIGEN_ITERATIVE_SOLVERS_MODULE_H 12 | 13 | #include 14 | 15 | /** 16 | * \defgroup IterativeSolvers_Module Iterative solvers module 17 | * This module aims to provide various iterative linear and non linear solver algorithms. 18 | * It currently provides: 19 | * - a constrained conjugate gradient 20 | * - a Householder GMRES implementation 21 | * \code 22 | * #include 23 | * \endcode 24 | */ 25 | //@{ 26 | 27 | #include "../../Eigen/src/misc/Solve.h" 28 | #include "../../Eigen/src/misc/SparseSolve.h" 29 | 30 | #ifndef EIGEN_MPL2_ONLY 31 | #include "src/IterativeSolvers/IterationController.h" 32 | #include "src/IterativeSolvers/ConstrainedConjGrad.h" 33 | #endif 34 | 35 | #include "src/IterativeSolvers/IncompleteLU.h" 36 | #include "../../Eigen/Jacobi" 37 | #include "../../Eigen/Householder" 38 | #include "src/IterativeSolvers/GMRES.h" 39 | #include "src/IterativeSolvers/IncompleteCholesky.h" 40 | //#include "src/IterativeSolvers/SSORPreconditioner.h" 41 | #include "src/IterativeSolvers/MINRES.h" 42 | 43 | //@} 44 | 45 | #endif // EIGEN_ITERATIVE_SOLVERS_MODULE_H 46 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/KroneckerProduct: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // 5 | // This Source Code Form is subject to the terms of the Mozilla 6 | // Public License v. 2.0. If a copy of the MPL was not distributed 7 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 8 | 9 | #ifndef EIGEN_KRONECKER_PRODUCT_MODULE_H 10 | #define EIGEN_KRONECKER_PRODUCT_MODULE_H 11 | 12 | #include "../../Eigen/Core" 13 | 14 | #include "../../Eigen/src/Core/util/DisableStupidWarnings.h" 15 | 16 | namespace Eigen { 17 | 18 | /** 19 | * \defgroup KroneckerProduct_Module KroneckerProduct module 20 | * 21 | * This module contains an experimental Kronecker product implementation. 22 | * 23 | * \code 24 | * #include 25 | * \endcode 26 | */ 27 | 28 | } // namespace Eigen 29 | 30 | #include "src/KroneckerProduct/KroneckerTensorProduct.h" 31 | 32 | #include "../../Eigen/src/Core/util/ReenableStupidWarnings.h" 33 | 34 | #endif // EIGEN_KRONECKER_PRODUCT_MODULE_H 35 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/LevenbergMarquardt: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009 Thomas Capricelli 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_LEVENBERGMARQUARDT_MODULE 11 | #define EIGEN_LEVENBERGMARQUARDT_MODULE 12 | 13 | // #include 14 | 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | #include 21 | 22 | /** 23 | * \defgroup LevenbergMarquardt_Module Levenberg-Marquardt module 24 | * 25 | * \code 26 | * #include 27 | * \endcode 28 | * 29 | * 30 | */ 31 | 32 | #include "Eigen/SparseCore" 33 | #ifndef EIGEN_PARSED_BY_DOXYGEN 34 | 35 | #include "src/LevenbergMarquardt/LMqrsolv.h" 36 | #include "src/LevenbergMarquardt/LMcovar.h" 37 | #include "src/LevenbergMarquardt/LMpar.h" 38 | 39 | #endif 40 | 41 | #include "src/LevenbergMarquardt/LevenbergMarquardt.h" 42 | #include "src/LevenbergMarquardt/LMonestep.h" 43 | 44 | 45 | #endif // EIGEN_LEVENBERGMARQUARDT_MODULE 46 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/MoreVectorization: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // 5 | // This Source Code Form is subject to the terms of the Mozilla 6 | // Public License v. 2.0. If a copy of the MPL was not distributed 7 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 8 | 9 | #ifndef EIGEN_MOREVECTORIZATION_MODULE_H 10 | #define EIGEN_MOREVECTORIZATION_MODULE_H 11 | 12 | #include 13 | 14 | namespace Eigen { 15 | 16 | /** 17 | * \defgroup MoreVectorization More vectorization module 18 | */ 19 | 20 | } 21 | 22 | #include "src/MoreVectorization/MathFunctions.h" 23 | 24 | #endif // EIGEN_MOREVECTORIZATION_MODULE_H 25 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/SVD: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_SVD_MODULE_H 2 | #define EIGEN_SVD_MODULE_H 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | #include "../../Eigen/src/Core/util/DisableStupidWarnings.h" 9 | 10 | /** \defgroup SVD_Module SVD module 11 | * 12 | * 13 | * 14 | * This module provides SVD decomposition for matrices (both real and complex). 15 | * This decomposition is accessible via the following MatrixBase method: 16 | * - MatrixBase::jacobiSvd() 17 | * 18 | * \code 19 | * #include 20 | * \endcode 21 | */ 22 | 23 | #include "../../Eigen/src/misc/Solve.h" 24 | #include "../../Eigen/src/SVD/UpperBidiagonalization.h" 25 | #include "src/SVD/SVDBase.h" 26 | #include "src/SVD/JacobiSVD.h" 27 | #include "src/SVD/BDCSVD.h" 28 | #if defined(EIGEN_USE_LAPACKE) && !defined(EIGEN_USE_LAPACKE_STRICT) 29 | #include "../../Eigen/src/SVD/JacobiSVD_MKL.h" 30 | #endif 31 | 32 | #ifdef EIGEN2_SUPPORT 33 | #include "../../Eigen/src/Eigen2Support/SVD.h" 34 | #endif 35 | 36 | #include "../../Eigen/src/Core/util/ReenableStupidWarnings.h" 37 | 38 | #endif // EIGEN_SVD_MODULE_H 39 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 40 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/Skyline: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // 5 | // This Source Code Form is subject to the terms of the Mozilla 6 | // Public License v. 2.0. If a copy of the MPL was not distributed 7 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 8 | 9 | #ifndef EIGEN_SKYLINE_MODULE_H 10 | #define EIGEN_SKYLINE_MODULE_H 11 | 12 | 13 | #include "Eigen/Core" 14 | 15 | #include "Eigen/src/Core/util/DisableStupidWarnings.h" 16 | 17 | #include 18 | #include 19 | #include 20 | #include 21 | 22 | /** 23 | * \defgroup Skyline_Module Skyline module 24 | * 25 | * 26 | * 27 | * 28 | */ 29 | 30 | #include "src/Skyline/SkylineUtil.h" 31 | #include "src/Skyline/SkylineMatrixBase.h" 32 | #include "src/Skyline/SkylineStorage.h" 33 | #include "src/Skyline/SkylineMatrix.h" 34 | #include "src/Skyline/SkylineInplaceLU.h" 35 | #include "src/Skyline/SkylineProduct.h" 36 | 37 | #include "Eigen/src/Core/util/ReenableStupidWarnings.h" 38 | 39 | #endif // EIGEN_SKYLINE_MODULE_H 40 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/Splines: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 20010-2011 Hauke Heibel 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_SPLINES_MODULE_H 11 | #define EIGEN_SPLINES_MODULE_H 12 | 13 | namespace Eigen 14 | { 15 | /** 16 | * \defgroup Splines_Module Spline and spline fitting module 17 | * 18 | * This module provides a simple multi-dimensional spline class while 19 | * offering most basic functionality to fit a spline to point sets. 20 | * 21 | * \code 22 | * #include 23 | * \endcode 24 | */ 25 | } 26 | 27 | #include "src/Splines/SplineFwd.h" 28 | #include "src/Splines/Spline.h" 29 | #include "src/Splines/SplineFitting.h" 30 | 31 | #endif // EIGEN_SPLINES_MODULE_H 32 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/src/AutoDiff/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_AutoDiff_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_AutoDiff_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/AutoDiff COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/src/BVH/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_BVH_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_BVH_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/BVH COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/src/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | ADD_SUBDIRECTORY(AutoDiff) 2 | ADD_SUBDIRECTORY(BVH) 3 | ADD_SUBDIRECTORY(Eigenvalues) 4 | ADD_SUBDIRECTORY(FFT) 5 | ADD_SUBDIRECTORY(IterativeSolvers) 6 | ADD_SUBDIRECTORY(KroneckerProduct) 7 | ADD_SUBDIRECTORY(LevenbergMarquardt) 8 | ADD_SUBDIRECTORY(MatrixFunctions) 9 | ADD_SUBDIRECTORY(MoreVectorization) 10 | ADD_SUBDIRECTORY(NonLinearOptimization) 11 | ADD_SUBDIRECTORY(NumericalDiff) 12 | ADD_SUBDIRECTORY(Polynomials) 13 | ADD_SUBDIRECTORY(Skyline) 14 | ADD_SUBDIRECTORY(SparseExtra) 15 | ADD_SUBDIRECTORY(Splines) 16 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/src/Eigenvalues/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Eigenvalues_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Eigenvalues_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/Eigenvalues COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/src/FFT/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_FFT_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_FFT_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/FFT COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/src/IterativeSolvers/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_IterativeSolvers_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_IterativeSolvers_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/IterativeSolvers COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/src/KroneckerProduct/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_KroneckerProduct_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_KroneckerProduct_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/KroneckerProduct COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/src/LevenbergMarquardt/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_LevenbergMarquardt_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_LevenbergMarquardt_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/LevenbergMarquardt COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/src/MatrixFunctions/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_MatrixFunctions_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_MatrixFunctions_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/MatrixFunctions COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/src/MoreVectorization/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_MoreVectorization_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_MoreVectorization_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/MoreVectorization COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/src/NonLinearOptimization/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_NonLinearOptimization_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_NonLinearOptimization_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/NonLinearOptimization COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/src/NonLinearOptimization/r1mpyq.h: -------------------------------------------------------------------------------- 1 | namespace Eigen { 2 | 3 | namespace internal { 4 | 5 | // TODO : move this to GivensQR once there's such a thing in Eigen 6 | 7 | template 8 | void r1mpyq(DenseIndex m, DenseIndex n, Scalar *a, const std::vector > &v_givens, const std::vector > &w_givens) 9 | { 10 | typedef DenseIndex Index; 11 | 12 | /* apply the first set of givens rotations to a. */ 13 | for (Index j = n-2; j>=0; --j) 14 | for (Index i = 0; i 6 | void rwupdt( 7 | Matrix< Scalar, Dynamic, Dynamic > &r, 8 | const Matrix< Scalar, Dynamic, 1> &w, 9 | Matrix< Scalar, Dynamic, 1> &b, 10 | Scalar alpha) 11 | { 12 | typedef DenseIndex Index; 13 | 14 | const Index n = r.cols(); 15 | eigen_assert(r.rows()>=n); 16 | std::vector > givens(n); 17 | 18 | /* Local variables */ 19 | Scalar temp, rowj; 20 | 21 | /* Function Body */ 22 | for (Index j = 0; j < n; ++j) { 23 | rowj = w[j]; 24 | 25 | /* apply the previous transformations to */ 26 | /* r(i,j), i=0,1,...,j-1, and to w(j). */ 27 | for (Index i = 0; i < j; ++i) { 28 | temp = givens[i].c() * r(i,j) + givens[i].s() * rowj; 29 | rowj = -givens[i].s() * r(i,j) + givens[i].c() * rowj; 30 | r(i,j) = temp; 31 | } 32 | 33 | /* determine a givens rotation which eliminates w(j). */ 34 | givens[j].makeGivens(-r(j,j), rowj); 35 | 36 | if (rowj == 0.) 37 | continue; // givens[j] is identity 38 | 39 | /* apply the current transformation to r(j,j), b(j), and alpha. */ 40 | r(j,j) = givens[j].c() * r(j,j) + givens[j].s() * rowj; 41 | temp = givens[j].c() * b[j] + givens[j].s() * alpha; 42 | alpha = -givens[j].s() * b[j] + givens[j].c() * alpha; 43 | b[j] = temp; 44 | } 45 | } 46 | 47 | } // end namespace internal 48 | 49 | } // end namespace Eigen 50 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/src/NumericalDiff/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_NumericalDiff_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_NumericalDiff_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/NumericalDiff COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/src/Polynomials/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Polynomials_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Polynomials_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/Polynomials COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/src/SVD/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SVD_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SVD_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}unsupported/Eigen/src/SVD COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/src/SVD/doneInBDCSVD.txt: -------------------------------------------------------------------------------- 1 | This unsupported package is about a divide and conquer algorithm to compute SVD. 2 | 3 | The implementation follows as closely as possible the following reference paper : 4 | http://www.cs.yale.edu/publications/techreports/tr933.pdf 5 | 6 | The code documentation uses the same names for variables as the reference paper. The code, deflation included, is 7 | working but there are a few things that could be optimised as explained in the TODOBdsvd. 8 | 9 | In the code comments were put at the line where would be the third step of the algorithm so one could simply add the call 10 | of a function doing the last part of the algorithm and that would not require any knowledge of the part we implemented. 11 | 12 | In the TODOBdcsvd we explain what is the main difficulty of the last part and suggest a reference paper to help solve it. 13 | 14 | The implemented has trouble with fixed size matrices. 15 | 16 | In the actual implementation, it returns matrices of zero when ask to do a svd on an int matrix. 17 | 18 | 19 | Paper for the third part: 20 | http://www.stat.uchicago.edu/~lekheng/courses/302/classics/greengard-rokhlin.pdf 21 | 22 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/src/Skyline/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Skyline_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Skyline_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/Skyline COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/src/SparseExtra/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SparseExtra_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SparseExtra_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/SparseExtra COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/Eigen/src/Splines/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Splines_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Splines_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/Splines COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/doc/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set_directory_properties(PROPERTIES EXCLUDE_FROM_ALL TRUE) 2 | 3 | add_subdirectory(examples) 4 | add_subdirectory(snippets) 5 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/doc/Overview.dox: -------------------------------------------------------------------------------- 1 | namespace Eigen { 2 | 3 | /** \mainpage Eigen's unsupported modules 4 | 5 | This is the API documentation for Eigen's unsupported modules. 6 | 7 | These modules are contributions from various users. They are provided "as is", without any support. 8 | 9 | Click on the \e Modules tab at the top of this page to get a list of all unsupported modules. 10 | 11 | Don't miss the official Eigen documentation. 12 | 13 | */ 14 | 15 | /* 16 | 17 | \defgroup Unsupported_modules Unsupported modules 18 | 19 | The unsupported modules are contributions from various users. They are 20 | provided "as is", without any support. Nevertheless, some of them are 21 | subject to be included in Eigen in the future. 22 | 23 | */ 24 | 25 | } 26 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/doc/examples/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB examples_SRCS "*.cpp") 2 | 3 | ADD_CUSTOM_TARGET(unsupported_examples) 4 | 5 | INCLUDE_DIRECTORIES(../../../unsupported ../../../unsupported/test) 6 | 7 | FOREACH(example_src ${examples_SRCS}) 8 | GET_FILENAME_COMPONENT(example ${example_src} NAME_WE) 9 | ADD_EXECUTABLE(example_${example} ${example_src}) 10 | if(EIGEN_STANDARD_LIBRARIES_TO_LINK_TO) 11 | target_link_libraries(example_${example} ${EIGEN_STANDARD_LIBRARIES_TO_LINK_TO}) 12 | endif() 13 | ADD_CUSTOM_COMMAND( 14 | TARGET example_${example} 15 | POST_BUILD 16 | COMMAND example_${example} 17 | ARGS >${CMAKE_CURRENT_BINARY_DIR}/${example}.out 18 | ) 19 | ADD_DEPENDENCIES(unsupported_examples example_${example}) 20 | ENDFOREACH(example_src) 21 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/doc/examples/MatrixExponential.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace Eigen; 5 | 6 | int main() 7 | { 8 | const double pi = std::acos(-1.0); 9 | 10 | MatrixXd A(3,3); 11 | A << 0, -pi/4, 0, 12 | pi/4, 0, 0, 13 | 0, 0, 0; 14 | std::cout << "The matrix A is:\n" << A << "\n\n"; 15 | std::cout << "The matrix exponential of A is:\n" << A.exp() << "\n\n"; 16 | } 17 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/doc/examples/MatrixFunction.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace Eigen; 5 | 6 | std::complex expfn(std::complex x, int) 7 | { 8 | return std::exp(x); 9 | } 10 | 11 | int main() 12 | { 13 | const double pi = std::acos(-1.0); 14 | 15 | MatrixXd A(3,3); 16 | A << 0, -pi/4, 0, 17 | pi/4, 0, 0, 18 | 0, 0, 0; 19 | 20 | std::cout << "The matrix A is:\n" << A << "\n\n"; 21 | std::cout << "The matrix exponential of A is:\n" 22 | << A.matrixFunction(expfn) << "\n\n"; 23 | } 24 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/doc/examples/MatrixLogarithm.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace Eigen; 5 | 6 | int main() 7 | { 8 | using std::sqrt; 9 | MatrixXd A(3,3); 10 | A << 0.5*sqrt(2), -0.5*sqrt(2), 0, 11 | 0.5*sqrt(2), 0.5*sqrt(2), 0, 12 | 0, 0, 1; 13 | std::cout << "The matrix A is:\n" << A << "\n\n"; 14 | std::cout << "The matrix logarithm of A is:\n" << A.log() << "\n"; 15 | } 16 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/doc/examples/MatrixPower.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace Eigen; 5 | 6 | int main() 7 | { 8 | const double pi = std::acos(-1.0); 9 | Matrix3d A; 10 | A << cos(1), -sin(1), 0, 11 | sin(1), cos(1), 0, 12 | 0 , 0 , 1; 13 | std::cout << "The matrix A is:\n" << A << "\n\n" 14 | "The matrix power A^(pi/4) is:\n" << A.pow(pi/4) << std::endl; 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/doc/examples/MatrixPower_optimal.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace Eigen; 5 | 6 | int main() 7 | { 8 | Matrix4cd A = Matrix4cd::Random(); 9 | MatrixPower Apow(A); 10 | 11 | std::cout << "The matrix A is:\n" << A << "\n\n" 12 | "A^3.1 is:\n" << Apow(3.1) << "\n\n" 13 | "A^3.3 is:\n" << Apow(3.3) << "\n\n" 14 | "A^3.7 is:\n" << Apow(3.7) << "\n\n" 15 | "A^3.9 is:\n" << Apow(3.9) << std::endl; 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/doc/examples/MatrixSine.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace Eigen; 5 | 6 | int main() 7 | { 8 | MatrixXd A = MatrixXd::Random(3,3); 9 | std::cout << "A = \n" << A << "\n\n"; 10 | 11 | MatrixXd sinA = A.sin(); 12 | std::cout << "sin(A) = \n" << sinA << "\n\n"; 13 | 14 | MatrixXd cosA = A.cos(); 15 | std::cout << "cos(A) = \n" << cosA << "\n\n"; 16 | 17 | // The matrix functions satisfy sin^2(A) + cos^2(A) = I, 18 | // like the scalar functions. 19 | std::cout << "sin^2(A) + cos^2(A) = \n" << sinA*sinA + cosA*cosA << "\n\n"; 20 | } 21 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/doc/examples/MatrixSinh.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace Eigen; 5 | 6 | int main() 7 | { 8 | MatrixXf A = MatrixXf::Random(3,3); 9 | std::cout << "A = \n" << A << "\n\n"; 10 | 11 | MatrixXf sinhA = A.sinh(); 12 | std::cout << "sinh(A) = \n" << sinhA << "\n\n"; 13 | 14 | MatrixXf coshA = A.cosh(); 15 | std::cout << "cosh(A) = \n" << coshA << "\n\n"; 16 | 17 | // The matrix functions satisfy cosh^2(A) - sinh^2(A) = I, 18 | // like the scalar functions. 19 | std::cout << "cosh^2(A) - sinh^2(A) = \n" << coshA*coshA - sinhA*sinhA << "\n\n"; 20 | } 21 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/doc/examples/MatrixSquareRoot.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace Eigen; 5 | 6 | int main() 7 | { 8 | const double pi = std::acos(-1.0); 9 | 10 | MatrixXd A(2,2); 11 | A << cos(pi/3), -sin(pi/3), 12 | sin(pi/3), cos(pi/3); 13 | std::cout << "The matrix A is:\n" << A << "\n\n"; 14 | std::cout << "The matrix square root of A is:\n" << A.sqrt() << "\n\n"; 15 | std::cout << "The square of the last matrix is:\n" << A.sqrt() * A.sqrt() << "\n"; 16 | } 17 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/doc/examples/PolynomialUtils1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace Eigen; 5 | using namespace std; 6 | 7 | int main() 8 | { 9 | Vector4d roots = Vector4d::Random(); 10 | cout << "Roots: " << roots.transpose() << endl; 11 | Eigen::Matrix polynomial; 12 | roots_to_monicPolynomial( roots, polynomial ); 13 | cout << "Polynomial: "; 14 | for( int i=0; i<4; ++i ){ cout << polynomial[i] << ".x^" << i << "+ "; } 15 | cout << polynomial[4] << ".x^4" << endl; 16 | Vector4d evaluation; 17 | for( int i=0; i<4; ++i ){ 18 | evaluation[i] = poly_eval( polynomial, roots[i] ); } 19 | cout << "Evaluation of the polynomial at the roots: " << evaluation.transpose(); 20 | } 21 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/doc/snippets/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB snippets_SRCS "*.cpp") 2 | 3 | ADD_CUSTOM_TARGET(unsupported_snippets) 4 | 5 | FOREACH(snippet_src ${snippets_SRCS}) 6 | GET_FILENAME_COMPONENT(snippet ${snippet_src} NAME_WE) 7 | SET(compile_snippet_target compile_${snippet}) 8 | SET(compile_snippet_src ${compile_snippet_target}.cpp) 9 | FILE(READ ${snippet_src} snippet_source_code) 10 | CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/doc/snippets/compile_snippet.cpp.in 11 | ${CMAKE_CURRENT_BINARY_DIR}/${compile_snippet_src}) 12 | ADD_EXECUTABLE(${compile_snippet_target} 13 | ${CMAKE_CURRENT_BINARY_DIR}/${compile_snippet_src}) 14 | if(EIGEN_STANDARD_LIBRARIES_TO_LINK_TO) 15 | target_link_libraries(${compile_snippet_target} ${EIGEN_STANDARD_LIBRARIES_TO_LINK_TO}) 16 | endif() 17 | ADD_CUSTOM_COMMAND( 18 | TARGET ${compile_snippet_target} 19 | POST_BUILD 20 | COMMAND ${compile_snippet_target} 21 | ARGS >${CMAKE_CURRENT_BINARY_DIR}/${snippet}.out 22 | ) 23 | ADD_DEPENDENCIES(unsupported_snippets ${compile_snippet_target}) 24 | set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${compile_snippet_src} 25 | PROPERTIES OBJECT_DEPENDS ${snippet_src}) 26 | ENDFOREACH(snippet_src) 27 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/test/FFT.cpp: -------------------------------------------------------------------------------- 1 | #define test_FFTW test_FFT 2 | #include "FFTW.cpp" 3 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/test/dgmres.cpp: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2011 Gael Guennebaud 5 | // Copyright (C) 2012 desire Nuentsa 13 | 14 | template void test_dgmres_T() 15 | { 16 | DGMRES, DiagonalPreconditioner > dgmres_colmajor_diag; 17 | DGMRES, IdentityPreconditioner > dgmres_colmajor_I; 18 | DGMRES, IncompleteLUT > dgmres_colmajor_ilut; 19 | //GMRES, SSORPreconditioner > dgmres_colmajor_ssor; 20 | 21 | CALL_SUBTEST( check_sparse_square_solving(dgmres_colmajor_diag) ); 22 | // CALL_SUBTEST( check_sparse_square_solving(dgmres_colmajor_I) ); 23 | CALL_SUBTEST( check_sparse_square_solving(dgmres_colmajor_ilut) ); 24 | //CALL_SUBTEST( check_sparse_square_solving(dgmres_colmajor_ssor) ); 25 | } 26 | 27 | void test_dgmres() 28 | { 29 | CALL_SUBTEST_1(test_dgmres_T()); 30 | CALL_SUBTEST_2(test_dgmres_T >()); 31 | } 32 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/test/gmres.cpp: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2011 Gael Guennebaud 5 | // Copyright (C) 2012 Kolja Brix 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | #include "../../test/sparse_solver.h" 12 | #include 13 | 14 | template void test_gmres_T() 15 | { 16 | GMRES, DiagonalPreconditioner > gmres_colmajor_diag; 17 | GMRES, IdentityPreconditioner > gmres_colmajor_I; 18 | GMRES, IncompleteLUT > gmres_colmajor_ilut; 19 | //GMRES, SSORPreconditioner > gmres_colmajor_ssor; 20 | 21 | CALL_SUBTEST( check_sparse_square_solving(gmres_colmajor_diag) ); 22 | // CALL_SUBTEST( check_sparse_square_solving(gmres_colmajor_I) ); 23 | CALL_SUBTEST( check_sparse_square_solving(gmres_colmajor_ilut) ); 24 | //CALL_SUBTEST( check_sparse_square_solving(gmres_colmajor_ssor) ); 25 | } 26 | 27 | void test_gmres() 28 | { 29 | CALL_SUBTEST_1(test_gmres_T()); 30 | CALL_SUBTEST_2(test_gmres_T >()); 31 | } 32 | -------------------------------------------------------------------------------- /ThirdParty/Eigen/unsupported/test/matrix_square_root.cpp: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2011 Jitse Niesen 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 | #include "matrix_functions.h" 11 | 12 | template 13 | void testMatrixSqrt(const MatrixType& m) 14 | { 15 | MatrixType A; 16 | generateTestMatrix::run(A, m.rows()); 17 | MatrixType sqrtA = A.sqrt(); 18 | VERIFY_IS_APPROX(sqrtA * sqrtA, A); 19 | } 20 | 21 | void test_matrix_square_root() 22 | { 23 | for (int i = 0; i < g_repeat; i++) { 24 | CALL_SUBTEST_1(testMatrixSqrt(Matrix3cf())); 25 | CALL_SUBTEST_2(testMatrixSqrt(MatrixXcd(12,12))); 26 | CALL_SUBTEST_3(testMatrixSqrt(Matrix4f())); 27 | CALL_SUBTEST_4(testMatrixSqrt(Matrix(9, 9))); 28 | CALL_SUBTEST_5(testMatrixSqrt(Matrix())); 29 | CALL_SUBTEST_5(testMatrixSqrt(Matrix,1,1>())); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/.gitignore: -------------------------------------------------------------------------------- 1 | lib 2 | /matlab/CEPPnP_Toolbox 3 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/.travis.yml: -------------------------------------------------------------------------------- 1 | 2 | language: cpp 3 | 4 | compiler: 5 | - clang 6 | - gcc 7 | 8 | before_install: 9 | - sudo apt-get update 10 | 11 | install: 12 | - sudo apt-get install -y build-essential cmake git python-dev libboost-python-dev python-numpy libeigen3-dev 13 | 14 | before_script: 15 | - mkdir build 16 | - cd build 17 | - cmake .. -DBUILD_TESTS=ON -DBUILD_PYTHON=ON 18 | 19 | script: 20 | - make -j2 21 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/Makefile.ros: -------------------------------------------------------------------------------- 1 | include $(shell rospack find mk)/cmake.mk -------------------------------------------------------------------------------- /ThirdParty/OpenGV/README.txt: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/cmake/CXX11.cmake: -------------------------------------------------------------------------------- 1 | if (NOT CMAKE_CXX_COMPILER_LOADED) 2 | message(FATAL_ERROR "CheckCXX11Features modules only works if language CXX is enabled") 3 | endif () 4 | 5 | # Determines whether or not the compiler supports C++11 6 | macro(check_for_cxx11_compiler _VAR) 7 | message(STATUS "Checking for C++11 compiler") 8 | set(${_VAR}) 9 | if((MSVC AND (MSVC10 OR MSVC11 OR MSVC12)) OR 10 | (CMAKE_COMPILER_IS_GNUCXX AND NOT ${CMAKE_CXX_COMPILER_VERSION} VERSION_LESS 4.6) OR 11 | (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND NOT ${CMAKE_CXX_COMPILER_VERSION} VERSION_LESS 3.1)) 12 | set(${_VAR} 1) 13 | message(STATUS "Checking for C++11 compiler - available") 14 | else() 15 | message(STATUS "Checking for C++11 compiler - unavailable") 16 | endif() 17 | endmacro() 18 | 19 | # Sets the appropriate flag to enable C++11 support 20 | macro(enable_cxx11) 21 | if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR CMAKE_COMPILER_IS_GNUCXX) 22 | include(CheckCXXCompilerFlag) 23 | check_cxx_compiler_flag(--std=c++11 SUPPORTS_STD_CXX11) 24 | check_cxx_compiler_flag(--std=c++0x SUPPORTS_STD_CXX01) 25 | if(SUPPORTS_STD_CXX11) 26 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --std=c++11") 27 | elseif(SUPPORTS_STD_CXX01) 28 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --std=c++0x") 29 | else() 30 | message(ERROR "Compiler does not support --std=c++11 or --std=c++0x.") 31 | endif() 32 | endif() 33 | endmacro() 34 | 35 | 36 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/05_contact.dox: -------------------------------------------------------------------------------- 1 | /** \page page_contact Contact 2 | * 3 | * For any questions or inquiries, please contact: 4 | * 5 | \verbatim 6 | kneip.laurent@gmail.com 7 | \endverbatim 8 | * 9 | */ 10 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/absolute_central.dia: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/absolute_central.dia -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/absolute_central.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/absolute_central.pdf -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/absolute_central.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/absolute_central.png -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/absolute_noncentral.dia: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/absolute_noncentral.dia -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/absolute_noncentral.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/absolute_noncentral.pdf -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/absolute_noncentral.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/absolute_noncentral.png -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/central.dia: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/central.dia -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/central.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/central.pdf -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/central.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/central.png -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/multi_viewpoint.dia: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/multi_viewpoint.dia -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/multi_viewpoint.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/multi_viewpoint.pdf -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/multi_viewpoint.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/multi_viewpoint.png -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/noncentral.dia: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/noncentral.dia -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/noncentral.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/noncentral.pdf -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/noncentral.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/noncentral.png -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/nonoverlapping.dia: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/nonoverlapping.dia -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/nonoverlapping.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/nonoverlapping.pdf -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/nonoverlapping.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/nonoverlapping.png -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/point_cloud.dia: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/point_cloud.dia -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/point_cloud.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/point_cloud.pdf -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/point_cloud.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/point_cloud.png -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/relative_central.dia: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/relative_central.dia -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/relative_central.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/relative_central.pdf -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/relative_central.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/relative_central.png -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/relative_noncentral.dia: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/relative_noncentral.dia -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/relative_noncentral.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/relative_noncentral.pdf -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/relative_noncentral.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/relative_noncentral.png -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/reprojectionError.dia: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/reprojectionError.dia -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/reprojectionError.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/reprojectionError.pdf -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/reprojectionError.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/reprojectionError.png -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/triangulation_central.dia: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/triangulation_central.dia -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/triangulation_central.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/triangulation_central.pdf -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/triangulation_central.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/triangulation_central.png -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/triangulation_noncentral.dia: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/triangulation_noncentral.dia -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/triangulation_noncentral.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/triangulation_noncentral.pdf -------------------------------------------------------------------------------- /ThirdParty/OpenGV/doc/addons/images/triangulation_noncentral.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/doc/addons/images/triangulation_noncentral.png -------------------------------------------------------------------------------- /ThirdParty/OpenGV/include/opengv/relative_pose/modules/sixpt_ventura/approx_relpose_generalized_fast_computeA.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef APPROX_RELPOSE_GENERALIZED_FAST_COMPUTEA_H 3 | #define APPROX_RELPOSE_GENERALIZED_FAST_COMPUTEA_H 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | namespace opengv 13 | { 14 | namespace relative_pose 15 | { 16 | namespace modules 17 | { 18 | namespace sixpt_ventura 19 | { 20 | Eigen::Matrix computeA( 21 | const Eigen::Matrix &w1, 22 | const Eigen::Matrix &w2, 23 | const Eigen::Matrix &w3, 24 | const Eigen::Matrix &w4, 25 | const Eigen::Matrix &w5, 26 | const Eigen::Matrix &w6 27 | ); 28 | 29 | } 30 | } 31 | } 32 | } 33 | #endif 34 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/manifest.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | opengv 5 | 6 | 7 | Laurent Kneip 8 | FreeBSD 9 | 10 | http://ros.org/wiki/opengv 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/matlab/compile_ogv_matlab_wrappers.m: -------------------------------------------------------------------------------- 1 | %% adjust paths to libs and includes if necessary 2 | 3 | mex opengv.cpp -IF:/Libraries/OpenGV_Pull/opengv/third_party/ ... 4 | -IF:/Libraries/OpenGV_Pull/opengv/include/ -LF:/Libraries/OpenGV_Pull/build/lib/Release/ ... 5 | -lopengv -lrandom_generators -------------------------------------------------------------------------------- /ThirdParty/OpenGV/matlab/helpers/addNoise.m: -------------------------------------------------------------------------------- 1 | function [v_noisy,v_noisy_norm,noiseX,noiseY] = addNoise(v_clean,focal_length,pixel_noise) 2 | 3 | %find good vector in normal plane based on good conditioning 4 | inPlaneVector1 = zeros(3,1); 5 | 6 | if v_clean(1,1) > v_clean(2,1) && v_clean(1,1) > v_clean(3,1) 7 | inPlaneVector1(2,1) = 1.0; 8 | inPlaneVector1(3,1) = 0.0; 9 | inPlaneVector1(1,1) = 1.0/v_clean(1,1) * (-v_clean(2,1)); 10 | else 11 | if v_clean(2,1) > v_clean(3,1) && v_clean(2,1) > v_clean(1,1) 12 | inPlaneVector1(3,1) = 1.0; 13 | inPlaneVector1(1,1) = 0.0; 14 | inPlaneVector1(2,1) = 1.0/v_clean(2,1) * (-v_clean(3,1)); 15 | else 16 | %v_clean(3,1) > v_clean(1,1) && v_clean(3,1) > v_clean(2,1) 17 | inPlaneVector1(1,1) = 1.0; 18 | inPlaneVector1(2,1) = 0.0; 19 | inPlaneVector1(3,1) = 1.0/v_clean(3,1) * (-v_clean(1,1)); 20 | end 21 | end 22 | 23 | %normalize the in-plane vector 24 | inPlaneVector1 = inPlaneVector1 / norm(inPlaneVector1); 25 | inPlaneVector2 = cross(v_clean,inPlaneVector1); 26 | 27 | noiseX = pixel_noise * (rand-0.5)*2.0;% / sqrt(2); 28 | noiseY = pixel_noise * (rand-0.5)*2.0;% / sqrt(2); 29 | 30 | v_noisy_un = focal_length * v_clean + noiseX * inPlaneVector1 + noiseY * inPlaneVector2; 31 | 32 | v_noisy_norm = norm(v_noisy_un); 33 | v_noisy = v_noisy_un ./ v_noisy_norm; 34 | 35 | end -------------------------------------------------------------------------------- /ThirdParty/OpenGV/matlab/helpers/cayley2rot.m: -------------------------------------------------------------------------------- 1 | function R = cayley2rot(v) 2 | 3 | cayley0 = v(1); 4 | cayley1 = v(2); 5 | cayley2 = v(3); 6 | 7 | R = zeros(3,3); 8 | scale = 1+cayley0^2+cayley1^2+cayley2^2; 9 | 10 | R(1,1) = 1+cayley0^2-cayley1^2-cayley2^2; 11 | R(1,2) = 2*(cayley0*cayley1-cayley2); 12 | R(1,3) = 2*(cayley0*cayley2+cayley1); 13 | R(2,1) = 2*(cayley0*cayley1+cayley2); 14 | R(2,2) = 1-cayley0^2+cayley1^2-cayley2^2; 15 | R(2,3) = 2*(cayley1*cayley2-cayley0); 16 | R(3,1) = 2*(cayley0*cayley2-cayley1); 17 | R(3,2) = 2*(cayley1*cayley2+cayley0); 18 | R(3,3) = 1-cayley0^2-cayley1^2+cayley2^2; 19 | 20 | R = (1/scale) * R; -------------------------------------------------------------------------------- /ThirdParty/OpenGV/matlab/helpers/create2D3DExperimentCov1Cam.m: -------------------------------------------------------------------------------- 1 | function [points, v, cov, t, R ] = create2D3DExperimentCov1Cam(pt_number, noise, outlier_fraction) 2 | 3 | %% Generate random point-cloud 4 | minDepth = 4.0; 5 | maxDepth = 8.0; 6 | 7 | body_points = [xrand(1,pt_number,[-2 2]); xrand(1,pt_number,[-2 2]); xrand(1,pt_number,[minDepth maxDepth])]; 8 | t = mean(body_points,2); 9 | R = rodrigues(randn(3,1)); 10 | points = R\(body_points-repmat(t,1,pt_number)); 11 | 12 | %% Now create the correspondences by looping through the cameras 13 | 14 | focal_length = 800.0; 15 | K = [focal_length 0 0; 0 focal_length 0; 0 0 1]; 16 | cov = zeros(9,pt_number); 17 | 18 | % project poitns 19 | xx = [body_points(1,:)./body_points(3,:); body_points(2,:)./body_points(3,:)]*focal_length; 20 | std = rand(1,pt_number)*noise; 21 | noiseAdd = randn(2,pt_number).*[std;std]; 22 | xxn = xx+noiseAdd; 23 | homx = [xxn/focal_length; ones(1,size(xxn,2))]; 24 | v = normc(homx); 25 | for i=1:pt_number 26 | % covariance projection 27 | cov_proj = K\diag([std(i)^2 std(i)^2 0])/K'; 28 | J = (eye(3)-(v(1:3,i)*v(1:3,i)')/(v(1:3,i)'*v(1:3,i)))/norm(homx); 29 | Evv = J*cov_proj*J'; 30 | cov(:,i) = reshape(Evv,9,1); 31 | end 32 | %% copy over the position and orientation 33 | 34 | R = R'; 35 | t = -R*t; -------------------------------------------------------------------------------- /ThirdParty/OpenGV/matlab/helpers/evaluateRotationError.m: -------------------------------------------------------------------------------- 1 | function rotation_error = evaluateRotationError(R_gt,R) 2 | 3 | temp = size(size(R)); 4 | numberSolutions = 1; 5 | if temp(1,2) == 3 6 | temp2 = size(R); 7 | numberSolutions = temp2(1,3); 8 | end 9 | 10 | if numberSolutions == 1 11 | 12 | %rotation_error = norm(rodrigues(R_gt'*R)); 13 | rotation_error = norm( rodrigues(R_gt) - rodrigues(R) ); 14 | 15 | else 16 | 17 | rotation_errors = zeros(1,numberSolutions); 18 | 19 | index = 0; 20 | 21 | for i=1:numberSolutions 22 | 23 | %Check if there is any Nan 24 | if ~isnan(R(1,1,i)) 25 | index = index + 1; 26 | %rotation_errors(1,index) = norm(rodrigues(R_gt'*R(:,:,i))); 27 | rotation_errors(1,index) = norm( rodrigues(R_gt) - rodrigues(R(:,:,i)) ); 28 | end 29 | end 30 | 31 | %find the smallest error (we are the most "nice" to algorithms returning multiple solutions, 32 | %and do the disambiguation by hand) 33 | [~,minIndex] = min(rotation_errors(1,1:index)); 34 | rotation_error = rotation_errors(1,minIndex); 35 | 36 | end 37 | 38 | end 39 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/matlab/helpers/evaluateTransformationError.m: -------------------------------------------------------------------------------- 1 | function [position_error,rotation_error] = evaluateTransformationError(T_gt,T) 2 | 3 | temp = size(size(T)); 4 | numberSolutions = 1; 5 | if temp(1,2) == 3 6 | temp2 = size(T); 7 | numberSolutions = temp2(1,3); 8 | end 9 | 10 | if numberSolutions == 1 11 | 12 | position_error = norm(T_gt(:,4)-T(:,4)); 13 | rotation_error = norm(rodrigues(T_gt(:,1:3)'*T(:,1:3))); 14 | 15 | else 16 | 17 | position_errors = zeros(1,numberSolutions); 18 | rotation_errors = zeros(1,numberSolutions); 19 | 20 | index = 0; 21 | 22 | for i=1:numberSolutions 23 | 24 | %Check if there is any Nan 25 | if ~isnan(T(1,1,i)) 26 | index = index + 1; 27 | position_errors(1,index) = norm(T_gt(:,4)-T(:,4,i)); 28 | rotation_errors(1,index) = norm(rodrigues(T_gt(:,1:3)'*T(:,1:3,i))); 29 | end 30 | end 31 | 32 | %find the smallest error (we are the most "nice" to algorithms returning multiple solutions, 33 | %and do the disambiguation by hand) 34 | [~,minIndex] = min(position_errors(1,1:index)); 35 | position_error = position_errors(1,minIndex); 36 | rotation_error = rotation_errors(1,minIndex); 37 | 38 | end 39 | 40 | end -------------------------------------------------------------------------------- /ThirdParty/OpenGV/matlab/helpers/generateBoundedR.m: -------------------------------------------------------------------------------- 1 | function R = generateBoundedR( bound ) 2 | rpy = bound*2.0*(rand(3,1)-repmat(0.5,3,1)); 3 | 4 | R1 = zeros(3,3); 5 | R1(1,1) = 1.0; 6 | R1(2,2) = cos(rpy(1,1)); 7 | R1(2,3) = -sin(rpy(1,1)); 8 | R1(3,2) = -R1(2,3); 9 | R1(3,3) = R1(2,2); 10 | 11 | R2 = zeros(3,3); 12 | R2(1,1) = cos(rpy(2,1)); 13 | R2(1,3) = sin(rpy(2,1)); 14 | R2(2,2) = 1.0; 15 | R2(3,1) = -R2(1,3); 16 | R2(3,3) = R2(1,1); 17 | 18 | R3 = zeros(3,3); 19 | R3(1,1) = cos(rpy(3,1)); 20 | R3(1,2) = -sin(rpy(3,1)); 21 | R3(2,1) =-R3(1,2); 22 | R3(2,2) = R3(1,1); 23 | R3(3,3) = 1.0; 24 | 25 | R = R3 * R2 * R1; 26 | end -------------------------------------------------------------------------------- /ThirdParty/OpenGV/matlab/helpers/generateRandomR.m: -------------------------------------------------------------------------------- 1 | function R = generateRandomR() 2 | rpy = pi()*2.0*(rand(3,1)-repmat(0.5,3,1)); 3 | rpy(2,1) = 0.5*rpy(2,1); 4 | 5 | R1 = zeros(3,3); 6 | R1(1,1) = 1.0; 7 | R1(2,2) = cos(rpy(1,1)); 8 | R1(2,3) = -sin(rpy(1,1)); 9 | R1(3,2) = -R1(2,3); 10 | R1(3,3) = R1(2,2); 11 | 12 | R2 = zeros(3,3); 13 | R2(1,1) = cos(rpy(2,1)); 14 | R2(1,3) = sin(rpy(2,1)); 15 | R2(2,2) = 1.0; 16 | R2(3,1) = -R2(1,3); 17 | R2(3,3) = R2(1,1); 18 | 19 | R3 = zeros(3,3); 20 | R3(1,1) = cos(rpy(3,1)); 21 | R3(1,2) = -sin(rpy(3,1)); 22 | R3(2,1) =-R3(1,2); 23 | R3(2,2) = R3(1,1); 24 | R3(3,3) = 1.0; 25 | 26 | R = R3 * R2 * R1; 27 | end -------------------------------------------------------------------------------- /ThirdParty/OpenGV/matlab/helpers/perturb.m: -------------------------------------------------------------------------------- 1 | function [t_perturbed,R_perturbed] = perturb(t,R,amplitude) 2 | 3 | t_perturbed = t; 4 | r = rodrigues(R); 5 | 6 | for i=1:3 7 | t_perturbed(i,1) = t_perturbed(i,1) + (rand-0.5)*2.0*amplitude; 8 | r(i,1) = r(i,1) + (rand-0.5)*2.0*amplitude; 9 | end 10 | 11 | R_perturbed = rodrigues(r); 12 | end -------------------------------------------------------------------------------- /ThirdParty/OpenGV/matlab/helpers/rot2cayley.m: -------------------------------------------------------------------------------- 1 | function v = rot2cayley(R) 2 | 3 | C1 = R-eye(3); 4 | C2 = R+eye(3); 5 | C = C1 * inv(C2); 6 | 7 | v = zeros(3,1); 8 | v(1,1) = -C(2,3); 9 | v(2,1) = C(1,3); 10 | v(3,1) = -C(1,2); 11 | 12 | end -------------------------------------------------------------------------------- /ThirdParty/OpenGV/matlab/opengv.mexw64: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/matlab/opengv.mexw64 -------------------------------------------------------------------------------- /ThirdParty/OpenGV/matlab/ordinary3Dresults.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/OpenGV/matlab/ordinary3Dresults.mat -------------------------------------------------------------------------------- /ThirdParty/OpenGV/matlab/ransac_test.m: -------------------------------------------------------------------------------- 1 | %% Reset everything 2 | 3 | clear all; 4 | clc; 5 | close all; 6 | addpath('helpers'); 7 | 8 | % central case -> only one camera 9 | cam_number = 1; 10 | % let's only get 6 points, and generate new ones in each iteration 11 | pt_number = 100; 12 | % noise test, so no outliers 13 | outlier_fraction = 0.1; 14 | 15 | noise = 0.0; 16 | [points,v,t,R] = create2D3DExperiment(pt_number,cam_number,noise,outlier_fraction); 17 | [X, inliers] = opengv('p3p_kneip_ransac',points,v); -------------------------------------------------------------------------------- /ThirdParty/OpenGV/python/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | find_package(Boost COMPONENTS python REQUIRED) 3 | include_directories(${Boost_INCLUDE_DIRS}) 4 | 5 | set(Python_ADDITIONAL_VERSIONS "2.7") 6 | find_package(PythonLibs REQUIRED) 7 | include_directories(${PYTHON_INCLUDE_DIRS}) 8 | 9 | find_package(NumPy REQUIRED) 10 | include_directories(${NUMPY_INCLUDE_DIRS}) 11 | 12 | 13 | add_library( pyopengv SHARED pyopengv.cpp ) 14 | target_link_libraries(pyopengv opengv) 15 | 16 | 17 | set_target_properties(pyopengv PROPERTIES 18 | PREFIX "" 19 | SUFFIX ".so" 20 | ) 21 | if(APPLE) 22 | set_target_properties(pyopengv PROPERTIES 23 | LINK_FLAGS "-undefined dynamic_lookup" 24 | ) 25 | target_link_libraries(pyopengv "${Boost_LIBRARY_DIR}/libboost_python.a") 26 | else() 27 | target_link_libraries(pyopengv 28 | ${Boost_LIBRARIES} 29 | ${PYTHON_LIBRARIES} 30 | ) 31 | endif() 32 | 33 | # Find whether to install python libs in site-packages or dist-packages 34 | execute_process ( COMMAND 35 | python -c "import distutils.sysconfig; print 'dist-packages' if distutils.sysconfig.get_python_lib().endswith('dist-packages') else 'site-packages'" 36 | OUTPUT_VARIABLE PYTHON_SITE_PACKAGES OUTPUT_STRIP_TRAILING_WHITESPACE) 37 | 38 | set(PYTHON_INSTALL_DIR 39 | "${CMAKE_INSTALL_PREFIX}/lib/python2.7/${PYTHON_SITE_PACKAGES}" 40 | CACHE PATH "Path where to install pyopengv") 41 | 42 | install(TARGETS pyopengv DESTINATION "${PYTHON_INSTALL_DIR}") 43 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/Array: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_ARRAY_MODULE_H 2 | #define EIGEN_ARRAY_MODULE_H 3 | 4 | // include Core first to handle Eigen2 support macros 5 | #include "Core" 6 | 7 | #ifndef EIGEN2_SUPPORT 8 | #error The Eigen/Array header does no longer exist in Eigen3. All that functionality has moved to Eigen/Core. 9 | #endif 10 | 11 | #endif // EIGEN_ARRAY_MODULE_H 12 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include(RegexUtils) 2 | test_escape_string_as_regex() 3 | 4 | file(GLOB Eigen_directory_files "*") 5 | 6 | escape_string_as_regex(ESCAPED_CMAKE_CURRENT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}") 7 | 8 | foreach(f ${Eigen_directory_files}) 9 | if(NOT f MATCHES "\\.txt" AND NOT f MATCHES "${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/[.].+" AND NOT f MATCHES "${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/src") 10 | list(APPEND Eigen_directory_files_to_install ${f}) 11 | endif() 12 | endforeach(f ${Eigen_directory_files}) 13 | 14 | install(FILES 15 | ${Eigen_directory_files_to_install} 16 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen COMPONENT Devel 17 | ) 18 | 19 | add_subdirectory(src) 20 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/Cholesky: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_CHOLESKY_MODULE_H 2 | #define EIGEN_CHOLESKY_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** \defgroup Cholesky_Module Cholesky module 9 | * 10 | * 11 | * 12 | * This module provides two variants of the Cholesky decomposition for selfadjoint (hermitian) matrices. 13 | * Those decompositions are accessible via the following MatrixBase methods: 14 | * - MatrixBase::llt(), 15 | * - MatrixBase::ldlt() 16 | * 17 | * \code 18 | * #include 19 | * \endcode 20 | */ 21 | 22 | #include "src/misc/Solve.h" 23 | #include "src/Cholesky/LLT.h" 24 | #include "src/Cholesky/LDLT.h" 25 | #ifdef EIGEN_USE_LAPACKE 26 | #include "src/Cholesky/LLT_MKL.h" 27 | #endif 28 | 29 | #include "src/Core/util/ReenableStupidWarnings.h" 30 | 31 | #endif // EIGEN_CHOLESKY_MODULE_H 32 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 33 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/Dense: -------------------------------------------------------------------------------- 1 | #include "Core" 2 | #include "LU" 3 | #include "Cholesky" 4 | #include "QR" 5 | #include "SVD" 6 | #include "Geometry" 7 | #include "Eigenvalues" 8 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/Eigen: -------------------------------------------------------------------------------- 1 | #include "Dense" 2 | //#include "Sparse" 3 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/Eigenvalues: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_EIGENVALUES_MODULE_H 2 | #define EIGEN_EIGENVALUES_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include "Cholesky" 9 | #include "Jacobi" 10 | #include "Householder" 11 | #include "LU" 12 | #include "Geometry" 13 | 14 | /** \defgroup Eigenvalues_Module Eigenvalues module 15 | * 16 | * 17 | * 18 | * This module mainly provides various eigenvalue solvers. 19 | * This module also provides some MatrixBase methods, including: 20 | * - MatrixBase::eigenvalues(), 21 | * - MatrixBase::operatorNorm() 22 | * 23 | * \code 24 | * #include 25 | * \endcode 26 | */ 27 | 28 | #include "src/Eigenvalues/Tridiagonalization.h" 29 | #include "src/Eigenvalues/RealSchur.h" 30 | #include "src/Eigenvalues/EigenSolver.h" 31 | #include "src/Eigenvalues/SelfAdjointEigenSolver.h" 32 | #include "src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h" 33 | #include "src/Eigenvalues/HessenbergDecomposition.h" 34 | #include "src/Eigenvalues/ComplexSchur.h" 35 | #include "src/Eigenvalues/ComplexEigenSolver.h" 36 | #include "src/Eigenvalues/RealQZ.h" 37 | #include "src/Eigenvalues/GeneralizedEigenSolver.h" 38 | #include "src/Eigenvalues/MatrixBaseEigenvalues.h" 39 | #ifdef EIGEN_USE_LAPACKE 40 | #include "src/Eigenvalues/RealSchur_MKL.h" 41 | #include "src/Eigenvalues/ComplexSchur_MKL.h" 42 | #include "src/Eigenvalues/SelfAdjointEigenSolver_MKL.h" 43 | #endif 44 | 45 | #include "src/Core/util/ReenableStupidWarnings.h" 46 | 47 | #endif // EIGEN_EIGENVALUES_MODULE_H 48 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 49 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/Householder: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_HOUSEHOLDER_MODULE_H 2 | #define EIGEN_HOUSEHOLDER_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** \defgroup Householder_Module Householder module 9 | * This module provides Householder transformations. 10 | * 11 | * \code 12 | * #include 13 | * \endcode 14 | */ 15 | 16 | #include "src/Householder/Householder.h" 17 | #include "src/Householder/HouseholderSequence.h" 18 | #include "src/Householder/BlockHouseholder.h" 19 | 20 | #include "src/Core/util/ReenableStupidWarnings.h" 21 | 22 | #endif // EIGEN_HOUSEHOLDER_MODULE_H 23 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 24 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/Jacobi: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_JACOBI_MODULE_H 2 | #define EIGEN_JACOBI_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** \defgroup Jacobi_Module Jacobi module 9 | * This module provides Jacobi and Givens rotations. 10 | * 11 | * \code 12 | * #include 13 | * \endcode 14 | * 15 | * In addition to listed classes, it defines the two following MatrixBase methods to apply a Jacobi or Givens rotation: 16 | * - MatrixBase::applyOnTheLeft() 17 | * - MatrixBase::applyOnTheRight(). 18 | */ 19 | 20 | #include "src/Jacobi/Jacobi.h" 21 | 22 | #include "src/Core/util/ReenableStupidWarnings.h" 23 | 24 | #endif // EIGEN_JACOBI_MODULE_H 25 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 26 | 27 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/LU: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_LU_MODULE_H 2 | #define EIGEN_LU_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** \defgroup LU_Module LU module 9 | * This module includes %LU decomposition and related notions such as matrix inversion and determinant. 10 | * This module defines the following MatrixBase methods: 11 | * - MatrixBase::inverse() 12 | * - MatrixBase::determinant() 13 | * 14 | * \code 15 | * #include 16 | * \endcode 17 | */ 18 | 19 | #include "src/misc/Solve.h" 20 | #include "src/misc/Kernel.h" 21 | #include "src/misc/Image.h" 22 | #include "src/LU/FullPivLU.h" 23 | #include "src/LU/PartialPivLU.h" 24 | #ifdef EIGEN_USE_LAPACKE 25 | #include "src/LU/PartialPivLU_MKL.h" 26 | #endif 27 | #include "src/LU/Determinant.h" 28 | #include "src/LU/Inverse.h" 29 | 30 | #if defined EIGEN_VECTORIZE_SSE 31 | #include "src/LU/arch/Inverse_SSE.h" 32 | #endif 33 | 34 | #ifdef EIGEN2_SUPPORT 35 | #include "src/Eigen2Support/LU.h" 36 | #endif 37 | 38 | #include "src/Core/util/ReenableStupidWarnings.h" 39 | 40 | #endif // EIGEN_LU_MODULE_H 41 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 42 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/LeastSquares: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_REGRESSION_MODULE_H 2 | #define EIGEN_REGRESSION_MODULE_H 3 | 4 | #ifndef EIGEN2_SUPPORT 5 | #error LeastSquares is only available in Eigen2 support mode (define EIGEN2_SUPPORT) 6 | #endif 7 | 8 | // exclude from normal eigen3-only documentation 9 | #ifdef EIGEN2_SUPPORT 10 | 11 | #include "Core" 12 | 13 | #include "src/Core/util/DisableStupidWarnings.h" 14 | 15 | #include "Eigenvalues" 16 | #include "Geometry" 17 | 18 | /** \defgroup LeastSquares_Module LeastSquares module 19 | * This module provides linear regression and related features. 20 | * 21 | * \code 22 | * #include 23 | * \endcode 24 | */ 25 | 26 | #include "src/Eigen2Support/LeastSquares.h" 27 | 28 | #include "src/Core/util/ReenableStupidWarnings.h" 29 | 30 | #endif // EIGEN2_SUPPORT 31 | 32 | #endif // EIGEN_REGRESSION_MODULE_H 33 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/MetisSupport: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_METISSUPPORT_MODULE_H 2 | #define EIGEN_METISSUPPORT_MODULE_H 3 | 4 | #include "SparseCore" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | extern "C" { 9 | #include 10 | } 11 | 12 | 13 | /** \ingroup Support_modules 14 | * \defgroup MetisSupport_Module MetisSupport module 15 | * 16 | * \code 17 | * #include 18 | * \endcode 19 | * This module defines an interface to the METIS reordering package (http://glaros.dtc.umn.edu/gkhome/views/metis). 20 | * It can be used just as any other built-in method as explained in \link OrderingMethods_Module here. \endlink 21 | */ 22 | 23 | 24 | #include "src/MetisSupport/MetisSupport.h" 25 | 26 | #include "src/Core/util/ReenableStupidWarnings.h" 27 | 28 | #endif // EIGEN_METISSUPPORT_MODULE_H 29 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/PardisoSupport: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_PARDISOSUPPORT_MODULE_H 2 | #define EIGEN_PARDISOSUPPORT_MODULE_H 3 | 4 | #include "SparseCore" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include 9 | 10 | #include 11 | 12 | /** \ingroup Support_modules 13 | * \defgroup PardisoSupport_Module PardisoSupport module 14 | * 15 | * This module brings support for the Intel(R) MKL PARDISO direct sparse solvers. 16 | * 17 | * \code 18 | * #include 19 | * \endcode 20 | * 21 | * In order to use this module, the MKL headers must be accessible from the include paths, and your binary must be linked to the MKL library and its dependencies. 22 | * See this \ref TopicUsingIntelMKL "page" for more information on MKL-Eigen integration. 23 | * 24 | */ 25 | 26 | #include "src/PardisoSupport/PardisoSupport.h" 27 | 28 | #include "src/Core/util/ReenableStupidWarnings.h" 29 | 30 | #endif // EIGEN_PARDISOSUPPORT_MODULE_H 31 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/QR: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_QR_MODULE_H 2 | #define EIGEN_QR_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include "Cholesky" 9 | #include "Jacobi" 10 | #include "Householder" 11 | 12 | /** \defgroup QR_Module QR module 13 | * 14 | * 15 | * 16 | * This module provides various QR decompositions 17 | * This module also provides some MatrixBase methods, including: 18 | * - MatrixBase::qr(), 19 | * 20 | * \code 21 | * #include 22 | * \endcode 23 | */ 24 | 25 | #include "src/misc/Solve.h" 26 | #include "src/QR/HouseholderQR.h" 27 | #include "src/QR/FullPivHouseholderQR.h" 28 | #include "src/QR/ColPivHouseholderQR.h" 29 | #ifdef EIGEN_USE_LAPACKE 30 | #include "src/QR/HouseholderQR_MKL.h" 31 | #include "src/QR/ColPivHouseholderQR_MKL.h" 32 | #endif 33 | 34 | #ifdef EIGEN2_SUPPORT 35 | #include "src/Eigen2Support/QR.h" 36 | #endif 37 | 38 | #include "src/Core/util/ReenableStupidWarnings.h" 39 | 40 | #ifdef EIGEN2_SUPPORT 41 | #include "Eigenvalues" 42 | #endif 43 | 44 | #endif // EIGEN_QR_MODULE_H 45 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 46 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/QtAlignedMalloc: -------------------------------------------------------------------------------- 1 | 2 | #ifndef EIGEN_QTMALLOC_MODULE_H 3 | #define EIGEN_QTMALLOC_MODULE_H 4 | 5 | #include "Core" 6 | 7 | #if (!EIGEN_MALLOC_ALREADY_ALIGNED) 8 | 9 | #include "src/Core/util/DisableStupidWarnings.h" 10 | 11 | void *qMalloc(size_t size) 12 | { 13 | return Eigen::internal::aligned_malloc(size); 14 | } 15 | 16 | void qFree(void *ptr) 17 | { 18 | Eigen::internal::aligned_free(ptr); 19 | } 20 | 21 | void *qRealloc(void *ptr, size_t size) 22 | { 23 | void* newPtr = Eigen::internal::aligned_malloc(size); 24 | memcpy(newPtr, ptr, size); 25 | Eigen::internal::aligned_free(ptr); 26 | return newPtr; 27 | } 28 | 29 | #include "src/Core/util/ReenableStupidWarnings.h" 30 | 31 | #endif 32 | 33 | #endif // EIGEN_QTMALLOC_MODULE_H 34 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 35 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/SPQRSupport: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_SPQRSUPPORT_MODULE_H 2 | #define EIGEN_SPQRSUPPORT_MODULE_H 3 | 4 | #include "SparseCore" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include "SuiteSparseQR.hpp" 9 | 10 | /** \ingroup Support_modules 11 | * \defgroup SPQRSupport_Module SuiteSparseQR module 12 | * 13 | * This module provides an interface to the SPQR library, which is part of the suitesparse package. 14 | * 15 | * \code 16 | * #include 17 | * \endcode 18 | * 19 | * In order to use this module, the SPQR headers must be accessible from the include paths, and your binary must be linked to the SPQR library and its dependencies (Cholmod, AMD, COLAMD,...). 20 | * For a cmake based project, you can use our FindSPQR.cmake and FindCholmod.Cmake modules 21 | * 22 | */ 23 | 24 | #include "src/misc/Solve.h" 25 | #include "src/misc/SparseSolve.h" 26 | #include "src/CholmodSupport/CholmodSupport.h" 27 | #include "src/SPQRSupport/SuiteSparseQRSupport.h" 28 | 29 | #endif 30 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/SVD: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_SVD_MODULE_H 2 | #define EIGEN_SVD_MODULE_H 3 | 4 | #include "QR" 5 | #include "Householder" 6 | #include "Jacobi" 7 | 8 | #include "src/Core/util/DisableStupidWarnings.h" 9 | 10 | /** \defgroup SVD_Module SVD module 11 | * 12 | * 13 | * 14 | * This module provides SVD decomposition for matrices (both real and complex). 15 | * This decomposition is accessible via the following MatrixBase method: 16 | * - MatrixBase::jacobiSvd() 17 | * 18 | * \code 19 | * #include 20 | * \endcode 21 | */ 22 | 23 | #include "src/misc/Solve.h" 24 | #include "src/SVD/JacobiSVD.h" 25 | #if defined(EIGEN_USE_LAPACKE) && !defined(EIGEN_USE_LAPACKE_STRICT) 26 | #include "src/SVD/JacobiSVD_MKL.h" 27 | #endif 28 | #include "src/SVD/UpperBidiagonalization.h" 29 | 30 | #ifdef EIGEN2_SUPPORT 31 | #include "src/Eigen2Support/SVD.h" 32 | #endif 33 | 34 | #include "src/Core/util/ReenableStupidWarnings.h" 35 | 36 | #endif // EIGEN_SVD_MODULE_H 37 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 38 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/Sparse: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_SPARSE_MODULE_H 2 | #define EIGEN_SPARSE_MODULE_H 3 | 4 | /** \defgroup Sparse_Module Sparse meta-module 5 | * 6 | * Meta-module including all related modules: 7 | * - \ref SparseCore_Module 8 | * - \ref OrderingMethods_Module 9 | * - \ref SparseCholesky_Module 10 | * - \ref SparseLU_Module 11 | * - \ref SparseQR_Module 12 | * - \ref IterativeLinearSolvers_Module 13 | * 14 | * \code 15 | * #include 16 | * \endcode 17 | */ 18 | 19 | #include "SparseCore" 20 | #include "OrderingMethods" 21 | #include "SparseCholesky" 22 | #include "SparseLU" 23 | #include "SparseQR" 24 | #include "IterativeLinearSolvers" 25 | 26 | #endif // EIGEN_SPARSE_MODULE_H 27 | 28 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/SparseQR: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_SPARSEQR_MODULE_H 2 | #define EIGEN_SPARSEQR_MODULE_H 3 | 4 | #include "SparseCore" 5 | #include "OrderingMethods" 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** \defgroup SparseQR_Module SparseQR module 9 | * \brief Provides QR decomposition for sparse matrices 10 | * 11 | * This module provides a simplicial version of the left-looking Sparse QR decomposition. 12 | * The columns of the input matrix should be reordered to limit the fill-in during the 13 | * decomposition. Built-in methods (COLAMD, AMD) or external methods (METIS) can be used to this end. 14 | * See the \link OrderingMethods_Module OrderingMethods\endlink module for the list 15 | * of built-in and external ordering methods. 16 | * 17 | * \code 18 | * #include 19 | * \endcode 20 | * 21 | * 22 | */ 23 | 24 | #include "src/misc/Solve.h" 25 | #include "src/misc/SparseSolve.h" 26 | 27 | #include "OrderingMethods" 28 | #include "src/SparseCore/SparseColEtree.h" 29 | #include "src/SparseQR/SparseQR.h" 30 | 31 | #include "src/Core/util/ReenableStupidWarnings.h" 32 | 33 | #endif 34 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/StdDeque: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009 Gael Guennebaud 5 | // Copyright (C) 2009 Hauke Heibel 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | #ifndef EIGEN_STDDEQUE_MODULE_H 12 | #define EIGEN_STDDEQUE_MODULE_H 13 | 14 | #include "Core" 15 | #include 16 | 17 | #if (defined(_MSC_VER) && defined(_WIN64)) /* MSVC auto aligns in 64 bit builds */ 18 | 19 | #define EIGEN_DEFINE_STL_DEQUE_SPECIALIZATION(...) 20 | 21 | #else 22 | 23 | #include "src/StlSupport/StdDeque.h" 24 | 25 | #endif 26 | 27 | #endif // EIGEN_STDDEQUE_MODULE_H 28 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/StdList: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009 Hauke Heibel 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_STDLIST_MODULE_H 11 | #define EIGEN_STDLIST_MODULE_H 12 | 13 | #include "Core" 14 | #include 15 | 16 | #if (defined(_MSC_VER) && defined(_WIN64)) /* MSVC auto aligns in 64 bit builds */ 17 | 18 | #define EIGEN_DEFINE_STL_LIST_SPECIALIZATION(...) 19 | 20 | #else 21 | 22 | #include "src/StlSupport/StdList.h" 23 | 24 | #endif 25 | 26 | #endif // EIGEN_STDLIST_MODULE_H 27 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/StdVector: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009 Gael Guennebaud 5 | // Copyright (C) 2009 Hauke Heibel 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | #ifndef EIGEN_STDVECTOR_MODULE_H 12 | #define EIGEN_STDVECTOR_MODULE_H 13 | 14 | #include "Core" 15 | #include 16 | 17 | #if (defined(_MSC_VER) && defined(_WIN64)) /* MSVC auto aligns in 64 bit builds */ 18 | 19 | #define EIGEN_DEFINE_STL_VECTOR_SPECIALIZATION(...) 20 | 21 | #else 22 | 23 | #include "src/StlSupport/StdVector.h" 24 | 25 | #endif 26 | 27 | #endif // EIGEN_STDVECTOR_MODULE_H 28 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/UmfPackSupport: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_UMFPACKSUPPORT_MODULE_H 2 | #define EIGEN_UMFPACKSUPPORT_MODULE_H 3 | 4 | #include "SparseCore" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | extern "C" { 9 | #include 10 | } 11 | 12 | /** \ingroup Support_modules 13 | * \defgroup UmfPackSupport_Module UmfPackSupport module 14 | * 15 | * This module provides an interface to the UmfPack library which is part of the suitesparse package. 16 | * It provides the following factorization class: 17 | * - class UmfPackLU: a multifrontal sequential LU factorization. 18 | * 19 | * \code 20 | * #include 21 | * \endcode 22 | * 23 | * In order to use this module, the umfpack headers must be accessible from the include paths, and your binary must be linked to the umfpack library and its dependencies. 24 | * The dependencies depend on how umfpack has been compiled. 25 | * For a cmake based project, you can use our FindUmfPack.cmake module to help you in this task. 26 | * 27 | */ 28 | 29 | #include "src/misc/Solve.h" 30 | #include "src/misc/SparseSolve.h" 31 | 32 | #include "src/UmfPackSupport/UmfPackSupport.h" 33 | 34 | #include "src/Core/util/ReenableStupidWarnings.h" 35 | 36 | #endif // EIGEN_UMFPACKSUPPORT_MODULE_H 37 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | file(GLOB Eigen_src_subdirectories "*") 2 | escape_string_as_regex(ESCAPED_CMAKE_CURRENT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}") 3 | foreach(f ${Eigen_src_subdirectories}) 4 | if(NOT f MATCHES "\\.txt" AND NOT f MATCHES "${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/[.].+" ) 5 | add_subdirectory(${f}) 6 | endif() 7 | endforeach() 8 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/Cholesky/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Cholesky_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Cholesky_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Cholesky COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/CholmodSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_CholmodSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_CholmodSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/CholmodSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/Core/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core COMPONENT Devel 6 | ) 7 | 8 | ADD_SUBDIRECTORY(products) 9 | ADD_SUBDIRECTORY(util) 10 | ADD_SUBDIRECTORY(arch) 11 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/Core/arch/AltiVec/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_arch_AltiVec_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_arch_AltiVec_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/AltiVec COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/Core/arch/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | ADD_SUBDIRECTORY(SSE) 2 | ADD_SUBDIRECTORY(AltiVec) 3 | ADD_SUBDIRECTORY(NEON) 4 | ADD_SUBDIRECTORY(Default) 5 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/Core/arch/Default/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_arch_Default_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_arch_Default_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/Default COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/Core/arch/NEON/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_arch_NEON_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_arch_NEON_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/NEON COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/Core/arch/SSE/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_arch_SSE_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_arch_SSE_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/SSE COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/Core/products/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_Product_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_Product_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/products COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/Core/util/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_util_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_util_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/util COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/Core/util/NonMPL2.h: -------------------------------------------------------------------------------- 1 | #ifdef EIGEN_MPL2_ONLY 2 | #error Including non-MPL2 code in EIGEN_MPL2_ONLY mode 3 | #endif 4 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/Core/util/ReenableStupidWarnings.h: -------------------------------------------------------------------------------- 1 | #ifdef EIGEN_WARNINGS_DISABLED 2 | #undef EIGEN_WARNINGS_DISABLED 3 | 4 | #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS 5 | #ifdef _MSC_VER 6 | #pragma warning( pop ) 7 | #elif defined __INTEL_COMPILER 8 | #pragma warning pop 9 | #elif defined __clang__ 10 | #pragma clang diagnostic pop 11 | #elif defined __GNUC__ && __GNUC__>=6 12 | #pragma GCC diagnostic pop 13 | #endif 14 | 15 | #endif 16 | 17 | #endif // EIGEN_WARNINGS_DISABLED 18 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/Eigen2Support/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Eigen2Support_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Eigen2Support_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Eigen2Support COMPONENT Devel 6 | ) 7 | 8 | ADD_SUBDIRECTORY(Geometry) -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/Eigen2Support/Geometry/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Eigen2Support_Geometry_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Eigen2Support_Geometry_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Eigen2Support/Geometry 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/Eigen2Support/Macros.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2011 Benoit Jacob 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 EIGEN2_MACROS_H 11 | #define EIGEN2_MACROS_H 12 | 13 | #define ei_assert eigen_assert 14 | #define ei_internal_assert eigen_internal_assert 15 | 16 | #define EIGEN_ALIGN_128 EIGEN_ALIGN16 17 | 18 | #define EIGEN_ARCH_WANTS_ALIGNMENT EIGEN_ALIGN_STATICALLY 19 | 20 | #endif // EIGEN2_MACROS_H 21 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/Eigenvalues/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_EIGENVALUES_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_EIGENVALUES_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Eigenvalues COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/Geometry/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Geometry_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Geometry_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Geometry COMPONENT Devel 6 | ) 7 | 8 | ADD_SUBDIRECTORY(arch) 9 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/Geometry/arch/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Geometry_arch_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Geometry_arch_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Geometry/arch COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/Householder/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Householder_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Householder_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Householder COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/IterativeLinearSolvers/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_IterativeLinearSolvers_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_IterativeLinearSolvers_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/IterativeLinearSolvers COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/Jacobi/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Jacobi_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Jacobi_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Jacobi COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/LU/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_LU_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_LU_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/LU COMPONENT Devel 6 | ) 7 | 8 | ADD_SUBDIRECTORY(arch) 9 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/LU/arch/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_LU_arch_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_LU_arch_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/LU/arch COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/MetisSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_MetisSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_MetisSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/MetisSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/OrderingMethods/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_OrderingMethods_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_OrderingMethods_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/OrderingMethods COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/PaStiXSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_PastixSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_PastixSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/PaStiXSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/PardisoSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_PardisoSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_PardisoSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/PardisoSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/QR/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_QR_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_QR_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/QR COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/SPQRSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SPQRSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SPQRSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SPQRSupport/ COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/SVD/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SVD_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SVD_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SVD COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/SparseCholesky/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SparseCholesky_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SparseCholesky_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SparseCholesky COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/SparseCore/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SparseCore_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SparseCore_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SparseCore COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/SparseCore/SparseFuzzy.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008 Gael Guennebaud 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_SPARSE_FUZZY_H 11 | #define EIGEN_SPARSE_FUZZY_H 12 | 13 | // template 14 | // template 15 | // bool SparseMatrixBase::isApprox( 16 | // const OtherDerived& other, 17 | // typename NumTraits::Real prec 18 | // ) const 19 | // { 20 | // const typename internal::nested::type nested(derived()); 21 | // const typename internal::nested::type otherNested(other.derived()); 22 | // return (nested - otherNested).cwise().abs2().sum() 23 | // <= prec * prec * (std::min)(nested.cwise().abs2().sum(), otherNested.cwise().abs2().sum()); 24 | // } 25 | 26 | #endif // EIGEN_SPARSE_FUZZY_H 27 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/SparseLU/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SparseLU_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SparseLU_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SparseLU COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/SparseQR/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SparseQR_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SparseQR_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SparseQR/ COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/StlSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_StlSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_StlSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/StlSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/SuperLUSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SuperLUSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SuperLUSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SuperLUSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/UmfPackSupport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_UmfPackSupport_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_UmfPackSupport_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/UmfPackSupport COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/misc/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_misc_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_misc_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/misc COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/Eigen/src/plugins/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_plugins_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_plugins_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/plugins COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory(Eigen) 2 | add_subdirectory(doc EXCLUDE_FROM_ALL) 3 | if(EIGEN_LEAVE_TEST_IN_ALL_TARGET) 4 | add_subdirectory(test) # can't do EXCLUDE_FROM_ALL here, breaks CTest 5 | else() 6 | add_subdirectory(test EXCLUDE_FROM_ALL) 7 | endif() 8 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/ArpackSupport: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // 5 | // This Source Code Form is subject to the terms of the Mozilla 6 | // Public License v. 2.0. If a copy of the MPL was not distributed 7 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 8 | 9 | #ifndef EIGEN_ARPACKSUPPORT_MODULE_H 10 | #define EIGEN_ARPACKSUPPORT_MODULE_H 11 | 12 | #include 13 | 14 | #include 15 | 16 | /** \defgroup ArpackSupport_Module Arpack support module 17 | * 18 | * This module provides a wrapper to Arpack, a library for sparse eigenvalue decomposition. 19 | * 20 | * \code 21 | * #include 22 | * \endcode 23 | */ 24 | 25 | #include 26 | #include "src/Eigenvalues/ArpackSelfAdjointEigenSolver.h" 27 | 28 | #include 29 | 30 | #endif // EIGEN_ARPACKSUPPORT_MODULE_H 31 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 32 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/AutoDiff: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008-2009 Gael Guennebaud 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_AUTODIFF_MODULE 11 | #define EIGEN_AUTODIFF_MODULE 12 | 13 | namespace Eigen { 14 | 15 | /** 16 | * \defgroup AutoDiff_Module Auto Diff module 17 | * 18 | * This module features forward automatic differentation via a simple 19 | * templated scalar type wrapper AutoDiffScalar. 20 | * 21 | * Warning : this should NOT be confused with numerical differentiation, which 22 | * is a different method and has its own module in Eigen : \ref NumericalDiff_Module. 23 | * 24 | * \code 25 | * #include 26 | * \endcode 27 | */ 28 | //@{ 29 | 30 | } 31 | 32 | #include "src/AutoDiff/AutoDiffScalar.h" 33 | // #include "src/AutoDiff/AutoDiffVector.h" 34 | #include "src/AutoDiff/AutoDiffJacobian.h" 35 | 36 | namespace Eigen { 37 | //@} 38 | } 39 | 40 | #endif // EIGEN_AUTODIFF_MODULE 41 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(Eigen_HEADERS AdolcForward AlignedVector3 ArpackSupport AutoDiff BVH FFT IterativeSolvers KroneckerProduct LevenbergMarquardt 2 | MatrixFunctions MoreVectorization MPRealSupport NonLinearOptimization NumericalDiff OpenGLSupport Polynomials 3 | Skyline SparseExtra Splines 4 | ) 5 | 6 | install(FILES 7 | ${Eigen_HEADERS} 8 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen COMPONENT Devel 9 | ) 10 | 11 | add_subdirectory(src) 12 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/KroneckerProduct: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // 5 | // This Source Code Form is subject to the terms of the Mozilla 6 | // Public License v. 2.0. If a copy of the MPL was not distributed 7 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 8 | 9 | #ifndef EIGEN_KRONECKER_PRODUCT_MODULE_H 10 | #define EIGEN_KRONECKER_PRODUCT_MODULE_H 11 | 12 | #include "../../Eigen/Core" 13 | 14 | #include "../../Eigen/src/Core/util/DisableStupidWarnings.h" 15 | 16 | namespace Eigen { 17 | 18 | /** 19 | * \defgroup KroneckerProduct_Module KroneckerProduct module 20 | * 21 | * This module contains an experimental Kronecker product implementation. 22 | * 23 | * \code 24 | * #include 25 | * \endcode 26 | */ 27 | 28 | } // namespace Eigen 29 | 30 | #include "src/KroneckerProduct/KroneckerTensorProduct.h" 31 | 32 | #include "../../Eigen/src/Core/util/ReenableStupidWarnings.h" 33 | 34 | #endif // EIGEN_KRONECKER_PRODUCT_MODULE_H 35 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/LevenbergMarquardt: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009 Thomas Capricelli 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_LEVENBERGMARQUARDT_MODULE 11 | #define EIGEN_LEVENBERGMARQUARDT_MODULE 12 | 13 | // #include 14 | 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | #include 21 | 22 | /** 23 | * \defgroup LevenbergMarquardt_Module Levenberg-Marquardt module 24 | * 25 | * \code 26 | * #include 27 | * \endcode 28 | * 29 | * 30 | */ 31 | 32 | #include "Eigen/SparseCore" 33 | #ifndef EIGEN_PARSED_BY_DOXYGEN 34 | 35 | #include "src/LevenbergMarquardt/LMqrsolv.h" 36 | #include "src/LevenbergMarquardt/LMcovar.h" 37 | #include "src/LevenbergMarquardt/LMpar.h" 38 | 39 | #endif 40 | 41 | #include "src/LevenbergMarquardt/LevenbergMarquardt.h" 42 | #include "src/LevenbergMarquardt/LMonestep.h" 43 | 44 | 45 | #endif // EIGEN_LEVENBERGMARQUARDT_MODULE 46 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/MoreVectorization: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // 5 | // This Source Code Form is subject to the terms of the Mozilla 6 | // Public License v. 2.0. If a copy of the MPL was not distributed 7 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 8 | 9 | #ifndef EIGEN_MOREVECTORIZATION_MODULE_H 10 | #define EIGEN_MOREVECTORIZATION_MODULE_H 11 | 12 | #include 13 | 14 | namespace Eigen { 15 | 16 | /** 17 | * \defgroup MoreVectorization More vectorization module 18 | */ 19 | 20 | } 21 | 22 | #include "src/MoreVectorization/MathFunctions.h" 23 | 24 | #endif // EIGEN_MOREVECTORIZATION_MODULE_H 25 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/SVD: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_SVD_MODULE_H 2 | #define EIGEN_SVD_MODULE_H 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | #include "../../Eigen/src/Core/util/DisableStupidWarnings.h" 9 | 10 | /** \defgroup SVD_Module SVD module 11 | * 12 | * 13 | * 14 | * This module provides SVD decomposition for matrices (both real and complex). 15 | * This decomposition is accessible via the following MatrixBase method: 16 | * - MatrixBase::jacobiSvd() 17 | * 18 | * \code 19 | * #include 20 | * \endcode 21 | */ 22 | 23 | #include "../../Eigen/src/misc/Solve.h" 24 | #include "../../Eigen/src/SVD/UpperBidiagonalization.h" 25 | #include "src/SVD/SVDBase.h" 26 | #include "src/SVD/JacobiSVD.h" 27 | #include "src/SVD/BDCSVD.h" 28 | #if defined(EIGEN_USE_LAPACKE) && !defined(EIGEN_USE_LAPACKE_STRICT) 29 | #include "../../Eigen/src/SVD/JacobiSVD_MKL.h" 30 | #endif 31 | 32 | #ifdef EIGEN2_SUPPORT 33 | #include "../../Eigen/src/Eigen2Support/SVD.h" 34 | #endif 35 | 36 | #include "../../Eigen/src/Core/util/ReenableStupidWarnings.h" 37 | 38 | #endif // EIGEN_SVD_MODULE_H 39 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 40 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/Skyline: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // 5 | // This Source Code Form is subject to the terms of the Mozilla 6 | // Public License v. 2.0. If a copy of the MPL was not distributed 7 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 8 | 9 | #ifndef EIGEN_SKYLINE_MODULE_H 10 | #define EIGEN_SKYLINE_MODULE_H 11 | 12 | 13 | #include "Eigen/Core" 14 | 15 | #include "Eigen/src/Core/util/DisableStupidWarnings.h" 16 | 17 | #include 18 | #include 19 | #include 20 | #include 21 | 22 | /** 23 | * \defgroup Skyline_Module Skyline module 24 | * 25 | * 26 | * 27 | * 28 | */ 29 | 30 | #include "src/Skyline/SkylineUtil.h" 31 | #include "src/Skyline/SkylineMatrixBase.h" 32 | #include "src/Skyline/SkylineStorage.h" 33 | #include "src/Skyline/SkylineMatrix.h" 34 | #include "src/Skyline/SkylineInplaceLU.h" 35 | #include "src/Skyline/SkylineProduct.h" 36 | 37 | #include "Eigen/src/Core/util/ReenableStupidWarnings.h" 38 | 39 | #endif // EIGEN_SKYLINE_MODULE_H 40 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/Splines: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 20010-2011 Hauke Heibel 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_SPLINES_MODULE_H 11 | #define EIGEN_SPLINES_MODULE_H 12 | 13 | namespace Eigen 14 | { 15 | /** 16 | * \defgroup Splines_Module Spline and spline fitting module 17 | * 18 | * This module provides a simple multi-dimensional spline class while 19 | * offering most basic functionality to fit a spline to point sets. 20 | * 21 | * \code 22 | * #include 23 | * \endcode 24 | */ 25 | } 26 | 27 | #include "src/Splines/SplineFwd.h" 28 | #include "src/Splines/Spline.h" 29 | #include "src/Splines/SplineFitting.h" 30 | 31 | #endif // EIGEN_SPLINES_MODULE_H 32 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/src/AutoDiff/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_AutoDiff_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_AutoDiff_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/AutoDiff COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/src/BVH/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_BVH_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_BVH_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/BVH COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/src/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | ADD_SUBDIRECTORY(AutoDiff) 2 | ADD_SUBDIRECTORY(BVH) 3 | ADD_SUBDIRECTORY(Eigenvalues) 4 | ADD_SUBDIRECTORY(FFT) 5 | ADD_SUBDIRECTORY(IterativeSolvers) 6 | ADD_SUBDIRECTORY(KroneckerProduct) 7 | ADD_SUBDIRECTORY(LevenbergMarquardt) 8 | ADD_SUBDIRECTORY(MatrixFunctions) 9 | ADD_SUBDIRECTORY(MoreVectorization) 10 | ADD_SUBDIRECTORY(NonLinearOptimization) 11 | ADD_SUBDIRECTORY(NumericalDiff) 12 | ADD_SUBDIRECTORY(Polynomials) 13 | ADD_SUBDIRECTORY(Skyline) 14 | ADD_SUBDIRECTORY(SparseExtra) 15 | ADD_SUBDIRECTORY(Splines) 16 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/src/Eigenvalues/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Eigenvalues_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Eigenvalues_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/Eigenvalues COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/src/FFT/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_FFT_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_FFT_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/FFT COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/src/IterativeSolvers/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_IterativeSolvers_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_IterativeSolvers_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/IterativeSolvers COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/src/KroneckerProduct/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_KroneckerProduct_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_KroneckerProduct_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/KroneckerProduct COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/src/LevenbergMarquardt/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_LevenbergMarquardt_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_LevenbergMarquardt_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/LevenbergMarquardt COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/src/MatrixFunctions/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_MatrixFunctions_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_MatrixFunctions_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/MatrixFunctions COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/src/MoreVectorization/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_MoreVectorization_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_MoreVectorization_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/MoreVectorization COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/src/NonLinearOptimization/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_NonLinearOptimization_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_NonLinearOptimization_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/NonLinearOptimization COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/Eigen/src/NonLinearOptimization/r1mpyq.h: -------------------------------------------------------------------------------- 1 | namespace Eigen { 2 | 3 | namespace internal { 4 | 5 | // TODO : move this to GivensQR once there's such a thing in Eigen 6 | 7 | template 8 | void r1mpyq(DenseIndex m, DenseIndex n, Scalar *a, const std::vector > &v_givens, const std::vector > &w_givens) 9 | { 10 | typedef DenseIndex Index; 11 | 12 | /* apply the first set of givens rotations to a. */ 13 | for (Index j = n-2; j>=0; --j) 14 | for (Index i = 0; iofficial Eigen documentation. 12 | 13 | */ 14 | 15 | /* 16 | 17 | \defgroup Unsupported_modules Unsupported modules 18 | 19 | The unsupported modules are contributions from various users. They are 20 | provided "as is", without any support. Nevertheless, some of them are 21 | subject to be included in Eigen in the future. 22 | 23 | */ 24 | 25 | } 26 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/doc/examples/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB examples_SRCS "*.cpp") 2 | 3 | ADD_CUSTOM_TARGET(unsupported_examples) 4 | 5 | INCLUDE_DIRECTORIES(../../../unsupported ../../../unsupported/test) 6 | 7 | FOREACH(example_src ${examples_SRCS}) 8 | GET_FILENAME_COMPONENT(example ${example_src} NAME_WE) 9 | ADD_EXECUTABLE(example_${example} ${example_src}) 10 | if(EIGEN_STANDARD_LIBRARIES_TO_LINK_TO) 11 | target_link_libraries(example_${example} ${EIGEN_STANDARD_LIBRARIES_TO_LINK_TO}) 12 | endif() 13 | ADD_CUSTOM_COMMAND( 14 | TARGET example_${example} 15 | POST_BUILD 16 | COMMAND example_${example} 17 | ARGS >${CMAKE_CURRENT_BINARY_DIR}/${example}.out 18 | ) 19 | ADD_DEPENDENCIES(unsupported_examples example_${example}) 20 | ENDFOREACH(example_src) 21 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/doc/examples/MatrixExponential.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace Eigen; 5 | 6 | int main() 7 | { 8 | const double pi = std::acos(-1.0); 9 | 10 | MatrixXd A(3,3); 11 | A << 0, -pi/4, 0, 12 | pi/4, 0, 0, 13 | 0, 0, 0; 14 | std::cout << "The matrix A is:\n" << A << "\n\n"; 15 | std::cout << "The matrix exponential of A is:\n" << A.exp() << "\n\n"; 16 | } 17 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/doc/examples/MatrixFunction.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace Eigen; 5 | 6 | std::complex expfn(std::complex x, int) 7 | { 8 | return std::exp(x); 9 | } 10 | 11 | int main() 12 | { 13 | const double pi = std::acos(-1.0); 14 | 15 | MatrixXd A(3,3); 16 | A << 0, -pi/4, 0, 17 | pi/4, 0, 0, 18 | 0, 0, 0; 19 | 20 | std::cout << "The matrix A is:\n" << A << "\n\n"; 21 | std::cout << "The matrix exponential of A is:\n" 22 | << A.matrixFunction(expfn) << "\n\n"; 23 | } 24 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/doc/examples/MatrixLogarithm.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace Eigen; 5 | 6 | int main() 7 | { 8 | using std::sqrt; 9 | MatrixXd A(3,3); 10 | A << 0.5*sqrt(2), -0.5*sqrt(2), 0, 11 | 0.5*sqrt(2), 0.5*sqrt(2), 0, 12 | 0, 0, 1; 13 | std::cout << "The matrix A is:\n" << A << "\n\n"; 14 | std::cout << "The matrix logarithm of A is:\n" << A.log() << "\n"; 15 | } 16 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/doc/examples/MatrixPower.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace Eigen; 5 | 6 | int main() 7 | { 8 | const double pi = std::acos(-1.0); 9 | Matrix3d A; 10 | A << cos(1), -sin(1), 0, 11 | sin(1), cos(1), 0, 12 | 0 , 0 , 1; 13 | std::cout << "The matrix A is:\n" << A << "\n\n" 14 | "The matrix power A^(pi/4) is:\n" << A.pow(pi/4) << std::endl; 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/doc/examples/MatrixPower_optimal.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace Eigen; 5 | 6 | int main() 7 | { 8 | Matrix4cd A = Matrix4cd::Random(); 9 | MatrixPower Apow(A); 10 | 11 | std::cout << "The matrix A is:\n" << A << "\n\n" 12 | "A^3.1 is:\n" << Apow(3.1) << "\n\n" 13 | "A^3.3 is:\n" << Apow(3.3) << "\n\n" 14 | "A^3.7 is:\n" << Apow(3.7) << "\n\n" 15 | "A^3.9 is:\n" << Apow(3.9) << std::endl; 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/doc/examples/MatrixSine.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace Eigen; 5 | 6 | int main() 7 | { 8 | MatrixXd A = MatrixXd::Random(3,3); 9 | std::cout << "A = \n" << A << "\n\n"; 10 | 11 | MatrixXd sinA = A.sin(); 12 | std::cout << "sin(A) = \n" << sinA << "\n\n"; 13 | 14 | MatrixXd cosA = A.cos(); 15 | std::cout << "cos(A) = \n" << cosA << "\n\n"; 16 | 17 | // The matrix functions satisfy sin^2(A) + cos^2(A) = I, 18 | // like the scalar functions. 19 | std::cout << "sin^2(A) + cos^2(A) = \n" << sinA*sinA + cosA*cosA << "\n\n"; 20 | } 21 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/doc/examples/MatrixSinh.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace Eigen; 5 | 6 | int main() 7 | { 8 | MatrixXf A = MatrixXf::Random(3,3); 9 | std::cout << "A = \n" << A << "\n\n"; 10 | 11 | MatrixXf sinhA = A.sinh(); 12 | std::cout << "sinh(A) = \n" << sinhA << "\n\n"; 13 | 14 | MatrixXf coshA = A.cosh(); 15 | std::cout << "cosh(A) = \n" << coshA << "\n\n"; 16 | 17 | // The matrix functions satisfy cosh^2(A) - sinh^2(A) = I, 18 | // like the scalar functions. 19 | std::cout << "cosh^2(A) - sinh^2(A) = \n" << coshA*coshA - sinhA*sinhA << "\n\n"; 20 | } 21 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/doc/examples/MatrixSquareRoot.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace Eigen; 5 | 6 | int main() 7 | { 8 | const double pi = std::acos(-1.0); 9 | 10 | MatrixXd A(2,2); 11 | A << cos(pi/3), -sin(pi/3), 12 | sin(pi/3), cos(pi/3); 13 | std::cout << "The matrix A is:\n" << A << "\n\n"; 14 | std::cout << "The matrix square root of A is:\n" << A.sqrt() << "\n\n"; 15 | std::cout << "The square of the last matrix is:\n" << A.sqrt() * A.sqrt() << "\n"; 16 | } 17 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/doc/examples/PolynomialUtils1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace Eigen; 5 | using namespace std; 6 | 7 | int main() 8 | { 9 | Vector4d roots = Vector4d::Random(); 10 | cout << "Roots: " << roots.transpose() << endl; 11 | Eigen::Matrix polynomial; 12 | roots_to_monicPolynomial( roots, polynomial ); 13 | cout << "Polynomial: "; 14 | for( int i=0; i<4; ++i ){ cout << polynomial[i] << ".x^" << i << "+ "; } 15 | cout << polynomial[4] << ".x^4" << endl; 16 | Vector4d evaluation; 17 | for( int i=0; i<4; ++i ){ 18 | evaluation[i] = poly_eval( polynomial, roots[i] ); } 19 | cout << "Evaluation of the polynomial at the roots: " << evaluation.transpose(); 20 | } 21 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/doc/snippets/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB snippets_SRCS "*.cpp") 2 | 3 | ADD_CUSTOM_TARGET(unsupported_snippets) 4 | 5 | FOREACH(snippet_src ${snippets_SRCS}) 6 | GET_FILENAME_COMPONENT(snippet ${snippet_src} NAME_WE) 7 | SET(compile_snippet_target compile_${snippet}) 8 | SET(compile_snippet_src ${compile_snippet_target}.cpp) 9 | FILE(READ ${snippet_src} snippet_source_code) 10 | CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/doc/snippets/compile_snippet.cpp.in 11 | ${CMAKE_CURRENT_BINARY_DIR}/${compile_snippet_src}) 12 | ADD_EXECUTABLE(${compile_snippet_target} 13 | ${CMAKE_CURRENT_BINARY_DIR}/${compile_snippet_src}) 14 | if(EIGEN_STANDARD_LIBRARIES_TO_LINK_TO) 15 | target_link_libraries(${compile_snippet_target} ${EIGEN_STANDARD_LIBRARIES_TO_LINK_TO}) 16 | endif() 17 | ADD_CUSTOM_COMMAND( 18 | TARGET ${compile_snippet_target} 19 | POST_BUILD 20 | COMMAND ${compile_snippet_target} 21 | ARGS >${CMAKE_CURRENT_BINARY_DIR}/${snippet}.out 22 | ) 23 | ADD_DEPENDENCIES(unsupported_snippets ${compile_snippet_target}) 24 | set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${compile_snippet_src} 25 | PROPERTIES OBJECT_DEPENDS ${snippet_src}) 26 | ENDFOREACH(snippet_src) 27 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/test/FFT.cpp: -------------------------------------------------------------------------------- 1 | #define test_FFTW test_FFT 2 | #include "FFTW.cpp" 3 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/test/dgmres.cpp: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2011 Gael Guennebaud 5 | // Copyright (C) 2012 desire Nuentsa 13 | 14 | template void test_dgmres_T() 15 | { 16 | DGMRES, DiagonalPreconditioner > dgmres_colmajor_diag; 17 | DGMRES, IdentityPreconditioner > dgmres_colmajor_I; 18 | DGMRES, IncompleteLUT > dgmres_colmajor_ilut; 19 | //GMRES, SSORPreconditioner > dgmres_colmajor_ssor; 20 | 21 | CALL_SUBTEST( check_sparse_square_solving(dgmres_colmajor_diag) ); 22 | // CALL_SUBTEST( check_sparse_square_solving(dgmres_colmajor_I) ); 23 | CALL_SUBTEST( check_sparse_square_solving(dgmres_colmajor_ilut) ); 24 | //CALL_SUBTEST( check_sparse_square_solving(dgmres_colmajor_ssor) ); 25 | } 26 | 27 | void test_dgmres() 28 | { 29 | CALL_SUBTEST_1(test_dgmres_T()); 30 | CALL_SUBTEST_2(test_dgmres_T >()); 31 | } 32 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/test/gmres.cpp: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2011 Gael Guennebaud 5 | // Copyright (C) 2012 Kolja Brix 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | #include "../../test/sparse_solver.h" 12 | #include 13 | 14 | template void test_gmres_T() 15 | { 16 | GMRES, DiagonalPreconditioner > gmres_colmajor_diag; 17 | GMRES, IdentityPreconditioner > gmres_colmajor_I; 18 | GMRES, IncompleteLUT > gmres_colmajor_ilut; 19 | //GMRES, SSORPreconditioner > gmres_colmajor_ssor; 20 | 21 | CALL_SUBTEST( check_sparse_square_solving(gmres_colmajor_diag) ); 22 | // CALL_SUBTEST( check_sparse_square_solving(gmres_colmajor_I) ); 23 | CALL_SUBTEST( check_sparse_square_solving(gmres_colmajor_ilut) ); 24 | //CALL_SUBTEST( check_sparse_square_solving(gmres_colmajor_ssor) ); 25 | } 26 | 27 | void test_gmres() 28 | { 29 | CALL_SUBTEST_1(test_gmres_T()); 30 | CALL_SUBTEST_2(test_gmres_T >()); 31 | } 32 | -------------------------------------------------------------------------------- /ThirdParty/OpenGV/third_party/eigen3/unsupported/test/matrix_square_root.cpp: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2011 Jitse Niesen 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 | #include "matrix_functions.h" 11 | 12 | template 13 | void testMatrixSqrt(const MatrixType& m) 14 | { 15 | MatrixType A; 16 | generateTestMatrix::run(A, m.rows()); 17 | MatrixType sqrtA = A.sqrt(); 18 | VERIFY_IS_APPROX(sqrtA * sqrtA, A); 19 | } 20 | 21 | void test_matrix_square_root() 22 | { 23 | for (int i = 0; i < g_repeat; i++) { 24 | CALL_SUBTEST_1(testMatrixSqrt(Matrix3cf())); 25 | CALL_SUBTEST_2(testMatrixSqrt(MatrixXcd(12,12))); 26 | CALL_SUBTEST_3(testMatrixSqrt(Matrix4f())); 27 | CALL_SUBTEST_4(testMatrixSqrt(Matrix(9, 9))); 28 | CALL_SUBTEST_5(testMatrixSqrt(Matrix())); 29 | CALL_SUBTEST_5(testMatrixSqrt(Matrix,1,1>())); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /ThirdParty/g2o/README.txt: -------------------------------------------------------------------------------- 1 | You should have received this g2o version along with ORB-SLAM2 (https://github.com/raulmur/ORB_SLAM2). 2 | See the original g2o library at: https://github.com/RainerKuemmerle/g2o 3 | All files included in this g2o version are BSD, see license-bsd.txt 4 | -------------------------------------------------------------------------------- /ThirdParty/g2o/config.h: -------------------------------------------------------------------------------- 1 | #ifndef G2O_CONFIG_H 2 | #define G2O_CONFIG_H 3 | 4 | 5 | /* #undef G2O_HAVE_OPENGL */ 6 | /* #undef G2O_OPENGL_FOUND */ 7 | /* #undef G2O_OPENMP */ 8 | /* #undef G2O_SHARED_LIBS */ 9 | /* #undef G2O_LGPL_SHARED_LIBS */ 10 | 11 | // available sparse matrix libraries 12 | /* #undef G2O_HAVE_CHOLMOD */ 13 | /* #undef G2O_HAVE_CSPARSE */ 14 | 15 | #define G2O_CXX_COMPILER "GNU /usr/bin/c++" 16 | 17 | #ifdef __cplusplus 18 | #include 19 | #endif 20 | 21 | #endif 22 | -------------------------------------------------------------------------------- /ThirdParty/g2o/config.h.in: -------------------------------------------------------------------------------- 1 | #ifndef G2O_CONFIG_H 2 | #define G2O_CONFIG_H 3 | 4 | 5 | #cmakedefine G2O_HAVE_OPENGL 1 6 | #cmakedefine G2O_OPENGL_FOUND 1 7 | #cmakedefine G2O_OPENMP 1 8 | #cmakedefine G2O_SHARED_LIBS 1 9 | #cmakedefine G2O_LGPL_SHARED_LIBS 1 10 | 11 | // available sparse matrix libraries 12 | #cmakedefine G2O_HAVE_CHOLMOD 1 13 | #cmakedefine G2O_HAVE_CSPARSE 1 14 | 15 | #cmakedefine G2O_CXX_COMPILER "@G2O_CXX_COMPILER@" 16 | 17 | #ifdef __cplusplus 18 | #include 19 | #endif 20 | 21 | #endif 22 | -------------------------------------------------------------------------------- /ThirdParty/g2o/g2o/config.h: -------------------------------------------------------------------------------- 1 | #ifndef G2O_CONFIG_H 2 | #define G2O_CONFIG_H 3 | 4 | 5 | #define G2O_HAVE_OPENGL 1 6 | #define G2O_OPENGL_FOUND 1 7 | /* #undef G2O_OPENMP */ 8 | #define G2O_SHARED_LIBS 1 9 | #define G2O_LGPL_SHARED_LIBS 1 10 | 11 | // available sparse matrix libraries 12 | #define G2O_HAVE_CHOLMOD 1 13 | #define G2O_HAVE_CSPARSE 1 14 | 15 | #define G2O_CXX_COMPILER "MSVC F:/Programme/Microsoft Visual Studio 12.0/VC/bin/x86_amd64/cl.exe" 16 | 17 | #ifdef __cplusplus 18 | #include 19 | #endif 20 | 21 | #endif 22 | -------------------------------------------------------------------------------- /ThirdParty/g2o/g2o/core/g2o_core_api.h: -------------------------------------------------------------------------------- 1 | /*************************************************************************** 2 | * Description: import/export macros for creating DLLS with Microsoft 3 | * compiler. Any exported function needs to be declared with the 4 | * appropriate G2O_XXXX_API macro. Also, there must be separate macros 5 | * for each DLL (arrrrrgh!!!) 6 | * 7 | * 17 Jan 2012 8 | * Email: pupilli@cs.bris.ac.uk 9 | ****************************************************************************/ 10 | #ifndef G2O_CORE_API_H 11 | #define G2O_CORE_API_H 12 | 13 | //#include "g2o/config.h" 14 | #include "config.h" 15 | #ifdef _MSC_VER 16 | // We are using a Microsoft compiler: 17 | #ifdef G2O_SHARED_LIBS 18 | #ifdef core_EXPORTS 19 | #define G2O_CORE_API __declspec(dllexport) 20 | #else 21 | #define G2O_CORE_API __declspec(dllimport) 22 | #endif 23 | #else 24 | #define G2O_CORE_API 25 | #endif 26 | 27 | #else 28 | // Not Microsoft compiler so set empty definition: 29 | #define G2O_CORE_API 30 | #endif 31 | 32 | #endif // G2O_CORE_API_H 33 | -------------------------------------------------------------------------------- /ThirdParty/g2o/g2o/core/sparse_optimizer_terminate_action.h: -------------------------------------------------------------------------------- 1 | #ifndef SPARSE_OPTIMIZER_TERMINATE_ACTION_H 2 | #define SPARSE_OPTIMIZER_TERMINATE_ACTION_H 3 | 4 | #include "g2o_core_api.h" 5 | #include "hyper_graph_action.h" 6 | 7 | namespace g2o { 8 | 9 | class SparseOptimizer; 10 | 11 | /** 12 | * \brief stop iterating based on the gain which is (oldChi - currentChi) / currentChi. 13 | * 14 | * stop iterating based on the gain which is (oldChi - currentChi) / currentChi. 15 | * If the gain is larger than zero and below the threshold, then the optimizer is stopped. 16 | * Typically usage of this action includes adding it as a postIteration action, by calling 17 | * addPostIterationAction on a sparse optimizer. 18 | */ 19 | class G2O_CORE_API SparseOptimizerTerminateAction : public HyperGraphAction 20 | { 21 | public: 22 | SparseOptimizerTerminateAction(); 23 | virtual HyperGraphAction* operator()(const HyperGraph* graph, Parameters* parameters = 0); 24 | 25 | double gainThreshold() const { return _gainThreshold;} 26 | void setGainThreshold(double gainThreshold); 27 | 28 | int maxIterations() const { return _maxIterations;} 29 | void setMaxIterations(int maxit); 30 | 31 | protected: 32 | double _gainThreshold; 33 | double _lastChi; 34 | bool _auxTerminateFlag; 35 | int _maxIterations; 36 | 37 | void setOptimizerStopFlag(const SparseOptimizer* optimizer, bool stop); 38 | }; 39 | 40 | } // end namespace 41 | 42 | #endif 43 | -------------------------------------------------------------------------------- /ThirdParty/g2o/g2o/types/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Pre-canned types 2 | ADD_SUBDIRECTORY(data) 3 | ADD_SUBDIRECTORY(slam2d) 4 | ADD_SUBDIRECTORY(slam3d) 5 | ADD_SUBDIRECTORY(sba) 6 | ADD_SUBDIRECTORY(sim3) 7 | ADD_SUBDIRECTORY(icp) 8 | ADD_SUBDIRECTORY(sclam2d) 9 | ADD_SUBDIRECTORY(MultiCol) 10 | ADD_SUBDIRECTORY(slam2d_addons) 11 | ADD_SUBDIRECTORY(slam3d_addons) 12 | 13 | OPTION(G2O_BUILD_DEPRECATED_TYPES "Compile the deprecated types" OFF) 14 | IF(G2O_BUILD_DEPRECATED_TYPES) 15 | ADD_SUBDIRECTORY(deprecated) 16 | ENDIF() 17 | -------------------------------------------------------------------------------- /ThirdParty/g2o/lib/libg2o.so: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/ThirdParty/g2o/lib/libg2o.so -------------------------------------------------------------------------------- /ThirdParty/g2o/license-bsd.txt: -------------------------------------------------------------------------------- 1 | g2o - General Graph Optimization 2 | Copyright (C) 2011 Rainer Kuemmerle, Giorgio Grisetti, Hauke Strasdat, 3 | Kurt Konolige, and Wolfram Burgard 4 | All rights reserved. 5 | 6 | Redistribution and use in source and binary forms, with or without 7 | modification, are permitted provided that the following conditions are 8 | met: 9 | 10 | * Redistributions of source code must retain the above copyright notice, 11 | this list of conditions and the following disclaimer. 12 | * Redistributions in binary form must reproduce the above copyright 13 | notice, this list of conditions and the following disclaimer in the 14 | documentation and/or other materials provided with the distribution. 15 | 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS 17 | IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 18 | TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 19 | PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 20 | HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 21 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 22 | TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 23 | PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 24 | LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 25 | NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 26 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 | 28 | -------------------------------------------------------------------------------- /build.sh: -------------------------------------------------------------------------------- 1 | echo "Configuring and building Thirdparty/DBoW2 ..." 2 | 3 | cd ThirdParty/DBoW2 4 | mkdir build 5 | cd build 6 | cmake .. -DCMAKE_BUILD_TYPE=Release 7 | make 8 | 9 | 10 | cd ../../ 11 | echo "Configuring and building Thirdparty/g2o ..." 12 | 13 | EIGEN3_INCLUDE_DIR=$(pwd)/Eigen 14 | export EIGEN3_INCLUDE_DIR 15 | 16 | cd g2o 17 | mkdir build 18 | cd build 19 | cmake .. -DCMAKE_BUILD_TYPE=Release 20 | make 21 | 22 | echo "Configuring and building Thirdparty/opengv ..." 23 | 24 | cd ../../OpenGV 25 | 26 | mkdir build 27 | cd build 28 | cmake .. -DCMAKE_BUILD_TYPE=Release 29 | make 30 | 31 | echo "Configuring and building MultiCol-SLAM ..." 32 | cd ../../../ 33 | echo $(pwd) 34 | mkdir build 35 | cd build 36 | cmake .. -DCMAKE_BUILD_TYPE=Release 37 | make 38 | -------------------------------------------------------------------------------- /include/Utils.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #ifndef __UTILS_HPP__ 3 | #define __UTILS_HPP__ 4 | 5 | #include 6 | #include 7 | 8 | #define SET_CLOCK(t0) \ 9 | std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now(); 10 | 11 | #define TIME_DIFF(t1, t0) \ 12 | (std::chrono::duration_cast>((t1) - (t0)).count()) 13 | 14 | #define PRINT_CLOCK(msg, t1, t0) \ 15 | std::cerr << msg << TIME_DIFF(t1, t0) << endl; 16 | 17 | #ifdef USE_NVTX 18 | #include "nvToolsExt.h" 19 | 20 | static const uint32_t colors[] = { 0x0000ff00, 0x000000ff, 0x00ffff00, 0x00ff00ff, 0x0000ffff, 0x00ff0000, 0x00ffffff }; 21 | static const int num_colors = sizeof(colors)/sizeof(uint32_t); 22 | 23 | #define PUSH_RANGE(name,cid) { \ 24 | int color_id = cid; \ 25 | color_id = color_id%num_colors;\ 26 | nvtxEventAttributes_t eventAttrib = {0}; \ 27 | eventAttrib.version = NVTX_VERSION; \ 28 | eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE; \ 29 | eventAttrib.colorType = NVTX_COLOR_ARGB; \ 30 | eventAttrib.color = colors[color_id]; \ 31 | eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII; \ 32 | eventAttrib.message.ascii = name; \ 33 | nvtxRangePushEx(&eventAttrib); \ 34 | } 35 | #define POP_RANGE nvtxRangePop(); 36 | #else 37 | #define PUSH_RANGE(name,cid) 38 | #define POP_RANGE 39 | #endif 40 | 41 | #endif 42 | -------------------------------------------------------------------------------- /include/cLocalMapping.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/include/cLocalMapping.h -------------------------------------------------------------------------------- /include/cLoopClosing.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/include/cLoopClosing.h -------------------------------------------------------------------------------- /include/cMapPoint.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/include/cMapPoint.h -------------------------------------------------------------------------------- /include/cMapPublisher.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/include/cMapPublisher.h -------------------------------------------------------------------------------- /include/cMultiFramePublisher.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/include/cMultiFramePublisher.h -------------------------------------------------------------------------------- /include/cMultiInitializer.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/include/cMultiInitializer.h -------------------------------------------------------------------------------- /include/cMultiKeyFrameDatabase.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/include/cMultiKeyFrameDatabase.h -------------------------------------------------------------------------------- /include/cORBVocabulary.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/include/cORBVocabulary.h -------------------------------------------------------------------------------- /include/cORBmatcher.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/include/cORBmatcher.h -------------------------------------------------------------------------------- /include/cReadImage.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/include/cReadImage.h -------------------------------------------------------------------------------- /include/cSim3Solver.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/include/cSim3Solver.h -------------------------------------------------------------------------------- /include/cSystem.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/include/cSystem.h -------------------------------------------------------------------------------- /include/cViewer.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/include/cViewer.h -------------------------------------------------------------------------------- /include/cuda/Allocator.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #ifndef __ALLOCATOR_HPP__ 3 | #define __ALLOCATOR_HPP__ 4 | 5 | #include 6 | 7 | namespace ORB_SLAM2 { namespace cuda { 8 | extern cv::cuda::GpuMat::Allocator * gpu_mat_allocator; 9 | 10 | class Allocator : public cv::cuda::GpuMat::Allocator 11 | { 12 | const int allocatorPitchBase = 128; 13 | size_t getPitch(size_t widthSize); 14 | 15 | public: 16 | 17 | bool allocate(cv::cuda::GpuMat* mat, int rows, int cols, size_t elemSize); 18 | void free(cv::cuda::GpuMat* mat); 19 | }; 20 | } } 21 | 22 | #endif 23 | -------------------------------------------------------------------------------- /include/cuda/Cuda.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #ifndef __ORB_SLAM2_CUDA_HPP__ 3 | #define __ORB_SLAM2_CUDA_HPP__ 4 | 5 | namespace ORB_SLAM2 { namespace cuda { 6 | void deviceSynchronize(); 7 | } } 8 | 9 | #endif 10 | -------------------------------------------------------------------------------- /include/cuda/Orb.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #ifndef __ORB_HPP__ 3 | #define __ORB_HPP__ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | namespace ORB_SLAM2 { namespace cuda { 12 | using namespace std; 13 | using namespace cv; 14 | using namespace cv::cuda; 15 | 16 | class GpuOrb { 17 | unsigned int maxKeypoints; 18 | KeyPoint * keypoints[3]; 19 | GpuMat descriptors[3]; 20 | GpuMat desc[3]; 21 | cudaStream_t stream[3]; 22 | Stream cvStream[3]; 23 | public: 24 | GpuOrb(int maxKeypoints = 10000); 25 | ~GpuOrb(); 26 | 27 | void launch_async(InputArray _image, const KeyPoint * _keypoints, const int npoints,vector keypoints_mul_GPU,float scale,int c); 28 | void launch_async_mul(std::vector _images, vector > *allKeypoints, int level); 29 | void join(Mat &_descriptors,vector &_keypoints,vector keypoints_mul_GPU,int c); 30 | 31 | static void loadPattern(const Point * _pattern); 32 | }; 33 | } } 34 | #endif 35 | -------------------------------------------------------------------------------- /include/mdBRIEFextractorCon.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/include/mdBRIEFextractorCon.h -------------------------------------------------------------------------------- /include/mdBRIEFextractorOct.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/include/mdBRIEFextractorOct.h -------------------------------------------------------------------------------- /src/cConverter.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/src/cConverter.cpp -------------------------------------------------------------------------------- /src/cLoopClosing.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/src/cLoopClosing.cpp -------------------------------------------------------------------------------- /src/cMap.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/src/cMap.cpp -------------------------------------------------------------------------------- /src/cMapPoint.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/src/cMapPoint.cpp -------------------------------------------------------------------------------- /src/cMapPublisher.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/src/cMapPublisher.cpp -------------------------------------------------------------------------------- /src/cMultiFrame.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/src/cMultiFrame.cpp -------------------------------------------------------------------------------- /src/cMultiKeyFrameDatabase.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/src/cMultiKeyFrameDatabase.cpp -------------------------------------------------------------------------------- /src/cORBmatcher.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/src/cORBmatcher.cpp -------------------------------------------------------------------------------- /src/cSystem.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/src/cSystem.cpp -------------------------------------------------------------------------------- /src/cTracking.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/src/cTracking.cpp -------------------------------------------------------------------------------- /src/cViewer.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/src/cViewer.cpp -------------------------------------------------------------------------------- /src/cuda/Allocator_gpu.cu: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include "cuda/Allocator.hpp" 5 | 6 | namespace ORB_SLAM2 { namespace cuda { 7 | 8 | size_t Allocator::getPitch(size_t widthSize){ 9 | return 128 + widthSize - widthSize%128; 10 | } 11 | 12 | bool Allocator::allocate(cv::cuda::GpuMat* mat, int rows, int cols, size_t elemSize) 13 | { 14 | if (rows > 1 && cols > 1) 15 | { 16 | mat->step = getPitch(elemSize * cols); 17 | checkCudaErrors(cudaMallocManaged(&mat->data, mat->step * rows)); 18 | } 19 | else 20 | { 21 | // Single row or single column must be continuous 22 | checkCudaErrors(cudaMallocManaged(&mat->data, elemSize * cols * rows)); 23 | mat->step = elemSize * cols; 24 | } 25 | 26 | mat->refcount = (int*) new int(); 27 | 28 | return true; 29 | } 30 | 31 | void Allocator::free(cv::cuda::GpuMat* mat) 32 | { 33 | checkCudaErrors(cudaFree(mat->datastart)); 34 | delete mat->refcount; 35 | } 36 | 37 | cv::cuda::GpuMat::Allocator * gpu_mat_allocator; 38 | 39 | } } 40 | 41 | 42 | namespace { 43 | using namespace ORB_SLAM2; 44 | 45 | void __attribute__((constructor)) init() { 46 | // Setup GPU Memory Management 47 | cuda::gpu_mat_allocator = new cuda::Allocator(); 48 | // cv::cuda::GpuMat::setDefaultAllocator(cuda::gpu_mat_allocator); 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /src/cuda/Cuda.cu: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | namespace ORB_SLAM2 { namespace cuda { 5 | void deviceSynchronize() { 6 | checkCudaErrors( cudaDeviceSynchronize() ); 7 | } 8 | } } 9 | -------------------------------------------------------------------------------- /src/mdBRIEFextractorOct.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CASHIPS-ComputerVision/GPU-based-feature-extraction-for-VINS-VIO/109d877f2f9ba483583bae12d6fbfe4ec8006c2d/src/mdBRIEFextractorOct.cpp --------------------------------------------------------------------------------