├── CppNativePlugin ├── .gitignore ├── PlyLoader.sln ├── PlyLoader.vcxproj ├── PlyLoader.vcxproj.filters ├── PlyLoader │ ├── PlyLoader.cpp │ ├── PlyLoader.h │ └── ml_mesh_type.h └── vcglib │ ├── eigenlib │ ├── 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 │ ├── howto.txt │ └── 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 │ │ │ ├── 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 │ ├── vcg │ ├── complex │ │ ├── algorithms │ │ │ ├── attribute_seam.h │ │ │ ├── autoalign_4pcs.h │ │ │ ├── bitquad_creation.h │ │ │ ├── bitquad_optimization.h │ │ │ ├── bitquad_support.h │ │ │ ├── clean.h │ │ │ ├── clip.h │ │ │ ├── closest.h │ │ │ ├── clustering.h │ │ │ ├── convex_hull.h │ │ │ ├── crease_cut.h │ │ │ ├── create │ │ │ │ ├── advancing_front.h │ │ │ │ ├── ball_pivoting.h │ │ │ │ ├── extrude.h │ │ │ │ ├── marching_cubes.h │ │ │ │ ├── mc_lookup_table.h │ │ │ │ ├── mc_trivial_walker.h │ │ │ │ ├── platonic.h │ │ │ │ ├── plymc │ │ │ │ │ ├── plymc.h │ │ │ │ │ ├── simplemeshprovider.h │ │ │ │ │ ├── svoxel.h │ │ │ │ │ ├── tri_edge_collapse_mc.h │ │ │ │ │ ├── volume.h │ │ │ │ │ └── voxel.h │ │ │ │ ├── readme.txt │ │ │ │ ├── resampler.h │ │ │ │ └── zonohedron.h │ │ │ ├── curve_on_manifold.h │ │ │ ├── cylinder_clipping.h │ │ │ ├── edge_collapse.h │ │ │ ├── geodesic.h │ │ │ ├── halfedge_quad_clean.h │ │ │ ├── harmonic.h │ │ │ ├── hole.h │ │ │ ├── implicit_smooth.h │ │ │ ├── inertia.h │ │ │ ├── inside.h │ │ │ ├── intersection.h │ │ │ ├── local_optimization.h │ │ │ ├── local_optimization │ │ │ │ ├── quad_diag_collapse.h │ │ │ │ ├── tetra_edge_collapse.h │ │ │ │ ├── tri_edge_collapse.h │ │ │ │ ├── tri_edge_collapse_quadric.h │ │ │ │ ├── tri_edge_collapse_quadric_tex.h │ │ │ │ └── tri_edge_flip.h │ │ │ ├── mesh_assert.h │ │ │ ├── mesh_to_matrix.h │ │ │ ├── nring.h │ │ │ ├── outline_support.h │ │ │ ├── overlap_estimation.h │ │ │ ├── parametrization │ │ │ │ ├── distortion.h │ │ │ │ ├── poisson_solver.h │ │ │ │ ├── tangent_field_operators.h │ │ │ │ ├── uv_utils.h │ │ │ │ └── voronoi_atlas.h │ │ │ ├── point_outlier.h │ │ │ ├── point_sampling.h │ │ │ ├── pointcloud_normal.h │ │ │ ├── polygon_polychord_collapse.h │ │ │ ├── polygon_support.h │ │ │ ├── quadrangulator.h │ │ │ ├── ransac_matching.h │ │ │ ├── refine.h │ │ │ ├── refine_loop.h │ │ │ ├── skeleton.h │ │ │ ├── smooth.h │ │ │ ├── stat.h │ │ │ ├── symmetry.h │ │ │ ├── textcoord_optimization.h │ │ │ ├── update │ │ │ │ ├── bounding.h │ │ │ │ ├── color.h │ │ │ │ ├── component_ep.h │ │ │ │ ├── curvature.h │ │ │ │ ├── curvature_fitting.h │ │ │ │ ├── fitmaps.h │ │ │ │ ├── flag.h │ │ │ │ ├── halfedge_indexed.h │ │ │ │ ├── halfedge_topology.h │ │ │ │ ├── normal.h │ │ │ │ ├── position.h │ │ │ │ ├── quality.h │ │ │ │ ├── selection.h │ │ │ │ ├── texture.h │ │ │ │ └── topology.h │ │ │ ├── voronoi_processing.h │ │ │ └── voronoi_volume_sampling.h │ │ ├── all_types.h │ │ ├── allocate.h │ │ ├── append.h │ │ ├── base.h │ │ ├── complex.h │ │ ├── exception.h │ │ └── used_types.h │ ├── connectors │ │ ├── halfedge_pos.h │ │ ├── hedge.h │ │ └── hedge_component.h │ ├── container │ │ ├── container_allocation_table.h │ │ ├── derivation_chain.h │ │ ├── entries_allocation_table.h │ │ ├── simple_temporary_data.h │ │ └── vector_occ.h │ ├── math │ │ ├── base.h │ │ ├── camera.h │ │ ├── disjoint_set.h │ │ ├── eigen.h │ │ ├── eigen_matrix_addons.h │ │ ├── eigen_matrixbase_addons.h │ │ ├── factorial.h │ │ ├── gen_normal.h │ │ ├── histogram.h │ │ ├── legendre.h │ │ ├── linear.h │ │ ├── matrix33.h │ │ ├── matrix44.h │ │ ├── old_deprecated_matrix.h │ │ ├── old_lin_algebra.h │ │ ├── old_matrix.h │ │ ├── old_matrix33.h │ │ ├── old_matrix44.h │ │ ├── perlin_noise.h │ │ ├── polar_decomposition.h │ │ ├── quadric.h │ │ ├── quadric5.h │ │ ├── quaternion.h │ │ ├── random_generator.h │ │ ├── shot.h │ │ ├── similarity.h │ │ ├── similarity2.h │ │ └── spherical_harmonics.h │ ├── simplex │ │ ├── edge │ │ │ ├── base.h │ │ │ ├── component.h │ │ │ ├── distance.h │ │ │ ├── pos.h │ │ │ └── topology.h │ │ ├── face │ │ │ ├── base.h │ │ │ ├── component.h │ │ │ ├── component_ep.h │ │ │ ├── component_occ.h │ │ │ ├── component_ocf.h │ │ │ ├── component_polygon.h │ │ │ ├── distance.h │ │ │ ├── jumping_pos.h │ │ │ ├── pos.h │ │ │ └── topology.h │ │ ├── tetrahedron │ │ │ ├── base.h │ │ │ ├── component.h │ │ │ ├── pos.h │ │ │ └── tetrahedron.h │ │ └── vertex │ │ │ ├── base.h │ │ │ ├── component.h │ │ │ ├── component_occ.h │ │ │ ├── component_ocf.h │ │ │ ├── component_sph.h │ │ │ └── distance.h │ └── space │ │ ├── box.h │ │ ├── box2.h │ │ ├── box3.h │ │ ├── color4.h │ │ ├── colorspace.h │ │ ├── deprecated_point.h │ │ ├── deprecated_point2.h │ │ ├── deprecated_point3.h │ │ ├── deprecated_point4.h │ │ ├── distance2.h │ │ ├── distance3.h │ │ ├── fitting3.h │ │ ├── index │ │ ├── aabb_binary_tree │ │ │ ├── aabb_binary_tree.h │ │ │ ├── base.h │ │ │ ├── closest.h │ │ │ ├── frustum_cull.h │ │ │ ├── kclosest.h │ │ │ └── ray.h │ │ ├── base.h │ │ ├── base2d.h │ │ ├── closest2d.h │ │ ├── grid_closest.h │ │ ├── grid_closest2d.h │ │ ├── grid_static_obj.h │ │ ├── grid_static_ptr.h │ │ ├── grid_static_ptr2d.h │ │ ├── grid_util.h │ │ ├── grid_util2d.h │ │ ├── kdtree │ │ │ ├── kdtree.h │ │ │ ├── kdtree_face.h │ │ │ ├── mlsutils.h │ │ │ └── priorityqueue.h │ │ ├── octree.h │ │ ├── octree_template.h │ │ ├── perfect_spatial_hashing.h │ │ ├── space_iterators.h │ │ ├── space_iterators2d.h │ │ ├── spatial_hashing.h │ │ └── spatial_hashing2d.h │ │ ├── intersection │ │ └── triangle_triangle3.h │ │ ├── intersection2.h │ │ ├── intersection3.h │ │ ├── line2.h │ │ ├── line3.h │ │ ├── obox3.h │ │ ├── outline2_packer.h │ │ ├── planar_polygon_tessellation.h │ │ ├── plane3.h │ │ ├── point.h │ │ ├── point2.h │ │ ├── point3.h │ │ ├── point4.h │ │ ├── point_matching.h │ │ ├── polygon3.h │ │ ├── rasterized_outline2_packer.h │ │ ├── ray2.h │ │ ├── ray3.h │ │ ├── rect_packer.h │ │ ├── segment2.h │ │ ├── segment3.h │ │ ├── smallest_enclosing.h │ │ ├── space.h │ │ ├── sphere3.h │ │ ├── tetra3.h │ │ ├── texcoord2.h │ │ ├── triangle2.h │ │ └── triangle3.h │ └── wrap │ ├── bmt │ ├── bmt.cpp │ ├── bmt.h │ └── strip_mesh.h │ ├── callback.h │ ├── dae │ ├── colladaformat.h │ ├── poly_triangulator.h │ ├── util_dae.h │ ├── xmldocumentmanaging.cpp │ └── xmldocumentmanaging.h │ ├── gcache │ ├── cache.h │ ├── controller.h │ ├── dheap.h │ ├── docs │ │ ├── Doxyfile │ │ ├── css │ │ │ └── prettify.css │ │ ├── img │ │ │ ├── architecture.png │ │ │ ├── architecture.svg │ │ │ ├── overflow.png │ │ │ ├── overflow.svg │ │ │ └── shadow.png │ │ ├── js │ │ │ ├── prettify.css │ │ │ └── prettify.js │ │ └── readme.html │ ├── door.h │ ├── provider.h │ └── token.h │ ├── gl │ ├── addons.h │ ├── camera.h │ ├── deprecated_math.h │ ├── deprecated_space.h │ ├── fbo.h │ ├── gl_field.h │ ├── gl_geometry.h │ ├── gl_mesh_attributes_info.h │ ├── gl_mesh_attributes_multi_viewer_bo_manager.h │ ├── gl_object.h │ ├── gl_surface.h │ ├── gl_type_name.h │ ├── glu_tesselator.h │ ├── glu_tessellator_cap.h │ ├── math.h │ ├── pick.h │ ├── picking.h │ ├── pos.h │ ├── shaders.h │ ├── shot.h │ ├── space.h │ ├── splatting_apss │ │ ├── shaders │ │ │ ├── Finalization.glsl │ │ │ └── Raycasting.glsl │ │ ├── splatrenderer.h │ │ └── splatrenderer.qrc │ ├── tetramesh.h │ └── trimesh.h │ ├── glw │ ├── bookkeeping.h │ ├── buffer.h │ ├── common.h │ ├── config.h │ ├── context.h │ ├── fragmentshader.h │ ├── framebuffer.h │ ├── geometryshader.h │ ├── glheaders.h │ ├── glw.h │ ├── noncopyable.h │ ├── object.h │ ├── objectdeleter.h │ ├── program.h │ ├── renderable.h │ ├── renderbuffer.h │ ├── shader.h │ ├── texture.h │ ├── texture2d.h │ ├── texturecube.h │ ├── type.h │ ├── utility.h │ └── vertexshader.h │ ├── gui │ ├── activecoordinateframe.cpp │ ├── activecoordinateframe.h │ ├── coordinateframe.cpp │ ├── coordinateframe.h │ ├── frustum.h │ ├── rubberband.cpp │ ├── rubberband.h │ ├── trackball.cpp │ ├── trackball.h │ ├── trackmode.cpp │ ├── trackmode.h │ ├── trackrecorder.h │ ├── trackutils.h │ └── view.h │ ├── igl │ ├── lscm_parametrization.h │ ├── miq_parametrization.h │ └── smooth_field.h │ ├── io_edgemesh │ ├── export_dxf.h │ └── export_svg.h │ ├── io_tetramesh │ ├── export_ply.h │ ├── export_ts.h │ ├── import_ply.h │ ├── import_ts.h │ └── io_ply.h │ ├── io_trimesh │ ├── additionalinfo.h │ ├── export.h │ ├── export_3ds.h │ ├── export_ctm.h │ ├── export_dae.h │ ├── export_dxf.h │ ├── export_fbx.h │ ├── export_field.h │ ├── export_gts.h │ ├── export_idtf.h │ ├── export_iv.h │ ├── export_obj.h │ ├── export_off.h │ ├── export_ply.h │ ├── export_smf.h │ ├── export_stl.h │ ├── export_u3d.h │ ├── export_vmi.h │ ├── export_vrml.h │ ├── how_to_write_an_io_filter.txt │ ├── import.h │ ├── import_asc.h │ ├── import_ctm.h │ ├── import_dae.h │ ├── import_fbx.h │ ├── import_field.h │ ├── import_gts.h │ ├── import_nvm.h │ ├── import_obj.h │ ├── import_off.h │ ├── import_out.h │ ├── import_ply.h │ ├── import_ptx.h │ ├── import_raw.h │ ├── import_smf.h │ ├── import_stl.h │ ├── import_vmi.h │ ├── io_fan_tessellator.h │ ├── io_mask.h │ ├── io_material.h │ ├── io_ply.h │ └── precision.h │ ├── math │ ├── sparse_matrix.h │ └── system_interface_ldl.h │ ├── minpack │ └── minpack.h │ ├── mt │ └── mt.h │ ├── nanoply │ ├── docs │ │ ├── doxyfile │ │ └── index.dxy │ ├── include │ │ ├── nanoply.hpp │ │ └── nanoplyWrapper.hpp │ ├── nanoply_demo │ │ ├── main.cpp │ │ └── nanoply_demo.pro │ └── nanoply_vcg │ │ ├── main.cpp │ │ └── nanoply_vcg.pro │ ├── opensg │ └── vertex_component.h │ ├── ply │ ├── plylib.cpp │ ├── plylib.h │ └── plystuff.h │ ├── qt │ ├── Outline2ToQImage.cpp │ ├── Outline2ToQImage.h │ ├── anttweakbarMapper.cpp │ ├── anttweakbarMapper.h │ ├── anttweakbarMapperNew.cpp │ ├── checkGLError.h │ ├── col_qt_convert.h │ ├── device_to_logical.h │ ├── gl_label.h │ ├── img_qt.h │ ├── img_qt_convert.h │ ├── img_qt_io.h │ ├── outline2_rasterizer.cpp │ ├── outline2_rasterizer.h │ ├── qt_thread_safe_memory_info.h │ ├── qt_thread_safe_mesh_attributes_multi_viewer_bo_manager.h │ ├── qt_thread_safe_texture_names_container.h │ ├── shot_qt.h │ ├── to_string.h │ └── trackball.h │ ├── system │ ├── getopt.cpp │ ├── getopt.h │ ├── memory_info.h │ ├── multithreading │ │ ├── atomic_int.h │ │ ├── atomic_int_apple.h │ │ ├── atomic_int_generic.h │ │ ├── base.h │ │ ├── condition.h │ │ ├── mt.h │ │ ├── mutex.h │ │ ├── rw_lock.h │ │ ├── scoped_mutex_lock.h │ │ ├── scoped_read_lock.h │ │ ├── scoped_write_lock.h │ │ ├── semaphore.h │ │ ├── thread.h │ │ └── util.h │ ├── qgetopt.cpp │ ├── qgetopt.h │ └── time │ │ └── clock.h │ ├── tsai │ ├── tsaimethods.cpp │ └── tsaimethods.h │ └── utils.h ├── LICENSE ├── PlyLoader.unitypackage ├── README.md └── UnityProject ├── .gitignore ├── Assets ├── PlyLoader.meta ├── PlyLoader │ ├── PlyLoader.dll │ ├── PlyLoader.dll.meta │ ├── PlyLoaderDll.cs │ └── PlyLoaderDll.cs.meta ├── StreamingAssets.meta ├── StreamingAssets │ ├── mesh_UVtexture.jpg │ ├── mesh_UVtexture.jpg.meta │ ├── mesh_textured.ply │ └── mesh_textured.ply.meta ├── TestLoader.cs ├── TestLoader.cs.meta ├── main.unity └── main.unity.meta └── ProjectSettings ├── AudioManager.asset ├── ClusterInputManager.asset ├── DynamicsManager.asset ├── EditorBuildSettings.asset ├── EditorSettings.asset ├── GraphicsSettings.asset ├── InputManager.asset ├── NavMeshAreas.asset ├── NetworkManager.asset ├── Physics2DSettings.asset ├── ProjectSettings.asset ├── ProjectVersion.txt ├── QualitySettings.asset ├── TagManager.asset ├── TimeManager.asset └── UnityConnectSettings.asset /CppNativePlugin/.gitignore: -------------------------------------------------------------------------------- 1 | /.vs 2 | /obj 3 | /Debug 4 | /x64 5 | /Release 6 | /DTAR_* 7 | *.sdf 8 | *.user 9 | *.opendb -------------------------------------------------------------------------------- /CppNativePlugin/PlyLoader.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio 14 4 | VisualStudioVersion = 14.0.24720.0 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PlyLoader", "PlyLoader.vcxproj", "{D46D46AE-8384-432B-9A99-205B2117A497}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|x64 = Debug|x64 11 | Debug|x86 = Debug|x86 12 | Release|x64 = Release|x64 13 | Release|x86 = Release|x86 14 | EndGlobalSection 15 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 16 | {D46D46AE-8384-432B-9A99-205B2117A497}.Debug|x64.ActiveCfg = Debug|x64 17 | {D46D46AE-8384-432B-9A99-205B2117A497}.Debug|x64.Build.0 = Debug|x64 18 | {D46D46AE-8384-432B-9A99-205B2117A497}.Debug|x86.ActiveCfg = Debug|Win32 19 | {D46D46AE-8384-432B-9A99-205B2117A497}.Debug|x86.Build.0 = Debug|Win32 20 | {D46D46AE-8384-432B-9A99-205B2117A497}.Release|x64.ActiveCfg = Release|x64 21 | {D46D46AE-8384-432B-9A99-205B2117A497}.Release|x64.Build.0 = Release|x64 22 | {D46D46AE-8384-432B-9A99-205B2117A497}.Release|x86.ActiveCfg = Release|Win32 23 | {D46D46AE-8384-432B-9A99-205B2117A497}.Release|x86.Build.0 = Release|Win32 24 | EndGlobalSection 25 | GlobalSection(SolutionProperties) = preSolution 26 | HideSolutionNode = FALSE 27 | EndGlobalSection 28 | EndGlobal 29 | -------------------------------------------------------------------------------- /CppNativePlugin/PlyLoader.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | Ply 7 | 8 | 9 | 10 | 11 | 12 | 13 | Ply 14 | 15 | 16 | Ply 17 | 18 | 19 | 20 | 21 | {e7d61559-f672-4449-9b1f-617449830707} 22 | 23 | 24 | -------------------------------------------------------------------------------- /CppNativePlugin/PlyLoader/PlyLoader.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include "ml_mesh_type.h" 6 | 7 | using namespace std; 8 | 9 | class PlyFileObject 10 | { 11 | public: 12 | enum MeshElement { 13 | MM_NONE = 0x00000000, 14 | MM_VERTCOORD = 0x00000001, 15 | MM_VERTNORMAL = 0x00000002, 16 | MM_VERTFLAG = 0x00000004, 17 | MM_VERTCOLOR = 0x00000008, 18 | MM_VERTQUALITY = 0x00000010, 19 | MM_VERTMARK = 0x00000020, 20 | MM_VERTFACETOPO = 0x00000040, 21 | MM_VERTCURV = 0x00000080, 22 | MM_VERTCURVDIR = 0x00000100, 23 | MM_VERTRADIUS = 0x00000200, 24 | MM_VERTTEXCOORD = 0x00000400, 25 | MM_VERTNUMBER = 0x00000800, 26 | 27 | MM_FACEVERT = 0x00001000, 28 | MM_FACENORMAL = 0x00002000, 29 | MM_FACEFLAG = 0x00004000, 30 | MM_FACECOLOR = 0x00008000, 31 | MM_FACEQUALITY = 0x00010000, 32 | MM_FACEMARK = 0x00020000, 33 | MM_FACEFACETOPO = 0x00040000, 34 | MM_FACENUMBER = 0x00080000, 35 | MM_FACECURVDIR = 0x00100000, 36 | 37 | MM_WEDGTEXCOORD = 0x00200000, 38 | MM_WEDGNORMAL = 0x00400000, 39 | MM_WEDGCOLOR = 0x00800000, 40 | 41 | // Selection 42 | MM_VERTFLAGSELECT = 0x01000000, 43 | MM_FACEFLAGSELECT = 0x02000000, 44 | 45 | // Per Mesh Stuff.... 46 | MM_CAMERA = 0x08000000, 47 | MM_TRANSFMATRIX = 0x10000000, 48 | MM_COLOR = 0x20000000, 49 | MM_POLYGONAL = 0x40000000, 50 | MM_UNKNOWN = 0x80000000, 51 | 52 | MM_ALL = 0xffffffff 53 | }; 54 | 55 | PlyFileObject(const char* fileName); 56 | vector verts; 57 | vector norms; 58 | vector colors; 59 | vector faces; 60 | vector uvCoords; 61 | string textureName; 62 | CMeshO cm; 63 | 64 | private: 65 | void Enable(int openingFileMask); 66 | void updateDataMask(int openingFileMask); 67 | }; 68 | 69 | extern "C" { 70 | __declspec(dllexport) PlyFileObject* LoadPly(const char* fileName); 71 | 72 | __declspec(dllexport) void UnLoadPly(PlyFileObject* plyFile); 73 | 74 | __declspec(dllexport) float* GetPlyVerts(PlyFileObject* plyFile, unsigned int& count); 75 | 76 | __declspec(dllexport) float* GetPlyNormals(PlyFileObject* plyFile, unsigned int& count); 77 | 78 | __declspec(dllexport) unsigned char* GetPlyColors(PlyFileObject* plyFile, unsigned int& count); 79 | 80 | __declspec(dllexport) unsigned int* GetPlyIndexs(PlyFileObject* plyFile, unsigned int& count); 81 | 82 | __declspec(dllexport) float* GetPlyUvs(PlyFileObject* plyFile, unsigned int& count); 83 | 84 | __declspec(dllexport) const char* GetPlyTextureName(PlyFileObject* plyFile); 85 | }; 86 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/CholmodSupport: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_CHOLMODSUPPORT_MODULE_H 2 | #define EIGEN_CHOLMODSUPPORT_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 CholmodSupport_Module CholmodSupport module 14 | * 15 | * This module provides an interface to the Cholmod library which is part of the suitesparse package. 16 | * It provides the two following main factorization classes: 17 | * - class CholmodSupernodalLLT: a supernodal LLT Cholesky factorization. 18 | * - class CholmodDecomposiiton: a general L(D)LT Cholesky factorization with automatic or explicit runtime selection of the underlying factorization method (supernodal or simplicial). 19 | * 20 | * For the sake of completeness, this module also propose the two following classes: 21 | * - class CholmodSimplicialLLT 22 | * - class CholmodSimplicialLDLT 23 | * Note that these classes does not bring any particular advantage compared to the built-in 24 | * SimplicialLLT and SimplicialLDLT factorization classes. 25 | * 26 | * \code 27 | * #include 28 | * \endcode 29 | * 30 | * In order to use this module, the cholmod headers must be accessible from the include paths, and your binary must be linked to the cholmod library and its dependencies. 31 | * The dependencies depend on how cholmod has been compiled. 32 | * For a cmake based project, you can use our FindCholmod.cmake module to help you in this task. 33 | * 34 | */ 35 | 36 | #include "src/misc/Solve.h" 37 | #include "src/misc/SparseSolve.h" 38 | 39 | #include "src/CholmodSupport/CholmodSupport.h" 40 | 41 | 42 | #include "src/Core/util/ReenableStupidWarnings.h" 43 | 44 | #endif // EIGEN_CHOLMODSUPPORT_MODULE_H 45 | 46 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/Dense: -------------------------------------------------------------------------------- 1 | #include "Core" 2 | #include "LU" 3 | #include "Cholesky" 4 | #include "QR" 5 | #include "SVD" 6 | #include "Geometry" 7 | #include "Eigenvalues" 8 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/Eigen: -------------------------------------------------------------------------------- 1 | #include "Dense" 2 | //#include "Sparse" 3 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/Geometry: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_GEOMETRY_MODULE_H 2 | #define EIGEN_GEOMETRY_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include "SVD" 9 | #include "LU" 10 | #include 11 | 12 | #ifndef M_PI 13 | #define M_PI 3.14159265358979323846 14 | #endif 15 | 16 | /** \defgroup Geometry_Module Geometry module 17 | * 18 | * 19 | * 20 | * This module provides support for: 21 | * - fixed-size homogeneous transformations 22 | * - translation, scaling, 2D and 3D rotations 23 | * - quaternions 24 | * - \ref MatrixBase::cross() "cross product" 25 | * - \ref MatrixBase::unitOrthogonal() "orthognal vector generation" 26 | * - some linear components: parametrized-lines and hyperplanes 27 | * 28 | * \code 29 | * #include 30 | * \endcode 31 | */ 32 | 33 | #include "src/Geometry/OrthoMethods.h" 34 | #include "src/Geometry/EulerAngles.h" 35 | 36 | #if EIGEN2_SUPPORT_STAGE > STAGE20_RESOLVE_API_CONFLICTS 37 | #include "src/Geometry/Homogeneous.h" 38 | #include "src/Geometry/RotationBase.h" 39 | #include "src/Geometry/Rotation2D.h" 40 | #include "src/Geometry/Quaternion.h" 41 | #include "src/Geometry/AngleAxis.h" 42 | #include "src/Geometry/Transform.h" 43 | #include "src/Geometry/Translation.h" 44 | #include "src/Geometry/Scaling.h" 45 | #include "src/Geometry/Hyperplane.h" 46 | #include "src/Geometry/ParametrizedLine.h" 47 | #include "src/Geometry/AlignedBox.h" 48 | #include "src/Geometry/Umeyama.h" 49 | 50 | #if defined EIGEN_VECTORIZE_SSE 51 | #include "src/Geometry/arch/Geometry_SSE.h" 52 | #endif 53 | #endif 54 | 55 | #ifdef EIGEN2_SUPPORT 56 | #include "src/Eigen2Support/Geometry/All.h" 57 | #endif 58 | 59 | #include "src/Core/util/ReenableStupidWarnings.h" 60 | 61 | #endif // EIGEN_GEOMETRY_MODULE_H 62 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 63 | 64 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/IterativeLinearSolvers: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_ITERATIVELINEARSOLVERS_MODULE_H 2 | #define EIGEN_ITERATIVELINEARSOLVERS_MODULE_H 3 | 4 | #include "SparseCore" 5 | #include "OrderingMethods" 6 | 7 | #include "src/Core/util/DisableStupidWarnings.h" 8 | 9 | /** 10 | * \defgroup IterativeLinearSolvers_Module IterativeLinearSolvers module 11 | * 12 | * This module currently provides iterative methods to solve problems of the form \c A \c x = \c b, where \c A is a squared matrix, usually very large and sparse. 13 | * Those solvers are accessible via the following classes: 14 | * - ConjugateGradient for selfadjoint (hermitian) matrices, 15 | * - BiCGSTAB for general square matrices. 16 | * 17 | * These iterative solvers are associated with some preconditioners: 18 | * - IdentityPreconditioner - not really useful 19 | * - DiagonalPreconditioner - also called JAcobi preconditioner, work very well on diagonal dominant matrices. 20 | * - IncompleteILUT - incomplete LU factorization with dual thresholding 21 | * 22 | * Such problems can also be solved using the direct sparse decomposition modules: SparseCholesky, CholmodSupport, UmfPackSupport, SuperLUSupport. 23 | * 24 | * \code 25 | * #include 26 | * \endcode 27 | */ 28 | 29 | #include "src/misc/Solve.h" 30 | #include "src/misc/SparseSolve.h" 31 | 32 | #include "src/IterativeLinearSolvers/IterativeSolverBase.h" 33 | #include "src/IterativeLinearSolvers/BasicPreconditioners.h" 34 | #include "src/IterativeLinearSolvers/ConjugateGradient.h" 35 | #include "src/IterativeLinearSolvers/BiCGSTAB.h" 36 | #include "src/IterativeLinearSolvers/IncompleteLUT.h" 37 | 38 | #include "src/Core/util/ReenableStupidWarnings.h" 39 | 40 | #endif // EIGEN_ITERATIVELINEARSOLVERS_MODULE_H 41 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/OrderingMethods: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_ORDERINGMETHODS_MODULE_H 2 | #define EIGEN_ORDERINGMETHODS_MODULE_H 3 | 4 | #include "SparseCore" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** 9 | * \defgroup OrderingMethods_Module OrderingMethods module 10 | * 11 | * This module is currently for internal use only 12 | * 13 | * It defines various built-in and external ordering methods for sparse matrices. 14 | * They are typically used to reduce the number of elements during 15 | * the sparse matrix decomposition (LLT, LU, QR). 16 | * Precisely, in a preprocessing step, a permutation matrix P is computed using 17 | * those ordering methods and applied to the columns of the matrix. 18 | * Using for instance the sparse Cholesky decomposition, it is expected that 19 | * the nonzeros elements in LLT(A*P) will be much smaller than that in LLT(A). 20 | * 21 | * 22 | * Usage : 23 | * \code 24 | * #include 25 | * \endcode 26 | * 27 | * A simple usage is as a template parameter in the sparse decomposition classes : 28 | * 29 | * \code 30 | * SparseLU > solver; 31 | * \endcode 32 | * 33 | * \code 34 | * SparseQR > solver; 35 | * \endcode 36 | * 37 | * It is possible as well to call directly a particular ordering method for your own purpose, 38 | * \code 39 | * AMDOrdering ordering; 40 | * PermutationMatrix perm; 41 | * SparseMatrix A; 42 | * //Fill the matrix ... 43 | * 44 | * ordering(A, perm); // Call AMD 45 | * \endcode 46 | * 47 | * \note Some of these methods (like AMD or METIS), need the sparsity pattern 48 | * of the input matrix to be symmetric. When the matrix is structurally unsymmetric, 49 | * Eigen computes internally the pattern of \f$A^T*A\f$ before calling the method. 50 | * If your matrix is already symmetric (at leat in structure), you can avoid that 51 | * by calling the method with a SelfAdjointView type. 52 | * 53 | * \code 54 | * // Call the ordering on the pattern of the lower triangular matrix A 55 | * ordering(A.selfadjointView(), perm); 56 | * \endcode 57 | */ 58 | 59 | #ifndef EIGEN_MPL2_ONLY 60 | #include "src/OrderingMethods/Amd.h" 61 | #endif 62 | 63 | #include "src/OrderingMethods/Ordering.h" 64 | #include "src/Core/util/ReenableStupidWarnings.h" 65 | 66 | #endif // EIGEN_ORDERINGMETHODS_MODULE_H 67 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/PaStiXSupport: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_PASTIXSUPPORT_MODULE_H 2 | #define EIGEN_PASTIXSUPPORT_MODULE_H 3 | 4 | #include "SparseCore" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include 9 | extern "C" { 10 | #include 11 | #include 12 | } 13 | 14 | #ifdef complex 15 | #undef complex 16 | #endif 17 | 18 | /** \ingroup Support_modules 19 | * \defgroup PaStiXSupport_Module PaStiXSupport module 20 | * 21 | * This module provides an interface to the PaSTiX library. 22 | * PaSTiX is a general \b supernodal, \b parallel and \b opensource sparse solver. 23 | * It provides the two following main factorization classes: 24 | * - class PastixLLT : a supernodal, parallel LLt Cholesky factorization. 25 | * - class PastixLDLT: a supernodal, parallel LDLt Cholesky factorization. 26 | * - class PastixLU : a supernodal, parallel LU factorization (optimized for a symmetric pattern). 27 | * 28 | * \code 29 | * #include 30 | * \endcode 31 | * 32 | * In order to use this module, the PaSTiX headers must be accessible from the include paths, and your binary must be linked to the PaSTiX library and its dependencies. 33 | * The dependencies depend on how PaSTiX has been compiled. 34 | * For a cmake based project, you can use our FindPaSTiX.cmake module to help you in this task. 35 | * 36 | */ 37 | 38 | #include "src/misc/Solve.h" 39 | #include "src/misc/SparseSolve.h" 40 | 41 | #include "src/PaStiXSupport/PaStiXSupport.h" 42 | 43 | 44 | #include "src/Core/util/ReenableStupidWarnings.h" 45 | 46 | #endif // EIGEN_PASTIXSUPPORT_MODULE_H 47 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/SparseCholesky: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008-2013 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_SPARSECHOLESKY_MODULE_H 11 | #define EIGEN_SPARSECHOLESKY_MODULE_H 12 | 13 | #include "SparseCore" 14 | #include "OrderingMethods" 15 | 16 | #include "src/Core/util/DisableStupidWarnings.h" 17 | 18 | /** 19 | * \defgroup SparseCholesky_Module SparseCholesky module 20 | * 21 | * This module currently provides two variants of the direct sparse Cholesky decomposition for selfadjoint (hermitian) matrices. 22 | * Those decompositions are accessible via the following classes: 23 | * - SimplicialLLt, 24 | * - SimplicialLDLt 25 | * 26 | * Such problems can also be solved using the ConjugateGradient solver from the IterativeLinearSolvers module. 27 | * 28 | * \code 29 | * #include 30 | * \endcode 31 | */ 32 | 33 | #ifdef EIGEN_MPL2_ONLY 34 | #error The SparseCholesky module has nothing to offer in MPL2 only mode 35 | #endif 36 | 37 | #include "src/misc/Solve.h" 38 | #include "src/misc/SparseSolve.h" 39 | #include "src/SparseCholesky/SimplicialCholesky.h" 40 | 41 | #ifndef EIGEN_MPL2_ONLY 42 | #include "src/SparseCholesky/SimplicialCholesky_impl.h" 43 | #endif 44 | 45 | #include "src/Core/util/ReenableStupidWarnings.h" 46 | 47 | #endif // EIGEN_SPARSECHOLESKY_MODULE_H 48 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/SparseCore: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_SPARSECORE_MODULE_H 2 | #define EIGEN_SPARSECORE_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | /** 15 | * \defgroup SparseCore_Module SparseCore module 16 | * 17 | * This module provides a sparse matrix representation, and basic associatd matrix manipulations 18 | * and operations. 19 | * 20 | * See the \ref TutorialSparse "Sparse tutorial" 21 | * 22 | * \code 23 | * #include 24 | * \endcode 25 | * 26 | * This module depends on: Core. 27 | */ 28 | 29 | namespace Eigen { 30 | 31 | /** The type used to identify a general sparse storage. */ 32 | struct Sparse {}; 33 | 34 | } 35 | 36 | #include "src/SparseCore/SparseUtil.h" 37 | #include "src/SparseCore/SparseMatrixBase.h" 38 | #include "src/SparseCore/CompressedStorage.h" 39 | #include "src/SparseCore/AmbiVector.h" 40 | #include "src/SparseCore/SparseMatrix.h" 41 | #include "src/SparseCore/MappedSparseMatrix.h" 42 | #include "src/SparseCore/SparseVector.h" 43 | #include "src/SparseCore/SparseBlock.h" 44 | #include "src/SparseCore/SparseTranspose.h" 45 | #include "src/SparseCore/SparseCwiseUnaryOp.h" 46 | #include "src/SparseCore/SparseCwiseBinaryOp.h" 47 | #include "src/SparseCore/SparseDot.h" 48 | #include "src/SparseCore/SparsePermutation.h" 49 | #include "src/SparseCore/SparseRedux.h" 50 | #include "src/SparseCore/SparseFuzzy.h" 51 | #include "src/SparseCore/ConservativeSparseSparseProduct.h" 52 | #include "src/SparseCore/SparseSparseProductWithPruning.h" 53 | #include "src/SparseCore/SparseProduct.h" 54 | #include "src/SparseCore/SparseDenseProduct.h" 55 | #include "src/SparseCore/SparseDiagonalProduct.h" 56 | #include "src/SparseCore/SparseTriangularView.h" 57 | #include "src/SparseCore/SparseSelfAdjointView.h" 58 | #include "src/SparseCore/TriangularSolver.h" 59 | #include "src/SparseCore/SparseView.h" 60 | 61 | #include "src/Core/util/ReenableStupidWarnings.h" 62 | 63 | #endif // EIGEN_SPARSECORE_MODULE_H 64 | 65 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/SparseLU: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2012 Désiré Nuentsa-Wakam 5 | // Copyright (C) 2012 Gael Guennebaud 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_SPARSELU_MODULE_H 12 | #define EIGEN_SPARSELU_MODULE_H 13 | 14 | #include "SparseCore" 15 | 16 | /** 17 | * \defgroup SparseLU_Module SparseLU module 18 | * This module defines a supernodal factorization of general sparse matrices. 19 | * The code is fully optimized for supernode-panel updates with specialized kernels. 20 | * Please, see the documentation of the SparseLU class for more details. 21 | */ 22 | 23 | #include "src/misc/Solve.h" 24 | #include "src/misc/SparseSolve.h" 25 | 26 | // Ordering interface 27 | #include "OrderingMethods" 28 | 29 | #include "src/SparseLU/SparseLU_gemm_kernel.h" 30 | 31 | #include "src/SparseLU/SparseLU_Structs.h" 32 | #include "src/SparseLU/SparseLU_SupernodalMatrix.h" 33 | #include "src/SparseLU/SparseLUImpl.h" 34 | #include "src/SparseCore/SparseColEtree.h" 35 | #include "src/SparseLU/SparseLU_Memory.h" 36 | #include "src/SparseLU/SparseLU_heap_relax_snode.h" 37 | #include "src/SparseLU/SparseLU_relax_snode.h" 38 | #include "src/SparseLU/SparseLU_pivotL.h" 39 | #include "src/SparseLU/SparseLU_panel_dfs.h" 40 | #include "src/SparseLU/SparseLU_kernel_bmod.h" 41 | #include "src/SparseLU/SparseLU_panel_bmod.h" 42 | #include "src/SparseLU/SparseLU_column_dfs.h" 43 | #include "src/SparseLU/SparseLU_column_bmod.h" 44 | #include "src/SparseLU/SparseLU_copy_to_ucol.h" 45 | #include "src/SparseLU/SparseLU_pruneL.h" 46 | #include "src/SparseLU/SparseLU_Utils.h" 47 | #include "src/SparseLU/SparseLU.h" 48 | 49 | #endif // EIGEN_SPARSELU_MODULE_H 50 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/SuperLUSupport: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_SUPERLUSUPPORT_MODULE_H 2 | #define EIGEN_SUPERLUSUPPORT_MODULE_H 3 | 4 | #include "SparseCore" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #ifdef EMPTY 9 | #define EIGEN_EMPTY_WAS_ALREADY_DEFINED 10 | #endif 11 | 12 | typedef int int_t; 13 | #include 14 | #include 15 | #include 16 | 17 | // slu_util.h defines a preprocessor token named EMPTY which is really polluting, 18 | // so we remove it in favor of a SUPERLU_EMPTY token. 19 | // If EMPTY was already defined then we don't undef it. 20 | 21 | #if defined(EIGEN_EMPTY_WAS_ALREADY_DEFINED) 22 | # undef EIGEN_EMPTY_WAS_ALREADY_DEFINED 23 | #elif defined(EMPTY) 24 | # undef EMPTY 25 | #endif 26 | 27 | #define SUPERLU_EMPTY (-1) 28 | 29 | namespace Eigen { struct SluMatrix; } 30 | 31 | /** \ingroup Support_modules 32 | * \defgroup SuperLUSupport_Module SuperLUSupport module 33 | * 34 | * This module provides an interface to the SuperLU library. 35 | * It provides the following factorization class: 36 | * - class SuperLU: a supernodal sequential LU factorization. 37 | * - class SuperILU: a supernodal sequential incomplete LU factorization (to be used as a preconditioner for iterative methods). 38 | * 39 | * \warning When including this module, you have to use SUPERLU_EMPTY instead of EMPTY which is no longer defined because it is too polluting. 40 | * 41 | * \code 42 | * #include 43 | * \endcode 44 | * 45 | * In order to use this module, the superlu headers must be accessible from the include paths, and your binary must be linked to the superlu library and its dependencies. 46 | * The dependencies depend on how superlu has been compiled. 47 | * For a cmake based project, you can use our FindSuperLU.cmake module to help you in this task. 48 | * 49 | */ 50 | 51 | #include "src/misc/Solve.h" 52 | #include "src/misc/SparseSolve.h" 53 | 54 | #include "src/SuperLUSupport/SuperLUSupport.h" 55 | 56 | 57 | #include "src/Core/util/ReenableStupidWarnings.h" 58 | 59 | #endif // EIGEN_SUPERLUSUPPORT_MODULE_H 60 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/src/Core/CoreIterators.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008-2010 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_COREITERATORS_H 11 | #define EIGEN_COREITERATORS_H 12 | 13 | namespace Eigen { 14 | 15 | /* This file contains the respective InnerIterator definition of the expressions defined in Eigen/Core 16 | */ 17 | 18 | /** \ingroup SparseCore_Module 19 | * \class InnerIterator 20 | * \brief An InnerIterator allows to loop over the element of a sparse (or dense) matrix or expression 21 | * 22 | * todo 23 | */ 24 | 25 | // generic version for dense matrix and expressions 26 | template class DenseBase::InnerIterator 27 | { 28 | protected: 29 | typedef typename Derived::Scalar Scalar; 30 | typedef typename Derived::Index Index; 31 | 32 | enum { IsRowMajor = (Derived::Flags&RowMajorBit)==RowMajorBit }; 33 | public: 34 | EIGEN_STRONG_INLINE InnerIterator(const Derived& expr, Index outer) 35 | : m_expression(expr), m_inner(0), m_outer(outer), m_end(expr.innerSize()) 36 | {} 37 | 38 | EIGEN_STRONG_INLINE Scalar value() const 39 | { 40 | return (IsRowMajor) ? m_expression.coeff(m_outer, m_inner) 41 | : m_expression.coeff(m_inner, m_outer); 42 | } 43 | 44 | EIGEN_STRONG_INLINE InnerIterator& operator++() { m_inner++; return *this; } 45 | 46 | EIGEN_STRONG_INLINE Index index() const { return m_inner; } 47 | inline Index row() const { return IsRowMajor ? m_outer : index(); } 48 | inline Index col() const { return IsRowMajor ? index() : m_outer; } 49 | 50 | EIGEN_STRONG_INLINE operator bool() const { return m_inner < m_end && m_inner>=0; } 51 | 52 | protected: 53 | const Derived& m_expression; 54 | Index m_inner; 55 | const Index m_outer; 56 | const Index m_end; 57 | }; 58 | 59 | } // end namespace Eigen 60 | 61 | #endif // EIGEN_COREITERATORS_H 62 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/src/Core/arch/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | ADD_SUBDIRECTORY(SSE) 2 | ADD_SUBDIRECTORY(AltiVec) 3 | ADD_SUBDIRECTORY(NEON) 4 | ADD_SUBDIRECTORY(Default) 5 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/src/Core/arch/Default/Settings.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008-2010 Gael Guennebaud 5 | // Copyright (C) 2006-2008 Benoit Jacob 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 | 12 | /* All the parameters defined in this file can be specialized in the 13 | * architecture specific files, and/or by the user. 14 | * More to come... */ 15 | 16 | #ifndef EIGEN_DEFAULT_SETTINGS_H 17 | #define EIGEN_DEFAULT_SETTINGS_H 18 | 19 | /** Defines the maximal loop size to enable meta unrolling of loops. 20 | * Note that the value here is expressed in Eigen's own notion of "number of FLOPS", 21 | * it does not correspond to the number of iterations or the number of instructions 22 | */ 23 | #ifndef EIGEN_UNROLLING_LIMIT 24 | #define EIGEN_UNROLLING_LIMIT 100 25 | #endif 26 | 27 | /** Defines the threshold between a "small" and a "large" matrix. 28 | * This threshold is mainly used to select the proper product implementation. 29 | */ 30 | #ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 31 | #define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8 32 | #endif 33 | 34 | /** Defines the maximal width of the blocks used in the triangular product and solver 35 | * for vectors (level 2 blas xTRMV and xTRSV). The default is 8. 36 | */ 37 | #ifndef EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH 38 | #define EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH 8 39 | #endif 40 | 41 | 42 | /** Defines the default number of registers available for that architecture. 43 | * Currently it must be 8 or 16. Other values will fail. 44 | */ 45 | #ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 46 | #define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 8 47 | #endif 48 | 49 | #endif // EIGEN_DEFAULT_SETTINGS_H 50 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/src/Core/util/DisableStupidWarnings.h: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_WARNINGS_DISABLED 2 | #define EIGEN_WARNINGS_DISABLED 3 | 4 | #ifdef _MSC_VER 5 | // 4100 - unreferenced formal parameter (occurred e.g. in aligned_allocator::destroy(pointer p)) 6 | // 4101 - unreferenced local variable 7 | // 4127 - conditional expression is constant 8 | // 4181 - qualifier applied to reference type ignored 9 | // 4211 - nonstandard extension used : redefined extern to static 10 | // 4244 - 'argument' : conversion from 'type1' to 'type2', possible loss of data 11 | // 4273 - QtAlignedMalloc, inconsistent DLL linkage 12 | // 4324 - structure was padded due to declspec(align()) 13 | // 4512 - assignment operator could not be generated 14 | // 4522 - 'class' : multiple assignment operators specified 15 | // 4700 - uninitialized local variable 'xyz' used 16 | // 4717 - 'function' : recursive on all control paths, function will cause runtime stack overflow 17 | #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS 18 | #pragma warning( push ) 19 | #endif 20 | #pragma warning( disable : 4100 4101 4127 4181 4211 4244 4273 4324 4512 4522 4700 4717 ) 21 | #elif defined __INTEL_COMPILER 22 | // 2196 - routine is both "inline" and "noinline" ("noinline" assumed) 23 | // ICC 12 generates this warning even without any inline keyword, when defining class methods 'inline' i.e. inside of class body 24 | // typedef that may be a reference type. 25 | // 279 - controlling expression is constant 26 | // ICC 12 generates this warning on assert(constant_expression_depending_on_template_params) and frankly this is a legitimate use case. 27 | #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS 28 | #pragma warning push 29 | #endif 30 | #pragma warning disable 2196 279 31 | #elif defined __clang__ 32 | // -Wconstant-logical-operand - warning: use of logical && with constant operand; switch to bitwise & or remove constant 33 | // this is really a stupid warning as it warns on compile-time expressions involving enums 34 | #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS 35 | #pragma clang diagnostic push 36 | #endif 37 | #pragma clang diagnostic ignored "-Wconstant-logical-operand" 38 | #endif 39 | 40 | #endif // not EIGEN_WARNINGS_DISABLED 41 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | #endif 12 | #endif 13 | 14 | #endif // EIGEN_WARNINGS_DISABLED 15 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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) -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/src/Eigen2Support/Lazy.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008 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 EIGEN_LAZY_H 11 | #define EIGEN_LAZY_H 12 | 13 | namespace Eigen { 14 | 15 | /** \deprecated it is only used by lazy() which is deprecated 16 | * 17 | * \returns an expression of *this with added flags 18 | * 19 | * Example: \include MatrixBase_marked.cpp 20 | * Output: \verbinclude MatrixBase_marked.out 21 | * 22 | * \sa class Flagged, extract(), part() 23 | */ 24 | template 25 | template 26 | inline const Flagged 27 | MatrixBase::marked() const 28 | { 29 | return derived(); 30 | } 31 | 32 | /** \deprecated use MatrixBase::noalias() 33 | * 34 | * \returns an expression of *this with the EvalBeforeAssigningBit flag removed. 35 | * 36 | * Example: \include MatrixBase_lazy.cpp 37 | * Output: \verbinclude MatrixBase_lazy.out 38 | * 39 | * \sa class Flagged, marked() 40 | */ 41 | template 42 | inline const Flagged 43 | MatrixBase::lazy() const 44 | { 45 | return derived(); 46 | } 47 | 48 | 49 | /** \internal 50 | * Overloaded to perform an efficient C += (A*B).lazy() */ 51 | template 52 | template 53 | Derived& MatrixBase::operator+=(const Flagged, 0, 54 | EvalBeforeAssigningBit>& other) 55 | { 56 | other._expression().derived().addTo(derived()); return derived(); 57 | } 58 | 59 | /** \internal 60 | * Overloaded to perform an efficient C -= (A*B).lazy() */ 61 | template 62 | template 63 | Derived& MatrixBase::operator-=(const Flagged, 0, 64 | EvalBeforeAssigningBit>& other) 65 | { 66 | other._expression().derived().subTo(derived()); return derived(); 67 | } 68 | 69 | } // end namespace Eigen 70 | 71 | #endif // EIGEN_LAZY_H 72 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/src/Eigen2Support/Memory.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_MEMORY_H 11 | #define EIGEN2_MEMORY_H 12 | 13 | namespace Eigen { 14 | 15 | inline void* ei_aligned_malloc(size_t size) { return internal::aligned_malloc(size); } 16 | inline void ei_aligned_free(void *ptr) { internal::aligned_free(ptr); } 17 | inline void* ei_aligned_realloc(void *ptr, size_t new_size, size_t old_size) { return internal::aligned_realloc(ptr, new_size, old_size); } 18 | inline void* ei_handmade_aligned_malloc(size_t size) { return internal::handmade_aligned_malloc(size); } 19 | inline void ei_handmade_aligned_free(void *ptr) { internal::handmade_aligned_free(ptr); } 20 | 21 | template inline void* ei_conditional_aligned_malloc(size_t size) 22 | { 23 | return internal::conditional_aligned_malloc(size); 24 | } 25 | template inline void ei_conditional_aligned_free(void *ptr) 26 | { 27 | internal::conditional_aligned_free(ptr); 28 | } 29 | template inline void* ei_conditional_aligned_realloc(void* ptr, size_t new_size, size_t old_size) 30 | { 31 | return internal::conditional_aligned_realloc(ptr, new_size, old_size); 32 | } 33 | 34 | template inline T* ei_aligned_new(size_t size) 35 | { 36 | return internal::aligned_new(size); 37 | } 38 | template inline void ei_aligned_delete(T *ptr, size_t size) 39 | { 40 | return internal::aligned_delete(ptr, size); 41 | } 42 | 43 | } // end namespace Eigen 44 | 45 | #endif // EIGEN2_MACROS_H 46 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/src/Eigen2Support/QR.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 | // Copyright (C) 2011 Benoit Jacob 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 EIGEN2_QR_H 12 | #define EIGEN2_QR_H 13 | 14 | namespace Eigen { 15 | 16 | template 17 | class QR : public HouseholderQR 18 | { 19 | public: 20 | 21 | typedef HouseholderQR Base; 22 | typedef Block MatrixRBlockType; 23 | 24 | QR() : Base() {} 25 | 26 | template 27 | explicit QR(const T& t) : Base(t) {} 28 | 29 | template 30 | bool solve(const MatrixBase& b, ResultType *result) const 31 | { 32 | *result = static_cast(this)->solve(b); 33 | return true; 34 | } 35 | 36 | MatrixType matrixQ(void) const { 37 | MatrixType ret = MatrixType::Identity(this->rows(), this->cols()); 38 | ret = this->householderQ() * ret; 39 | return ret; 40 | } 41 | 42 | bool isFullRank() const { 43 | return true; 44 | } 45 | 46 | const TriangularView 47 | matrixR(void) const 48 | { 49 | int cols = this->cols(); 50 | return MatrixRBlockType(this->matrixQR(), 0, 0, cols, cols).template triangularView(); 51 | } 52 | }; 53 | 54 | /** \return the QR decomposition of \c *this. 55 | * 56 | * \sa class QR 57 | */ 58 | template 59 | const QR::PlainObject> 60 | MatrixBase::qr() const 61 | { 62 | return QR(eval()); 63 | } 64 | 65 | } // end namespace Eigen 66 | 67 | #endif // EIGEN2_QR_H 68 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/src/Eigen2Support/TriangularSolver.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2010 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_TRIANGULAR_SOLVER2_H 11 | #define EIGEN_TRIANGULAR_SOLVER2_H 12 | 13 | namespace Eigen { 14 | 15 | const unsigned int UnitDiagBit = UnitDiag; 16 | const unsigned int SelfAdjointBit = SelfAdjoint; 17 | const unsigned int UpperTriangularBit = Upper; 18 | const unsigned int LowerTriangularBit = Lower; 19 | 20 | const unsigned int UpperTriangular = Upper; 21 | const unsigned int LowerTriangular = Lower; 22 | const unsigned int UnitUpperTriangular = UnitUpper; 23 | const unsigned int UnitLowerTriangular = UnitLower; 24 | 25 | template 26 | template 27 | typename ExpressionType::PlainObject 28 | Flagged::solveTriangular(const MatrixBase& other) const 29 | { 30 | return m_matrix.template triangularView().solve(other.derived()); 31 | } 32 | 33 | template 34 | template 35 | void Flagged::solveTriangularInPlace(const MatrixBase& other) const 36 | { 37 | m_matrix.template triangularView().solveInPlace(other.derived()); 38 | } 39 | 40 | } // end namespace Eigen 41 | 42 | #endif // EIGEN_TRIANGULAR_SOLVER2_H 43 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/src/SparseCore/SparseRedux.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_SPARSEREDUX_H 11 | #define EIGEN_SPARSEREDUX_H 12 | 13 | namespace Eigen { 14 | 15 | template 16 | typename internal::traits::Scalar 17 | SparseMatrixBase::sum() const 18 | { 19 | eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix"); 20 | Scalar res(0); 21 | for (Index j=0; j 28 | typename internal::traits >::Scalar 29 | SparseMatrix<_Scalar,_Options,_Index>::sum() const 30 | { 31 | eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix"); 32 | return Matrix::Map(&m_data.value(0), m_data.size()).sum(); 33 | } 34 | 35 | template 36 | typename internal::traits >::Scalar 37 | SparseVector<_Scalar,_Options,_Index>::sum() const 38 | { 39 | eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix"); 40 | return Matrix::Map(&m_data.value(0), m_data.size()).sum(); 41 | } 42 | 43 | } // end namespace Eigen 44 | 45 | #endif // EIGEN_SPARSEREDUX_H 46 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/src/SparseLU/SparseLU_Utils.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2012 Désiré Nuentsa-Wakam 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 | 11 | #ifndef EIGEN_SPARSELU_UTILS_H 12 | #define EIGEN_SPARSELU_UTILS_H 13 | 14 | namespace Eigen { 15 | namespace internal { 16 | 17 | /** 18 | * \brief Count Nonzero elements in the factors 19 | */ 20 | template 21 | void SparseLUImpl::countnz(const Index n, Index& nnzL, Index& nnzU, GlobalLU_t& glu) 22 | { 23 | nnzL = 0; 24 | nnzU = (glu.xusub)(n); 25 | Index nsuper = (glu.supno)(n); 26 | Index jlen; 27 | Index i, j, fsupc; 28 | if (n <= 0 ) return; 29 | // For each supernode 30 | for (i = 0; i <= nsuper; i++) 31 | { 32 | fsupc = glu.xsup(i); 33 | jlen = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); 34 | 35 | for (j = fsupc; j < glu.xsup(i+1); j++) 36 | { 37 | nnzL += jlen; 38 | nnzU += j - fsupc + 1; 39 | jlen--; 40 | } 41 | } 42 | } 43 | 44 | /** 45 | * \brief Fix up the data storage lsub for L-subscripts. 46 | * 47 | * It removes the subscripts sets for structural pruning, 48 | * and applies permutation to the remaining subscripts 49 | * 50 | */ 51 | template 52 | void SparseLUImpl::fixupL(const Index n, const IndexVector& perm_r, GlobalLU_t& glu) 53 | { 54 | Index fsupc, i, j, k, jstart; 55 | 56 | Index nextl = 0; 57 | Index nsuper = (glu.supno)(n); 58 | 59 | // For each supernode 60 | for (i = 0; i <= nsuper; i++) 61 | { 62 | fsupc = glu.xsup(i); 63 | jstart = glu.xlsub(fsupc); 64 | glu.xlsub(fsupc) = nextl; 65 | for (j = jstart; j < glu.xlsub(fsupc + 1); j++) 66 | { 67 | glu.lsub(nextl) = perm_r(glu.lsub(j)); // Now indexed into P*A 68 | nextl++; 69 | } 70 | for (k = fsupc+1; k < glu.xsup(i+1); k++) 71 | glu.xlsub(k) = nextl; // other columns in supernode i 72 | } 73 | 74 | glu.xlsub(n) = nextl; 75 | } 76 | 77 | } // end namespace internal 78 | 79 | } // end namespace Eigen 80 | #endif // EIGEN_SPARSELU_UTILS_H 81 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/src/plugins/CommonCwiseBinaryOps.h: -------------------------------------------------------------------------------- 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 | // Copyright (C) 2006-2008 Benoit Jacob 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 | // This file is a base class plugin containing common coefficient wise functions. 12 | 13 | /** \returns an expression of the difference of \c *this and \a other 14 | * 15 | * \note If you want to substract a given scalar from all coefficients, see Cwise::operator-(). 16 | * 17 | * \sa class CwiseBinaryOp, operator-=() 18 | */ 19 | EIGEN_MAKE_CWISE_BINARY_OP(operator-,internal::scalar_difference_op) 20 | 21 | /** \returns an expression of the sum of \c *this and \a other 22 | * 23 | * \note If you want to add a given scalar to all coefficients, see Cwise::operator+(). 24 | * 25 | * \sa class CwiseBinaryOp, operator+=() 26 | */ 27 | EIGEN_MAKE_CWISE_BINARY_OP(operator+,internal::scalar_sum_op) 28 | 29 | /** \returns an expression of a custom coefficient-wise operator \a func of *this and \a other 30 | * 31 | * The template parameter \a CustomBinaryOp is the type of the functor 32 | * of the custom operator (see class CwiseBinaryOp for an example) 33 | * 34 | * Here is an example illustrating the use of custom functors: 35 | * \include class_CwiseBinaryOp.cpp 36 | * Output: \verbinclude class_CwiseBinaryOp.out 37 | * 38 | * \sa class CwiseBinaryOp, operator+(), operator-(), cwiseProduct() 39 | */ 40 | template 41 | EIGEN_STRONG_INLINE const CwiseBinaryOp 42 | binaryExpr(const EIGEN_CURRENT_STORAGE_BASE_CLASS &other, const CustomBinaryOp& func = CustomBinaryOp()) const 43 | { 44 | return CwiseBinaryOp(derived(), other.derived(), func); 45 | } 46 | 47 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/Eigen/src/plugins/MatrixCwiseUnaryOps.h: -------------------------------------------------------------------------------- 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 | // Copyright (C) 2006-2008 Benoit Jacob 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 | // This file is a base class plugin containing matrix specifics coefficient wise functions. 12 | 13 | /** \returns an expression of the coefficient-wise absolute value of \c *this 14 | * 15 | * Example: \include MatrixBase_cwiseAbs.cpp 16 | * Output: \verbinclude MatrixBase_cwiseAbs.out 17 | * 18 | * \sa cwiseAbs2() 19 | */ 20 | EIGEN_STRONG_INLINE const CwiseUnaryOp, const Derived> 21 | cwiseAbs() const { return derived(); } 22 | 23 | /** \returns an expression of the coefficient-wise squared absolute value of \c *this 24 | * 25 | * Example: \include MatrixBase_cwiseAbs2.cpp 26 | * Output: \verbinclude MatrixBase_cwiseAbs2.out 27 | * 28 | * \sa cwiseAbs() 29 | */ 30 | EIGEN_STRONG_INLINE const CwiseUnaryOp, const Derived> 31 | cwiseAbs2() const { return derived(); } 32 | 33 | /** \returns an expression of the coefficient-wise square root of *this. 34 | * 35 | * Example: \include MatrixBase_cwiseSqrt.cpp 36 | * Output: \verbinclude MatrixBase_cwiseSqrt.out 37 | * 38 | * \sa cwisePow(), cwiseSquare() 39 | */ 40 | inline const CwiseUnaryOp, const Derived> 41 | cwiseSqrt() const { return derived(); } 42 | 43 | /** \returns an expression of the coefficient-wise inverse of *this. 44 | * 45 | * Example: \include MatrixBase_cwiseInverse.cpp 46 | * Output: \verbinclude MatrixBase_cwiseInverse.out 47 | * 48 | * \sa cwiseProduct() 49 | */ 50 | inline const CwiseUnaryOp, const Derived> 51 | cwiseInverse() const { return derived(); } 52 | 53 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/howto.txt: -------------------------------------------------------------------------------- 1 | Current Eigen Version 3.1.2 (05.11.2012) 2 | Current Eigen Version 3.2.1 (26.02.2014) updated on 14/05/2014 3 | Current Eigen Version 3.2.2 (04.08.2014) updated on 21/10/2014 4 | Current Eigen Version 3.2.5 (16.06.2015) updated on 24/09/2015 5 | 6 | To update the lib: 7 | - download Eigen 8 | - unzip it somewhere 9 | - delete (in the filesystem) the content of the folder eigenlib/Eigen and eigenlib/unsupported 10 | - copy the two folders 'Eigen' and 'unsupported' here 11 | - check the svn status, svn-add the new files and svn-remove the missing ones. 12 | - update this file 13 | - commit everything 14 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/unsupported/Eigen/NumericalDiff: -------------------------------------------------------------------------------- 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_NUMERICALDIFF_MODULE 11 | #define EIGEN_NUMERICALDIFF_MODULE 12 | 13 | #include 14 | 15 | namespace Eigen { 16 | 17 | /** 18 | * \defgroup NumericalDiff_Module Numerical differentiation module 19 | * 20 | * \code 21 | * #include 22 | * \endcode 23 | * 24 | * See http://en.wikipedia.org/wiki/Numerical_differentiation 25 | * 26 | * Warning : this should NOT be confused with automatic differentiation, which 27 | * is a different method and has its own module in Eigen : \ref 28 | * AutoDiff_Module. 29 | * 30 | * Currently only "Forward" and "Central" schemes are implemented. Those 31 | * are basic methods, and there exist some more elaborated way of 32 | * computing such approximates. They are implemented using both 33 | * proprietary and free software, and usually requires linking to an 34 | * external library. It is very easy for you to write a functor 35 | * using such software, and the purpose is quite orthogonal to what we 36 | * want to achieve with Eigen. 37 | * 38 | * This is why we will not provide wrappers for every great numerical 39 | * differentiation software that exist, but should rather stick with those 40 | * basic ones, that still are useful for testing. 41 | * 42 | * Also, the \ref NonLinearOptimization_Module needs this in order to 43 | * provide full features compatibility with the original (c)minpack 44 | * package. 45 | * 46 | */ 47 | } 48 | 49 | //@{ 50 | 51 | #include "src/NumericalDiff/NumericalDiff.h" 52 | 53 | //@} 54 | 55 | 56 | #endif // EIGEN_NUMERICALDIFF_MODULE 57 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/unsupported/Eigen/SparseExtra: -------------------------------------------------------------------------------- 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_SPARSE_EXTRA_MODULE_H 11 | #define EIGEN_SPARSE_EXTRA_MODULE_H 12 | 13 | #include "../../Eigen/Sparse" 14 | 15 | #include "../../Eigen/src/Core/util/DisableStupidWarnings.h" 16 | 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | 25 | #ifdef EIGEN_GOOGLEHASH_SUPPORT 26 | #include 27 | #endif 28 | 29 | /** 30 | * \defgroup SparseExtra_Module SparseExtra module 31 | * 32 | * This module contains some experimental features extending the sparse module. 33 | * 34 | * \code 35 | * #include 36 | * \endcode 37 | */ 38 | 39 | 40 | #include "../../Eigen/src/misc/Solve.h" 41 | #include "../../Eigen/src/misc/SparseSolve.h" 42 | 43 | #include "src/SparseExtra/DynamicSparseMatrix.h" 44 | #include "src/SparseExtra/BlockOfDynamicSparseMatrix.h" 45 | #include "src/SparseExtra/RandomSetter.h" 46 | 47 | #include "src/SparseExtra/MarketIO.h" 48 | 49 | #if !defined(_WIN32) 50 | #include 51 | #include "src/SparseExtra/MatrixMarketIterator.h" 52 | #endif 53 | 54 | #include "../../Eigen/src/Core/util/ReenableStupidWarnings.h" 55 | 56 | #endif // EIGEN_SPARSE_EXTRA_MODULE_H 57 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/unsupported/Eigen/src/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | ADD_SUBDIRECTORY(AutoDiff) 2 | ADD_SUBDIRECTORY(BVH) 3 | ADD_SUBDIRECTORY(FFT) 4 | ADD_SUBDIRECTORY(IterativeSolvers) 5 | ADD_SUBDIRECTORY(KroneckerProduct) 6 | ADD_SUBDIRECTORY(LevenbergMarquardt) 7 | ADD_SUBDIRECTORY(MatrixFunctions) 8 | ADD_SUBDIRECTORY(MoreVectorization) 9 | ADD_SUBDIRECTORY(NonLinearOptimization) 10 | ADD_SUBDIRECTORY(NumericalDiff) 11 | ADD_SUBDIRECTORY(Polynomials) 12 | ADD_SUBDIRECTORY(Skyline) 13 | ADD_SUBDIRECTORY(SparseExtra) 14 | ADD_SUBDIRECTORY(Splines) 15 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/unsupported/Eigen/src/LevenbergMarquardt/CopyrightMINPACK.txt: -------------------------------------------------------------------------------- 1 | Minpack Copyright Notice (1999) University of Chicago. All rights reserved 2 | 3 | Redistribution and use in source and binary forms, with or 4 | without modification, are permitted provided that the 5 | following conditions are met: 6 | 7 | 1. Redistributions of source code must retain the above 8 | copyright notice, this list of conditions and the following 9 | disclaimer. 10 | 11 | 2. Redistributions in binary form must reproduce the above 12 | copyright notice, this list of conditions and the following 13 | disclaimer in the documentation and/or other materials 14 | provided with the distribution. 15 | 16 | 3. The end-user documentation included with the 17 | redistribution, if any, must include the following 18 | acknowledgment: 19 | 20 | "This product includes software developed by the 21 | University of Chicago, as Operator of Argonne National 22 | Laboratory. 23 | 24 | Alternately, this acknowledgment may appear in the software 25 | itself, if and wherever such third-party acknowledgments 26 | normally appear. 27 | 28 | 4. WARRANTY DISCLAIMER. THE SOFTWARE IS SUPPLIED "AS IS" 29 | WITHOUT WARRANTY OF ANY KIND. THE COPYRIGHT HOLDER, THE 30 | UNITED STATES, THE UNITED STATES DEPARTMENT OF ENERGY, AND 31 | THEIR EMPLOYEES: (1) DISCLAIM ANY WARRANTIES, EXPRESS OR 32 | IMPLIED, INCLUDING BUT NOT LIMITED TO ANY IMPLIED WARRANTIES 33 | OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE 34 | OR NON-INFRINGEMENT, (2) DO NOT ASSUME ANY LEGAL LIABILITY 35 | OR RESPONSIBILITY FOR THE ACCURACY, COMPLETENESS, OR 36 | USEFULNESS OF THE SOFTWARE, (3) DO NOT REPRESENT THAT USE OF 37 | THE SOFTWARE WOULD NOT INFRINGE PRIVATELY OWNED RIGHTS, (4) 38 | DO NOT WARRANT THAT THE SOFTWARE WILL FUNCTION 39 | UNINTERRUPTED, THAT IT IS ERROR-FREE OR THAT ANY ERRORS WILL 40 | BE CORRECTED. 41 | 42 | 5. LIMITATION OF LIABILITY. IN NO EVENT WILL THE COPYRIGHT 43 | HOLDER, THE UNITED STATES, THE UNITED STATES DEPARTMENT OF 44 | ENERGY, OR THEIR EMPLOYEES: BE LIABLE FOR ANY INDIRECT, 45 | INCIDENTAL, CONSEQUENTIAL, SPECIAL OR PUNITIVE DAMAGES OF 46 | ANY KIND OR NATURE, INCLUDING BUT NOT LIMITED TO LOSS OF 47 | PROFITS OR LOSS OF DATA, FOR ANY REASON WHATSOEVER, WHETHER 48 | SUCH LIABILITY IS ASSERTED ON THE BASIS OF CONTRACT, TORT 49 | (INCLUDING NEGLIGENCE OR STRICT LIABILITY), OR OTHERWISE, 50 | EVEN IF ANY OF SAID PARTIES HAS BEEN WARNED OF THE 51 | POSSIBILITY OF SUCH LOSS OR DAMAGES. 52 | 53 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/unsupported/Eigen/src/NonLinearOptimization/chkder.h: -------------------------------------------------------------------------------- 1 | #define chkder_log10e 0.43429448190325182765 2 | #define chkder_factor 100. 3 | 4 | namespace Eigen { 5 | 6 | namespace internal { 7 | 8 | template 9 | void chkder( 10 | const Matrix< Scalar, Dynamic, 1 > &x, 11 | const Matrix< Scalar, Dynamic, 1 > &fvec, 12 | const Matrix< Scalar, Dynamic, Dynamic > &fjac, 13 | Matrix< Scalar, Dynamic, 1 > &xp, 14 | const Matrix< Scalar, Dynamic, 1 > &fvecp, 15 | int mode, 16 | Matrix< Scalar, Dynamic, 1 > &err 17 | ) 18 | { 19 | using std::sqrt; 20 | using std::abs; 21 | using std::log; 22 | 23 | typedef DenseIndex Index; 24 | 25 | const Scalar eps = sqrt(NumTraits::epsilon()); 26 | const Scalar epsf = chkder_factor * NumTraits::epsilon(); 27 | const Scalar epslog = chkder_log10e * log(eps); 28 | Scalar temp; 29 | 30 | const Index m = fvec.size(), n = x.size(); 31 | 32 | if (mode != 2) { 33 | /* mode = 1. */ 34 | xp.resize(n); 35 | for (Index j = 0; j < n; ++j) { 36 | temp = eps * abs(x[j]); 37 | if (temp == 0.) 38 | temp = eps; 39 | xp[j] = x[j] + temp; 40 | } 41 | } 42 | else { 43 | /* mode = 2. */ 44 | err.setZero(m); 45 | for (Index j = 0; j < n; ++j) { 46 | temp = abs(x[j]); 47 | if (temp == 0.) 48 | temp = 1.; 49 | err += temp * fjac.col(j); 50 | } 51 | for (Index i = 0; i < m; ++i) { 52 | temp = 1.; 53 | if (fvec[i] != 0. && fvecp[i] != 0. && abs(fvecp[i] - fvec[i]) >= epsf * abs(fvec[i])) 54 | temp = eps * abs((fvecp[i] - fvec[i]) / eps - err[i]) / (abs(fvec[i]) + abs(fvecp[i])); 55 | err[i] = 1.; 56 | if (temp > NumTraits::epsilon() && temp < eps) 57 | err[i] = (chkder_log10e * log(temp) - epslog) / epslog; 58 | if (temp >= eps) 59 | err[i] = 0.; 60 | } 61 | } 62 | } 63 | 64 | } // end namespace internal 65 | 66 | } // end namespace Eigen 67 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/unsupported/Eigen/src/NonLinearOptimization/covar.h: -------------------------------------------------------------------------------- 1 | namespace Eigen { 2 | 3 | namespace internal { 4 | 5 | template 6 | void covar( 7 | Matrix< Scalar, Dynamic, Dynamic > &r, 8 | const VectorXi &ipvt, 9 | Scalar tol = std::sqrt(NumTraits::epsilon()) ) 10 | { 11 | using std::abs; 12 | typedef DenseIndex Index; 13 | 14 | /* Local variables */ 15 | Index i, j, k, l, ii, jj; 16 | bool sing; 17 | Scalar temp; 18 | 19 | /* Function Body */ 20 | const Index n = r.cols(); 21 | const Scalar tolr = tol * abs(r(0,0)); 22 | Matrix< Scalar, Dynamic, 1 > wa(n); 23 | eigen_assert(ipvt.size()==n); 24 | 25 | /* form the inverse of r in the full upper triangle of r. */ 26 | l = -1; 27 | for (k = 0; k < n; ++k) 28 | if (abs(r(k,k)) > tolr) { 29 | r(k,k) = 1. / r(k,k); 30 | for (j = 0; j <= k-1; ++j) { 31 | temp = r(k,k) * r(j,k); 32 | r(j,k) = 0.; 33 | r.col(k).head(j+1) -= r.col(j).head(j+1) * temp; 34 | } 35 | l = k; 36 | } 37 | 38 | /* form the full upper triangle of the inverse of (r transpose)*r */ 39 | /* in the full upper triangle of r. */ 40 | for (k = 0; k <= l; ++k) { 41 | for (j = 0; j <= k-1; ++j) 42 | r.col(j).head(j+1) += r.col(k).head(j+1) * r(j,k); 43 | r.col(k).head(k+1) *= r(k,k); 44 | } 45 | 46 | /* form the full lower triangle of the covariance matrix */ 47 | /* in the strict lower triangle of r and in wa. */ 48 | for (j = 0; j < n; ++j) { 49 | jj = ipvt[j]; 50 | sing = j > l; 51 | for (i = 0; i <= j; ++i) { 52 | if (sing) 53 | r(i,j) = 0.; 54 | ii = ipvt[i]; 55 | if (ii > jj) 56 | r(ii,jj) = r(i,j); 57 | if (ii < jj) 58 | r(jj,ii) = r(i,j); 59 | } 60 | wa[jj] = r(j,j); 61 | } 62 | 63 | /* symmetrize the covariance matrix in r. */ 64 | r.topLeftCorner(n,n).template triangularView() = r.topLeftCorner(n,n).transpose(); 65 | r.diagonal() = wa; 66 | } 67 | 68 | } // end namespace internal 69 | 70 | } // end namespace Eigen 71 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/unsupported/Eigen/src/NonLinearOptimization/fdjac1.h: -------------------------------------------------------------------------------- 1 | namespace Eigen { 2 | 3 | namespace internal { 4 | 5 | template 6 | DenseIndex fdjac1( 7 | const FunctorType &Functor, 8 | Matrix< Scalar, Dynamic, 1 > &x, 9 | Matrix< Scalar, Dynamic, 1 > &fvec, 10 | Matrix< Scalar, Dynamic, Dynamic > &fjac, 11 | DenseIndex ml, DenseIndex mu, 12 | Scalar epsfcn) 13 | { 14 | using std::sqrt; 15 | using std::abs; 16 | 17 | typedef DenseIndex Index; 18 | 19 | /* Local variables */ 20 | Scalar h; 21 | Index j, k; 22 | Scalar eps, temp; 23 | Index msum; 24 | int iflag; 25 | Index start, length; 26 | 27 | /* Function Body */ 28 | const Scalar epsmch = NumTraits::epsilon(); 29 | const Index n = x.size(); 30 | eigen_assert(fvec.size()==n); 31 | Matrix< Scalar, Dynamic, 1 > wa1(n); 32 | Matrix< Scalar, Dynamic, 1 > wa2(n); 33 | 34 | eps = sqrt((std::max)(epsfcn,epsmch)); 35 | msum = ml + mu + 1; 36 | if (msum >= n) { 37 | /* computation of dense approximate jacobian. */ 38 | for (j = 0; j < n; ++j) { 39 | temp = x[j]; 40 | h = eps * abs(temp); 41 | if (h == 0.) 42 | h = eps; 43 | x[j] = temp + h; 44 | iflag = Functor(x, wa1); 45 | if (iflag < 0) 46 | return iflag; 47 | x[j] = temp; 48 | fjac.col(j) = (wa1-fvec)/h; 49 | } 50 | 51 | }else { 52 | /* computation of banded approximate jacobian. */ 53 | for (k = 0; k < msum; ++k) { 54 | for (j = k; (msum<0) ? (j>n): (jn): (j(0,j-mu); 69 | length = (std::min)(n-1, j+ml) - start + 1; 70 | fjac.col(j).segment(start, length) = ( wa1.segment(start, length)-fvec.segment(start, length))/h; 71 | } 72 | } 73 | } 74 | return 0; 75 | } 76 | 77 | } // end namespace internal 78 | 79 | } // end namespace Eigen 80 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/unsupported/Eigen/src/SVD/TODOBdcsvd.txt: -------------------------------------------------------------------------------- 1 | TO DO LIST 2 | 3 | 4 | 5 | (optional optimization) - do all the allocations in the allocate part 6 | - support static matrices 7 | - return a error at compilation time when using integer matrices (int, long, std::complex, ...) 8 | 9 | to finish the algorithm : 10 | -implement the last part of the algorithm as described on the reference paper. 11 | You may find more information on that part on this paper 12 | 13 | -to replace the call to JacobiSVD at the end of the divide algorithm, just after the call to 14 | deflation. 15 | 16 | (suggested step by step resolution) 17 | 0) comment the call to Jacobi in the last part of the divide method and everything right after 18 | until the end of the method. What is commented can be a guideline to steps 3) 4) and 6) 19 | 1) solve the secular equation (Characteristic equation) on the values that are not null (zi!=0 and di!=0), after the deflation 20 | wich should be uncommented in the divide method 21 | 2) remember the values of the singular values that are already computed (zi=0) 22 | 3) assign the singular values found in m_computed at the right places (with the ones found in step 2) ) 23 | in decreasing order 24 | 4) set the firstcol to zero (except the first element) in m_computed 25 | 5) compute all the singular vectors when CompV is set to true and only the left vectors when 26 | CompV is set to false 27 | 6) multiply naiveU and naiveV to the right by the matrices found, only naiveU when CompV is set to 28 | false, /!\ if CompU is false NaiveU has only 2 rows 29 | 7) delete everything commented in step 0) 30 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/unsupported/README.txt: -------------------------------------------------------------------------------- 1 | This directory contains contributions from various users. 2 | They are provided "as is", without any support. Nevertheless, 3 | most of them are subject to be included in Eigen in the future. 4 | 5 | In order to use an unsupported module you have to do either: 6 | 7 | - add the path_to_eigen/unsupported directory to your include path and do: 8 | #include 9 | 10 | - or directly do: 11 | #include 12 | 13 | 14 | If you are interested in contributing to one of them, or have other stuff 15 | you would like to share, feel free to contact us: 16 | http://eigen.tuxfamily.org/index.php?title=Main_Page#Mailing_list 17 | 18 | Any kind of contributions are much appreciated, even very preliminary ones. 19 | However, it: 20 | - must rely on Eigen, 21 | - must be highly related to math, 22 | - should have some general purpose in the sense that it could 23 | potentially become an offical Eigen module (or be merged into another one). 24 | 25 | In doubt feel free to contact us. For instance, if your addons is very too specific 26 | but it shows an interesting way of using Eigen, then it could be a nice demo. 27 | 28 | 29 | This directory is organized as follow: 30 | 31 | unsupported/Eigen/ModuleHeader1 32 | unsupported/Eigen/ModuleHeader2 33 | unsupported/Eigen/... 34 | unsupported/Eigen/src/Module1/SourceFile1.h 35 | unsupported/Eigen/src/Module1/SourceFile2.h 36 | unsupported/Eigen/src/Module1/... 37 | unsupported/Eigen/src/Module2/SourceFile1.h 38 | unsupported/Eigen/src/Module2/SourceFile2.h 39 | unsupported/Eigen/src/Module2/... 40 | unsupported/Eigen/src/... 41 | unsupported/doc/snippets/.cpp <- code snippets for the doc 42 | unsupported/doc/examples/.cpp <- examples for the doc 43 | unsupported/doc/TutorialModule1.dox 44 | unsupported/doc/TutorialModule2.dox 45 | unsupported/doc/... 46 | unsupported/test/.cpp <- unit test files 47 | 48 | The documentation is generated at the same time than the main Eigen documentation. 49 | The .html files are generated in: build_dir/doc/html/unsupported/ 50 | 51 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/unsupported/doc/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set_directory_properties(PROPERTIES EXCLUDE_FROM_ALL TRUE) 2 | 3 | add_subdirectory(examples) 4 | add_subdirectory(snippets) 5 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/unsupported/doc/examples/BVH_Example.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace Eigen; 6 | typedef AlignedBox Box2d; 7 | 8 | namespace Eigen { 9 | namespace internal { 10 | Box2d bounding_box(const Vector2d &v) { return Box2d(v, v); } //compute the bounding box of a single point 11 | } 12 | } 13 | 14 | struct PointPointMinimizer //how to compute squared distances between points and rectangles 15 | { 16 | PointPointMinimizer() : calls(0) {} 17 | typedef double Scalar; 18 | 19 | double minimumOnVolumeVolume(const Box2d &r1, const Box2d &r2) { ++calls; return r1.squaredExteriorDistance(r2); } 20 | double minimumOnVolumeObject(const Box2d &r, const Vector2d &v) { ++calls; return r.squaredExteriorDistance(v); } 21 | double minimumOnObjectVolume(const Vector2d &v, const Box2d &r) { ++calls; return r.squaredExteriorDistance(v); } 22 | double minimumOnObjectObject(const Vector2d &v1, const Vector2d &v2) { ++calls; return (v1 - v2).squaredNorm(); } 23 | 24 | int calls; 25 | }; 26 | 27 | int main() 28 | { 29 | typedef std::vector > StdVectorOfVector2d; 30 | StdVectorOfVector2d redPoints, bluePoints; 31 | for(int i = 0; i < 100; ++i) { //initialize random set of red points and blue points 32 | redPoints.push_back(Vector2d::Random()); 33 | bluePoints.push_back(Vector2d::Random()); 34 | } 35 | 36 | PointPointMinimizer minimizer; 37 | double minDistSq = std::numeric_limits::max(); 38 | 39 | //brute force to find closest red-blue pair 40 | for(int i = 0; i < (int)redPoints.size(); ++i) 41 | for(int j = 0; j < (int)bluePoints.size(); ++j) 42 | minDistSq = std::min(minDistSq, minimizer.minimumOnObjectObject(redPoints[i], bluePoints[j])); 43 | std::cout << "Brute force distance = " << sqrt(minDistSq) << ", calls = " << minimizer.calls << std::endl; 44 | 45 | //using BVH to find closest red-blue pair 46 | minimizer.calls = 0; 47 | KdBVH redTree(redPoints.begin(), redPoints.end()), blueTree(bluePoints.begin(), bluePoints.end()); //construct the trees 48 | minDistSq = BVMinimize(redTree, blueTree, minimizer); //actual BVH minimization call 49 | std::cout << "BVH distance = " << sqrt(minDistSq) << ", calls = " << minimizer.calls << std::endl; 50 | 51 | return 0; 52 | } 53 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/unsupported/doc/examples/PolynomialSolver1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace Eigen; 6 | using namespace std; 7 | 8 | int main() 9 | { 10 | typedef Matrix Vector5d; 11 | 12 | Vector5d roots = Vector5d::Random(); 13 | cout << "Roots: " << roots.transpose() << endl; 14 | Eigen::Matrix polynomial; 15 | roots_to_monicPolynomial( roots, polynomial ); 16 | 17 | PolynomialSolver psolve( polynomial ); 18 | cout << "Complex roots: " << psolve.roots().transpose() << endl; 19 | 20 | std::vector realRoots; 21 | psolve.realRoots( realRoots ); 22 | Map mapRR( &realRoots[0] ); 23 | cout << "Real roots: " << mapRR.transpose() << endl; 24 | 25 | cout << endl; 26 | cout << "Illustration of the convergence problem with the QR algorithm: " << endl; 27 | cout << "---------------------------------------------------------------" << endl; 28 | Eigen::Matrix hardCase_polynomial; 29 | hardCase_polynomial << 30 | -0.957, 0.9219, 0.3516, 0.9453, -0.4023, -0.5508, -0.03125; 31 | cout << "Hard case polynomial defined by floats: " << hardCase_polynomial.transpose() << endl; 32 | PolynomialSolver psolvef( hardCase_polynomial ); 33 | cout << "Complex roots: " << psolvef.roots().transpose() << endl; 34 | Eigen::Matrix evals; 35 | for( int i=0; i<6; ++i ){ evals[i] = std::abs( poly_eval( hardCase_polynomial, psolvef.roots()[i] ) ); } 36 | cout << "Norms of the evaluations of the polynomial at the roots: " << evals.transpose() << endl << endl; 37 | 38 | cout << "Using double's almost always solves the problem for small degrees: " << endl; 39 | cout << "-------------------------------------------------------------------" << endl; 40 | PolynomialSolver psolve6d( hardCase_polynomial.cast() ); 41 | cout << "Complex roots: " << psolve6d.roots().transpose() << endl; 42 | for( int i=0; i<6; ++i ) 43 | { 44 | std::complex castedRoot( psolve6d.roots()[i].real(), psolve6d.roots()[i].imag() ); 45 | evals[i] = std::abs( poly_eval( hardCase_polynomial, castedRoot ) ); 46 | } 47 | cout << "Norms of the evaluations of the polynomial at the roots: " << evals.transpose() << endl << endl; 48 | 49 | cout.precision(10); 50 | cout << "The last root in float then in double: " << psolvef.roots()[5] << "\t" << psolve6d.roots()[5] << endl; 51 | std::complex castedRoot( psolve6d.roots()[5].real(), psolve6d.roots()[5].imag() ); 52 | cout << "Norm of the difference: " << std::abs( psolvef.roots()[5] - castedRoot ) << endl; 53 | } 54 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/unsupported/test/FFT.cpp: -------------------------------------------------------------------------------- 1 | #define test_FFTW test_FFT 2 | #include "FFTW.cpp" 3 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/unsupported/test/alignedvector3.cpp: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 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 | #include "main.h" 11 | #include 12 | 13 | template 14 | void alignedvector3() 15 | { 16 | Scalar s1 = internal::random(); 17 | Scalar s2 = internal::random(); 18 | typedef Matrix RefType; 19 | typedef Matrix Mat33; 20 | typedef AlignedVector3 FastType; 21 | RefType r1(RefType::Random()), r2(RefType::Random()), r3(RefType::Random()), 22 | r4(RefType::Random()), r5(RefType::Random()), r6(RefType::Random()); 23 | FastType f1(r1), f2(r2), f3(r3), f4(r4), f5(r5), f6(r6); 24 | Mat33 m1(Mat33::Random()); 25 | 26 | VERIFY_IS_APPROX(f1,r1); 27 | VERIFY_IS_APPROX(f4,r4); 28 | 29 | VERIFY_IS_APPROX(f4+f1,r4+r1); 30 | VERIFY_IS_APPROX(f4-f1,r4-r1); 31 | VERIFY_IS_APPROX(f4+f1-f2,r4+r1-r2); 32 | VERIFY_IS_APPROX(f4+=f3,r4+=r3); 33 | VERIFY_IS_APPROX(f4-=f5,r4-=r5); 34 | VERIFY_IS_APPROX(f4-=f5+f1,r4-=r5+r1); 35 | VERIFY_IS_APPROX(f5+f1-s1*f2,r5+r1-s1*r2); 36 | VERIFY_IS_APPROX(f5+f1/s2-s1*f2,r5+r1/s2-s1*r2); 37 | 38 | VERIFY_IS_APPROX(m1*f4,m1*r4); 39 | VERIFY_IS_APPROX(f4.transpose()*m1,r4.transpose()*m1); 40 | 41 | VERIFY_IS_APPROX(f2.dot(f3),r2.dot(r3)); 42 | VERIFY_IS_APPROX(f2.cross(f3),r2.cross(r3)); 43 | VERIFY_IS_APPROX(f2.norm(),r2.norm()); 44 | 45 | VERIFY_IS_APPROX(f2.normalized(),r2.normalized()); 46 | 47 | VERIFY_IS_APPROX((f2+f1).normalized(),(r2+r1).normalized()); 48 | 49 | f2.normalize(); 50 | r2.normalize(); 51 | VERIFY_IS_APPROX(f2,r2); 52 | } 53 | 54 | void test_alignedvector3() 55 | { 56 | for(int i = 0; i < g_repeat; i++) { 57 | CALL_SUBTEST( alignedvector3() ); 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/unsupported/test/matrix_functions.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009-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 "main.h" 11 | #include 12 | 13 | template ::Scalar>::IsComplex> 14 | struct generateTestMatrix; 15 | 16 | // for real matrices, make sure none of the eigenvalues are negative 17 | template 18 | struct generateTestMatrix 19 | { 20 | static void run(MatrixType& result, typename MatrixType::Index size) 21 | { 22 | MatrixType mat = MatrixType::Random(size, size); 23 | EigenSolver es(mat); 24 | typename EigenSolver::EigenvalueType eivals = es.eigenvalues(); 25 | for (typename MatrixType::Index i = 0; i < size; ++i) { 26 | if (eivals(i).imag() == 0 && eivals(i).real() < 0) 27 | eivals(i) = -eivals(i); 28 | } 29 | result = (es.eigenvectors() * eivals.asDiagonal() * es.eigenvectors().inverse()).real(); 30 | } 31 | }; 32 | 33 | // for complex matrices, any matrix is fine 34 | template 35 | struct generateTestMatrix 36 | { 37 | static void run(MatrixType& result, typename MatrixType::Index size) 38 | { 39 | result = MatrixType::Random(size, size); 40 | } 41 | }; 42 | 43 | template 44 | double relerr(const MatrixBase& A, const MatrixBase& B) 45 | { 46 | return std::sqrt((A - B).cwiseAbs2().sum() / (std::min)(A.cwiseAbs2().sum(), B.cwiseAbs2().sum())); 47 | } 48 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/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 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/unsupported/test/minres.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 Giacomo Po 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 | #include 11 | 12 | #include "../../test/sparse_solver.h" 13 | #include 14 | 15 | template void test_minres_T() 16 | { 17 | MINRES, Lower|Upper, DiagonalPreconditioner > minres_colmajor_diag; 18 | MINRES, Lower, IdentityPreconditioner > minres_colmajor_lower_I; 19 | MINRES, Upper, IdentityPreconditioner > minres_colmajor_upper_I; 20 | // MINRES, Lower, IncompleteLUT > minres_colmajor_ilut; 21 | //minres, SSORPreconditioner > minres_colmajor_ssor; 22 | 23 | 24 | // CALL_SUBTEST( check_sparse_square_solving(minres_colmajor_diag) ); 25 | // CALL_SUBTEST( check_sparse_square_solving(minres_colmajor_ilut) ); 26 | //CALL_SUBTEST( check_sparse_square_solving(minres_colmajor_ssor) ); 27 | 28 | // Diagonal preconditioner 29 | MINRES, Lower, DiagonalPreconditioner > minres_colmajor_lower_diag; 30 | MINRES, Upper, DiagonalPreconditioner > minres_colmajor_upper_diag; 31 | MINRES, Upper|Lower, DiagonalPreconditioner > minres_colmajor_uplo_diag; 32 | 33 | // call tests for SPD matrix 34 | CALL_SUBTEST( check_sparse_spd_solving(minres_colmajor_lower_I) ); 35 | CALL_SUBTEST( check_sparse_spd_solving(minres_colmajor_upper_I) ); 36 | 37 | CALL_SUBTEST( check_sparse_spd_solving(minres_colmajor_lower_diag) ); 38 | CALL_SUBTEST( check_sparse_spd_solving(minres_colmajor_upper_diag) ); 39 | // CALL_SUBTEST( check_sparse_spd_solving(minres_colmajor_uplo_diag) ); 40 | 41 | // TO DO: symmetric semi-definite matrix 42 | // TO DO: symmetric indefinite matrix 43 | } 44 | 45 | void test_minres() 46 | { 47 | CALL_SUBTEST_1(test_minres_T()); 48 | // CALL_SUBTEST_2(test_minres_T >()); 49 | } 50 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/eigenlib/unsupported/test/mpreal_support.cpp: -------------------------------------------------------------------------------- 1 | #include "main.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace mpfr; 8 | using namespace Eigen; 9 | 10 | void test_mpreal_support() 11 | { 12 | // set precision to 256 bits (double has only 53 bits) 13 | mpreal::set_default_prec(256); 14 | typedef Matrix MatrixXmp; 15 | 16 | std::cerr << "epsilon = " << NumTraits::epsilon() << "\n"; 17 | std::cerr << "dummy_precision = " << NumTraits::dummy_precision() << "\n"; 18 | std::cerr << "highest = " << NumTraits::highest() << "\n"; 19 | std::cerr << "lowest = " << NumTraits::lowest() << "\n"; 20 | 21 | for(int i = 0; i < g_repeat; i++) { 22 | int s = Eigen::internal::random(1,100); 23 | MatrixXmp A = MatrixXmp::Random(s,s); 24 | MatrixXmp B = MatrixXmp::Random(s,s); 25 | MatrixXmp S = A.adjoint() * A; 26 | MatrixXmp X; 27 | 28 | // Basic stuffs 29 | VERIFY_IS_APPROX(A.real(), A); 30 | VERIFY(Eigen::internal::isApprox(A.array().abs2().sum(), A.squaredNorm())); 31 | VERIFY_IS_APPROX(A.array().exp(), exp(A.array())); 32 | VERIFY_IS_APPROX(A.array().abs2().sqrt(), A.array().abs()); 33 | VERIFY_IS_APPROX(A.array().sin(), sin(A.array())); 34 | VERIFY_IS_APPROX(A.array().cos(), cos(A.array())); 35 | 36 | 37 | // Cholesky 38 | X = S.selfadjointView().llt().solve(B); 39 | VERIFY_IS_APPROX((S.selfadjointView()*X).eval(),B); 40 | 41 | // partial LU 42 | X = A.lu().solve(B); 43 | VERIFY_IS_APPROX((A*X).eval(),B); 44 | 45 | // symmetric eigenvalues 46 | SelfAdjointEigenSolver eig(S); 47 | VERIFY_IS_EQUAL(eig.info(), Success); 48 | VERIFY( (S.selfadjointView() * eig.eigenvectors()).isApprox(eig.eigenvectors() * eig.eigenvalues().asDiagonal(), NumTraits::dummy_precision()*1e3) ); 49 | } 50 | 51 | { 52 | MatrixXmp A(8,3); A.setRandom(); 53 | // test output (interesting things happen in this code) 54 | std::stringstream stream; 55 | stream << A; 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/vcg/complex/algorithms/create/readme.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/warmtrue/UnityPlyLoader/4a0514f9e08423944df1a83fa9427eacf7032c32/CppNativePlugin/vcglib/vcg/complex/algorithms/create/readme.txt -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/vcg/complex/algorithms/textcoord_optimization.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/warmtrue/UnityPlyLoader/4a0514f9e08423944df1a83fa9427eacf7032c32/CppNativePlugin/vcglib/vcg/complex/algorithms/textcoord_optimization.h -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/vcg/complex/all_types.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * VCGLib o o * 3 | * Visual and Computer Graphics Library o o * 4 | * _ O _ * 5 | * Copyright(C) 2004-2016 \/)\/ * 6 | * Visual Computing Lab /\/| * 7 | * ISTI - Italian National Research Council | * 8 | * \ * 9 | * All rights reserved. * 10 | * * 11 | * This program is free software; you can redistribute it and/or modify * 12 | * it under the terms of the GNU General Public License as published by * 13 | * the Free Software Foundation; either version 2 of the License, or * 14 | * (at your option) any later version. * 15 | * * 16 | * This program is distributed in the hope that it will be useful, * 17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of * 18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * 19 | * GNU General Public License (http://www.gnu.org/licenses/gpl.txt) * 20 | * for more details. * 21 | * * 22 | ****************************************************************************/ 23 | #ifndef VCG_ALL_TYPES_H 24 | #define VCG_ALL_TYPES_H 25 | 26 | namespace vcg{ 27 | 28 | struct AllTypes{ 29 | struct AVertexType {}; 30 | struct AEdgeType {}; 31 | struct AFaceType {}; 32 | struct AHEdgeType {}; 33 | }; 34 | 35 | 36 | } 37 | 38 | #endif // USED_TYPES_H 39 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/vcg/complex/complex.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * VCGLib o o * 3 | * Visual and Computer Graphics Library o o * 4 | * _ O _ * 5 | * Copyright(C) 2004-2016 \/)\/ * 6 | * Visual Computing Lab /\/| * 7 | * ISTI - Italian National Research Council | * 8 | * \ * 9 | * All rights reserved. * 10 | * * 11 | * This program is free software; you can redistribute it and/or modify * 12 | * it under the terms of the GNU General Public License as published by * 13 | * the Free Software Foundation; either version 2 of the License, or * 14 | * (at your option) any later version. * 15 | * * 16 | * This program is distributed in the hope that it will be useful, * 17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of * 18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * 19 | * GNU General Public License (http://www.gnu.org/licenses/gpl.txt) * 20 | * for more details. * 21 | * * 22 | ****************************************************************************/ 23 | 24 | #ifndef __VCG_MESH_H 25 | #define __VCG_MESH_H 26 | #define __VCG_MESH 27 | 28 | #include 29 | #include 30 | #include 31 | #include 32 | #include 33 | #include 34 | #include 35 | #include 36 | #include 37 | #include 38 | #include 39 | #include 40 | #include 41 | #include 42 | #include 43 | #include 44 | #include 45 | #include 46 | #include 47 | #include 48 | #include 49 | 50 | #undef __VCG_MESH 51 | #endif 52 | 53 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/vcg/simplex/tetrahedron/tetrahedron.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * VCGLib o o * 3 | * Visual and Computer Graphics Library o o * 4 | * _ O _ * 5 | * Copyright(C) 2004-2016 \/)\/ * 6 | * Visual Computing Lab /\/| * 7 | * ISTI - Italian National Research Council | * 8 | * \ * 9 | * All rights reserved. * 10 | * * 11 | * This program is free software; you can redistribute it and/or modify * 12 | * it under the terms of the GNU General Public License as published by * 13 | * the Free Software Foundation; either version 2 of the License, or * 14 | * (at your option) any later version. * 15 | * * 16 | * This program is distributed in the hope that it will be useful, * 17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of * 18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * 19 | * GNU General Public License (http://www.gnu.org/licenses/gpl.txt) * 20 | * for more details. * 21 | * * 22 | ****************************************************************************/ 23 | #ifndef __VCGLIB_TETRAHEDRON 24 | #define __VCGLIB_TETRAHEDRON 25 | #define TETRA_TYPE Tetrahedron 26 | #include 27 | 28 | #endif 29 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/vcg/space/colorspace.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/warmtrue/UnityPlyLoader/4a0514f9e08423944df1a83fa9427eacf7032c32/CppNativePlugin/vcglib/vcg/space/colorspace.h -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/gcache/docs/css/prettify.css: -------------------------------------------------------------------------------- 1 | .str,.atv{color:#080} 2 | .kwd,.tag{color:#008} 3 | .com{color:#800} 4 | .typ,.atn,.dec{color:#606} 5 | .lit{color:#066} 6 | .pun{color:#660} 7 | .pln{color:#000} 8 | pre.prettyprint{padding:2px;border:1px solid #888} 9 | @media print{.str{color:#060} 10 | .kwd,.tag{color:#006;font-weight:bold} 11 | .com{color:#600;font-style:italic} 12 | .typ{font-weight:bold} 13 | .lit{color:#044} 14 | .pun{color:#440} 15 | .atn,.typ{color:#404} 16 | .atv{color:#060}} 17 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/gcache/docs/img/architecture.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/warmtrue/UnityPlyLoader/4a0514f9e08423944df1a83fa9427eacf7032c32/CppNativePlugin/vcglib/wrap/gcache/docs/img/architecture.png -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/gcache/docs/img/overflow.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/warmtrue/UnityPlyLoader/4a0514f9e08423944df1a83fa9427eacf7032c32/CppNativePlugin/vcglib/wrap/gcache/docs/img/overflow.png -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/gcache/docs/img/shadow.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/warmtrue/UnityPlyLoader/4a0514f9e08423944df1a83fa9427eacf7032c32/CppNativePlugin/vcglib/wrap/gcache/docs/img/shadow.png -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/gcache/docs/js/prettify.css: -------------------------------------------------------------------------------- 1 | .str,.atv{color:#080} 2 | .kwd,.tag{color:#008} 3 | .com{color:#800} 4 | .typ,.atn,.dec{color:#606} 5 | .lit{color:#066} 6 | .pun{color:#660} 7 | .pln{color:#000} 8 | pre.prettyprint{padding:2px;border:1px solid #888} 9 | @media print{.str{color:#060} 10 | .kwd,.tag{color:#006;font-weight:bold} 11 | .com{color:#600;font-style:italic} 12 | .typ{font-weight:bold} 13 | .lit{color:#044} 14 | .pun{color:#440} 15 | .atn,.typ{color:#404} 16 | .atv{color:#060}} 17 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/gcache/provider.h: -------------------------------------------------------------------------------- 1 | #ifndef GCACHE_PROVIDER_H 2 | #define GCACHE_PROVIDER_H 3 | 4 | #include 5 | #include "dheap.h" 6 | #include "door.h" 7 | 8 | #include "token.h" 9 | 10 | /* this cache system enforce the rule that the items in a cache are always in all the cache below */ 11 | /* two mechanism to remove tokens from the cache: 12 | 1) set token count to something low 13 | 2) set maximum number of tokens in the provider 14 | */ 15 | 16 | /** Base class for Cache and last cache in the GCache system. 17 | You should never interact with this class. 18 | */ 19 | 20 | namespace vcg { 21 | 22 | template 23 | class Provider: public mt::thread { 24 | public: 25 | ///holds the resources in this cache but not in the cache above 26 | PtrDHeap heap; 27 | ///tokens above this number will be scheduled for deletion 28 | int max_tokens; 29 | ///signals we need to rebuild heap. 30 | bool heap_dirty; 31 | ///lock this before manipulating heap. 32 | mt::mutex heap_lock; 33 | ///signals (to next cache!) priorities have changed or something is available 34 | QDoor check_queue; 35 | 36 | Provider(): max_tokens(-1), heap_dirty(false) {} 37 | virtual ~Provider() {} 38 | 39 | /// [should be protected, do not use] called in controller thread! 40 | void pushPriorities() { 41 | mt::mutexlocker locker(&heap_lock); 42 | for(int i = 0; i < heap.size(); i++) 43 | heap[i].pushPriority(); 44 | 45 | heap_dirty = true; 46 | check_queue.open(); 47 | } 48 | /// assumes heap lock is locked, runs in cache thread [should be protected, do not use] 49 | void rebuild() { 50 | if(!this->heap_dirty) return; 51 | 52 | this->heap.rebuild(); 53 | this->heap_dirty = false; 54 | 55 | //remove OUTSIDE tokens from bottom of heap 56 | if(max_tokens != -1) { 57 | while(this->heap.size() > max_tokens) { 58 | Token &t = this->heap.min(); 59 | t.count = Token::OUTSIDE; 60 | this->heap.popMin(); 61 | } 62 | } 63 | } 64 | 65 | ///ensure no locked item are to be removed [should be protected, do not use] 66 | template void flush(FUNCTOR functor) { 67 | int count = 0; 68 | mt::mutexlocker locker(&(this->heap_lock)); 69 | for(int k = 0; k < this->heap.size(); k++) { 70 | Token *token = &this->heap[k]; 71 | if(functor(token)) { //drop it 72 | token->count = Token::OUTSIDE; 73 | } else 74 | this->heap.at(count++) = token; 75 | } 76 | this->heap.resize(count); 77 | this->heap_dirty = true; 78 | } 79 | }; 80 | 81 | } //namespace 82 | #endif 83 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/gl/gl_type_name.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * VCGLib o o * 3 | * Visual and Computer Graphics Library o o * 4 | * _ O _ * 5 | * Copyright(C) 2004-2016 \/)\/ * 6 | * Visual Computing Lab /\/| * 7 | * ISTI - Italian National Research Council | * 8 | * \ * 9 | * All rights reserved. * 10 | * * 11 | * This program is free software; you can redistribute it and/or modify * 12 | * it under the terms of the GNU General Public License as published by * 13 | * the Free Software Foundation; either version 2 of the License, or * 14 | * (at your option) any later version. * 15 | * * 16 | * This program is distributed in the hope that it will be useful, * 17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of * 18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * 19 | * GNU General Public License (http://www.gnu.org/licenses/gpl.txt) * 20 | * for more details. * 21 | * * 22 | ****************************************************************************/ 23 | 24 | #ifndef __VCG_GL_TYPE_NAME 25 | #define __VCG_GL_TYPE_NAME 26 | 27 | namespace vcg 28 | { 29 | template 30 | class GL_TYPE_NM 31 | {public: 32 | static GLenum SCALAR() { assert(0); return 0;} 33 | }; 34 | template <> class GL_TYPE_NM 35 | { public: 36 | typedef GLfloat ScalarType; 37 | static GLenum SCALAR() { return GL_FLOAT; } 38 | }; 39 | template <> class GL_TYPE_NM 40 | {public: 41 | typedef GLdouble ScalarType; 42 | static GLenum SCALAR() { return GL_DOUBLE; } 43 | }; 44 | } 45 | 46 | #endif -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/gl/glu_tessellator_cap.h: -------------------------------------------------------------------------------- 1 | #ifndef GLU_TESSELLATOR_CAP_H 2 | #define GLU_TESSELLATOR_CAP_H 3 | #include "glu_tesselator.h" 4 | #include 5 | #include 6 | #include 7 | 8 | namespace vcg { 9 | namespace tri { 10 | 11 | 12 | // This function take a mesh with one or more boundary stored as edges, and fill another mesh with a triangulation of that boundaries. 13 | // it assumes that boundary are planar and exploits glutessellator for the triangulaiton 14 | template 15 | void CapEdgeMesh(MeshType &em, MeshType &cm, bool revertFlag=false) 16 | { 17 | typedef typename MeshType::EdgeType EdgeType; 18 | typedef typename MeshType::CoordType CoordType; 19 | std::vector< std::vector > outlines; 20 | std::vector outline; 21 | UpdateFlags::EdgeClearV(em); 22 | UpdateTopology::EdgeEdge(em); 23 | int nv=0; 24 | for(size_t i=0;i startE(&em.edge[i],0); 29 | edge::Pos curE=startE; 30 | do 31 | { 32 | curE.E()->SetV(); 33 | outline.push_back(curE.V()->P()); 34 | curE.NextE(); 35 | nv++; 36 | } 37 | while(curE != startE); 38 | if(revertFlag) std::reverse(outline.begin(),outline.end()); 39 | outlines.push_back(outline); 40 | outline.clear(); 41 | } 42 | } 43 | if (nv<2) return; 44 | // printf("Found %i outlines for a total of %i vertices",outlines.size(),nv); 45 | 46 | typename MeshType::VertexIterator vi=vcg::tri::Allocator::AddVertices(cm,nv); 47 | for (size_t i=0;iP()=outlines[i][j]; 51 | } 52 | 53 | std::vector indices; 54 | glu_tesselator::tesselate(outlines, indices); 55 | std::vector points; 56 | glu_tesselator::unroll(outlines, points); 57 | //typename MeshType::FaceIterator fi=tri::Allocator::AddFaces(cm,nv-2); 58 | typename MeshType::FaceIterator fi=tri::Allocator::AddFaces(cm,indices.size()/3); 59 | for (size_t i=0; iV(0)=&cm.vert[ indices[i+0] ]; 62 | (*&fi)->V(1)=&cm.vert[ indices[i+1] ]; 63 | (*&fi)->V(2)=&cm.vert[ indices[i+2] ]; 64 | } 65 | Clean::RemoveDuplicateVertex(cm); 66 | UpdateBounding::Box(cm); 67 | } 68 | 69 | } // end namespace tri 70 | } // end namespace vcg 71 | 72 | #endif // GLU_TESSELLATOR_CAP_H 73 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/gl/splatting_apss/splatrenderer.qrc: -------------------------------------------------------------------------------- 1 | 2 | 3 | shaders/Raycasting.glsl 4 | shaders/Finalization.glsl 5 | 6 | 7 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/glw/common.h: -------------------------------------------------------------------------------- 1 | #ifndef GLW_COMMON_H 2 | #define GLW_COMMON_H 3 | 4 | #include 5 | 6 | #include "./config.h" 7 | 8 | #define GLW_DONT_CARE (0xFFFFFFFF) 9 | #define GLW_CARE_OF(X) ((X) != GLW_DONT_CARE) 10 | 11 | #define GLW_CHECK_GL_ERROR GLW_ASSERT(glGetError() == GL_NO_ERROR) 12 | #define GLW_CHECK_GL_READ_FRAMEBUFFER_STATUS GLW_ASSERT(glCheckFramebufferStatus(GL_READ_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE) 13 | #define GLW_CHECK_GL_DRAW_FRAMEBUFFER_STATUS GLW_ASSERT(glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE) 14 | #define GLW_CHECK_GL_READ_DRAW_FRAMEBUFFER_STATUS GLW_ASSERT(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE) 15 | 16 | namespace glw 17 | { 18 | 19 | namespace detail 20 | { 21 | 22 | } 23 | 24 | }; 25 | 26 | #endif // GLW_COMMON_H 27 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/glw/config.h: -------------------------------------------------------------------------------- 1 | #ifndef GLW_CONFIG_H 2 | #define GLW_CONFIG_H 3 | 4 | #ifndef GLW_ASSERT 5 | # define GLW_ASSERT assert 6 | #endif 7 | 8 | #ifndef GLW_IMPLEMENT_CUSTOM_UNIFORMS 9 | # define GLW_IMPLEMENT_CUSTOM_UNIFORMS 10 | #endif 11 | 12 | #ifndef GLW_PRINT_LOG_TO_STDERR 13 | # define GLW_PRINT_LOG_TO_STDERR 1 14 | #endif 15 | 16 | #ifndef GLW_ASSERT_UNIFORM_LOCATION 17 | # define GLW_ASSERT_UNIFORM_LOCATION 0 18 | #endif 19 | 20 | #endif // GLW_CONFIG_H 21 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/glw/glheaders.h: -------------------------------------------------------------------------------- 1 | #ifndef GLW_GLHEADERS_H 2 | #define GLW_GLHEADERS_H 3 | 4 | #include 5 | 6 | #endif // GLW_GLHEADERS_H 7 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/glw/glw.h: -------------------------------------------------------------------------------- 1 | #ifndef GLW_GLW_H 2 | #define GLW_GLW_H 3 | 4 | #include "./context.h" 5 | #include "./utility.h" 6 | 7 | #endif // GLW_GLW_H 8 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/glw/noncopyable.h: -------------------------------------------------------------------------------- 1 | #ifndef GLW_NONCOPYABLE_H 2 | #define GLW_NONCOPYABLE_H 3 | 4 | #include "./common.h" 5 | 6 | namespace glw 7 | { 8 | 9 | namespace detail 10 | { 11 | 12 | class NonCopyable 13 | { 14 | public: 15 | 16 | typedef void BaseType; 17 | typedef NonCopyable ThisType; 18 | 19 | NonCopyable(void) 20 | { 21 | ; 22 | } 23 | 24 | private: 25 | 26 | NonCopyable(const ThisType & that) 27 | { 28 | (void)that; 29 | } 30 | 31 | ThisType & operator = (const ThisType & that) 32 | { 33 | (void)that; 34 | return (*this); 35 | } 36 | }; 37 | 38 | }; 39 | 40 | }; 41 | 42 | #endif // GLW_NONCOPYABLE_H 43 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/glw/objectdeleter.h: -------------------------------------------------------------------------------- 1 | #ifndef GLW_OBJECTDELETER_H 2 | #define GLW_OBJECTDELETER_H 3 | 4 | #include "./common.h" 5 | 6 | namespace glw 7 | { 8 | 9 | class Object; 10 | 11 | namespace detail 12 | { 13 | 14 | class ObjectDeleter 15 | { 16 | public: 17 | 18 | typedef void BaseType; 19 | typedef ObjectDeleter ThisType; 20 | 21 | inline void operator () (Object * object) const; 22 | }; 23 | 24 | }; 25 | 26 | }; 27 | 28 | #endif // GLW_OBJECTDELETER_H 29 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/glw/type.h: -------------------------------------------------------------------------------- 1 | #ifndef GLW_TYPE_H 2 | #define GLW_TYPE_H 3 | 4 | #include "./common.h" 5 | 6 | namespace glw 7 | { 8 | 9 | enum Type 10 | { 11 | InvalidType = 0, 12 | BufferType, 13 | RenderbufferType, 14 | VertexShaderType, 15 | GeometryShaderType, 16 | FragmentShaderType, 17 | ProgramType, 18 | Texture2DType, 19 | TextureCubeType, 20 | FramebufferType 21 | }; 22 | 23 | }; 24 | 25 | #endif // GLW_TYPE_H 26 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/io_trimesh/additionalinfo.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * MeshLab o o * 3 | * An extendible mesh processor o o * 4 | * _ O _ * 5 | * Copyright(C) 2005, 2009 \/)\/ * 6 | * Visual Computing Lab /\/| * 7 | * ISTI - Italian National Research Council | * 8 | * \ * 9 | * All rights reserved. * 10 | * * 11 | * This program is free software; you can redistribute it and/or modify * 12 | * it under the terms of the GNU General Public License as published by * 13 | * the Free Software Foundation; either version 2 of the License, or * 14 | * (at your option) any later version. * 15 | * * 16 | * This program is distributed in the hope that it will be useful, * 17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of * 18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * 19 | * GNU General Public License (http://www.gnu.org/licenses/gpl.txt) * 20 | * for more details. * 21 | * * 22 | ****************************************************************************/ 23 | 24 | #ifndef __VCGLIB_ADDITIONAL_INFO 25 | #define __VCGLIB_ADDITIONAL_INFO 26 | 27 | class AdditionalInfo 28 | { 29 | protected: 30 | AdditionalInfo() 31 | { 32 | } 33 | public: 34 | unsigned int numvert; 35 | unsigned int numface; 36 | int mask; 37 | 38 | virtual ~AdditionalInfo() 39 | { 40 | } 41 | }; 42 | 43 | #endif 44 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/io_trimesh/how_to_write_an_io_filter.txt: -------------------------------------------------------------------------------- 1 | ---- How to write an IMPORT filter ---- 2 | 3 | For writing an import filter for a XXX 3D mesh file type you must: 4 | 5 | create a class templated on the mesh type and named: 6 | 7 | vcg::tri::io::ImporterXXX 8 | 9 | The class must have at least the following methods 10 | 11 | static int Open(MESH_TYPE &mesh, const char *filename, CallBackPos *cb=0) 12 | static int Open(MESH_TYPE &mesh, const char *filename, int & loadmask, CallBackPos *cb =0) 13 | static const char *ErrorMsg(int error) 14 | 15 | where loadmask is an writeonly bitmask that, after the successful 16 | loading, will contain what kind of data have been found inside the 17 | loaded file (per vert color, tex coords etc). 18 | 19 | Please note that you can NOT use loadmask to selectively loading attribute from files. 20 | Note also that the returned mask should always match with the capability mask of your mesh, 21 | so if your mesh has no texture coords, that bit will be always zero even if the original file 22 | has texture coords. 23 | 24 | To know the original content of a given file use the LoadMask function. 25 | 26 | The last function is used to translate the numerical error code in a more meaningful message. 27 | 28 | The callback function should be used to back communicate the loading status in a 1..100 range. 29 | It should be called approximatively no more than some hundreds of time, 30 | so do not call it for every loaded face. Typical callback line 31 | in a j-based loop during vertex loading: 32 | 33 | if(cb && (j%1000)==0) cb(j*50/vertex_number,"Vertex Loading"); 34 | 35 | 36 | ---- How to write an EXPORT filter ---- 37 | 38 | create a class templated on the mesh type and named: 39 | 40 | vcg::tri::io::ExporterDOH 41 | 42 | The class must have at least the following methods 43 | 44 | static int Save(MESH_TYPE &mesh, const char *filename, CallBackPos *cb=0) 45 | static int Save(MESH_TYPE &mesh, const char *filename, int & savemask, CallBackPos *cb =0) 46 | static const char *ErrorMsg(int error) 47 | static int GetExportMaskCapability() 48 | 49 | function return 0 in case of success and a code in any other case... 50 | 51 | 52 | 53 | 54 | 55 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/io_trimesh/precision.h: -------------------------------------------------------------------------------- 1 | #ifndef __VCGLIB_PRECISION 2 | #define __VCGLIB_PRECISION 3 | 4 | namespace vcg 5 | { 6 | namespace tri 7 | { 8 | namespace io 9 | { 10 | template 11 | struct Precision 12 | { 13 | static int digits() {return 0;} 14 | static const char* typeName() {return "";} 15 | }; 16 | 17 | template<> 18 | struct Precision 19 | { 20 | static int digits() {return 7;} 21 | static const char* typeName() {return "float";} 22 | 23 | }; 24 | 25 | template<> 26 | struct Precision 27 | { 28 | static int digits() {return 16;} 29 | static const char* typeName() {return "double";} 30 | }; 31 | } 32 | } 33 | } 34 | 35 | 36 | #endif -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/math/sparse_matrix.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | ///this class define the interface to use sparse matrix 7 | ///you must extend this class and implement the code of each function in order 8 | ///to the system solver you're using. 9 | ///For details on implementation see system_interface_LDL.h as example 10 | template 11 | class SparseMatrix{ 12 | 13 | public: 14 | 15 | std::vector _Ap; 16 | std::vector _Ai; 17 | std::vector _Ax; 18 | 19 | typedef typename std::pair IndexType; 20 | 21 | int _dimension; 22 | 23 | public: 24 | 25 | ///initilaization of the system 26 | virtual void Initalize(int dimension) 27 | {_dimension=dimension;} 28 | 29 | ///create a sparse matrix given a set of entries as vector 30 | ///of pair of int 31 | virtual void CreateSparse(std::vector Entries) 32 | {} 33 | 34 | ///return the value of the matrix 35 | virtual ScalarType &A(int row,int col) 36 | {return (_Ax[0]);} 37 | 38 | ///return true if the rapresention of sparse matriz is symmetric 39 | virtual bool IsSymmetric() 40 | {return false;} 41 | 42 | virtual void Zero() 43 | {} 44 | 45 | ///return the dimension of the matrix 46 | virtual int Size(){return _dimension;} 47 | 48 | }; -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/nanoply/docs/index.dxy: -------------------------------------------------------------------------------- 1 | 2 | /** \mainpage The NanoPLY Library 3 | The NanoPLY is a C++ header-only library to read and write PLY file. It allow to load and save polygonal meshes and point clouds. 4 | 5 | NanoPLY does not require compiling or installing, just an #include in your code. 6 | 7 | 8 | Examples 9 | ---------------- 10 | The following code shows how to open and save a Ply file using a custom definition of mesh. 11 | 12 | \include nanoply_demo/main.cpp 13 | 14 | 15 | The following code shows how to open and save a Ply file using a VCGLib mesh. 16 | 17 | \include nanoply_vcg/main.cpp 18 | 19 | 20 | */ 21 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/nanoply/nanoply_demo/nanoply_demo.pro: -------------------------------------------------------------------------------- 1 | DEPENDPATH += ../include 2 | INCLUDEPATH += ../include 3 | CONFIG += console stl c++11 4 | CONFIG -= qt 5 | TEMPLATE = app 6 | SOURCES += main.cpp 7 | 8 | # Mac specific Config required to avoid to make application bundles 9 | CONFIG -= app_bundle 10 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/nanoply/nanoply_vcg/nanoply_vcg.pro: -------------------------------------------------------------------------------- 1 | INCLUDEPATH += ../../../ 2 | CONFIG += console stl c++11 3 | CONFIG -= qt 4 | TEMPLATE = app 5 | SOURCES += main.cpp 6 | 7 | # Mac specific Config required to avoid to make application bundles 8 | CONFIG -= app_bundle 9 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/qt/anttweakbarMapper.h: -------------------------------------------------------------------------------- 1 | #ifndef ANTTWEAKBARMAPPER_H 2 | #define ANTTWEAKBARMAPPER_H 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | void TW_CALL CopyCDStringToClient(char **destPtr, const char *src); 9 | void TW_CALL CopyStdStringToClient(std::string& destClientString, const std::string& srcLibraryString); 10 | 11 | TwMouseButtonID Qt2TwMouseButtonId(QMouseEvent *e); 12 | int TwMousePressQt(QMouseEvent *e); 13 | int TwMouseReleaseQt(QMouseEvent *e); 14 | int TwMousePressQt(QWidget *qw, QMouseEvent *e); 15 | int TwMouseReleaseQt(QWidget *qw, QMouseEvent *e); 16 | int TwKeyPressQt(QKeyEvent *e); 17 | 18 | #endif // ANTTWEAKBARMAPPER_H 19 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/qt/col_qt_convert.h: -------------------------------------------------------------------------------- 1 | #ifndef COL_QT_CONVERT_H_ 2 | #define COL_QT_CONVERT_H_ 3 | 4 | #include 5 | #include "../../vcg/space/color4.h" 6 | 7 | namespace vcg 8 | { 9 | class ColorConverter 10 | { 11 | public: 12 | inline static vcg::Color4b ToColor4b(const QColor& col) 13 | { 14 | return vcg::Color4b(col.red(),col.green(),col.blue(),col.alpha()); 15 | } 16 | 17 | inline static QColor ToQColor(const vcg::Color4b& col) 18 | { 19 | return QColor(col[0],col[1],col[2],col[3]); 20 | } 21 | }; 22 | } 23 | 24 | #endif -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/qt/device_to_logical.h: -------------------------------------------------------------------------------- 1 | #ifndef DEVICE_TO_LOGICAL_H 2 | #define DEVICE_TO_LOGICAL_H 3 | #include 4 | #include 5 | #include 6 | 7 | template < class ValueType> 8 | inline ValueType QTLogicalToDevice( QWidget *qw, const ValueType &value) 9 | { 10 | #if QT_VERSION >= 0x050000 11 | return value*qw->devicePixelRatio() ; 12 | #else 13 | Q_UNUSED(qw); 14 | return value; 15 | #endif 16 | } 17 | 18 | template < class ValueType> 19 | inline ValueType QTLogicalToDevice( QPainter *qp, const ValueType &value) 20 | { 21 | #if QT_VERSION >= 0x050000 22 | return value*qp->device()->devicePixelRatio() ; 23 | #else 24 | Q_UNUSED(qp); 25 | return value; 26 | #endif 27 | } 28 | 29 | template < class ValueType> 30 | inline ValueType QTDeviceToLogical( QWidget *qw, const ValueType &value) 31 | { 32 | #if QT_VERSION >= 0x050000 33 | return value/qw->devicePixelRatio() ; 34 | #else 35 | Q_UNUSED(qw); 36 | return value; 37 | #endif 38 | } 39 | 40 | template < class ValueType> 41 | inline ValueType QTDeviceToLogical( QPainter *qp, const ValueType &value) 42 | { 43 | #if QT_VERSION >= 0x050000 44 | return value/qp->device()->devicePixelRatio() ; 45 | #else 46 | Q_UNUSED(qp); 47 | return value; 48 | #endif 49 | } 50 | 51 | inline vcg::Point2f QTLogicalToOpenGL( QWidget *qw, const QPoint &p) 52 | { 53 | return vcg::Point2f(QTLogicalToDevice(qw,p.x()), QTLogicalToDevice(qw,qw->height()-p.y())); 54 | } 55 | 56 | 57 | inline int QTDeviceHeight(QWidget *qw) {return QTLogicalToDevice(qw,qw->height());} 58 | inline int QTDeviceWidth(QWidget *qw) {return QTLogicalToDevice(qw,qw->width());} 59 | #endif // DEVICE_TO_LOGICAL_H 60 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/qt/img_qt.h: -------------------------------------------------------------------------------- 1 | #ifndef IMG_QT_INCLUDES_H_ 2 | #define IMG_QT_INCLUDES_H_ 3 | 4 | // includes all img and all qt wrap headers 5 | 6 | #include "img/img.h" 7 | 8 | #include "wrap/qt/img_qt_convert.h" 9 | #include "wrap/qt/img_qt_io.h" 10 | 11 | #endif /*IMG_QT_INCLUDES_H_*/ 12 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/qt/outline2_rasterizer.h: -------------------------------------------------------------------------------- 1 | #ifndef QTPOLYRASTERIZER_H 2 | #define QTPOLYRASTERIZER_H 3 | 4 | #include 5 | //#include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | ///this class is used to draw polygons on an image could be vectorial or not 14 | class QtOutline2Rasterizer 15 | { 16 | public: 17 | static void rasterize(vcg::RasterizedOutline2 &poly, 18 | float scaleFactor, 19 | int rast_i, int rotationNum, int cellSize); 20 | 21 | static std::vector > rotateGridCWise(std::vector< std::vector >& inGrid); 22 | 23 | }; 24 | #endif // QTPOLYRASTERIZER_H 25 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/qt/to_string.h: -------------------------------------------------------------------------------- 1 | #ifndef TOSTRING_H 2 | #define TOSTRING_H 3 | #include 4 | #include 5 | 6 | inline QString toString( const vcg::Point4f& p ){ 7 | QString s; 8 | s.sprintf("%f %f %f %f", p[0], p[1], p[2], p[3]); 9 | return s; 10 | } 11 | inline QString toString( const vcg::Point3f& p ){ 12 | QString s; 13 | s.sprintf("%f %f %f", p[0], p[1], p[2]); 14 | return s; 15 | } 16 | inline QString toString( const vcg::Point2f& p ){ 17 | QString s; 18 | s.sprintf("%f %f", p[0], p[1]); 19 | return s; 20 | } 21 | inline QString toString( const vcg::Point2i& p ){ 22 | QString s; 23 | s.sprintf("%d %d", p[0], p[1]); 24 | return s; 25 | } 26 | inline QString toString(vcg::Matrix44f& m){ 27 | QString mat; 28 | for(int i=0; i<3; i++){ 29 | mat.append( toString( m.GetRow4(i) ) ); 30 | mat.append("\n"); 31 | } 32 | return mat; 33 | } 34 | #endif // TOSTRING_H 35 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/system/multithreading/atomic_int.h: -------------------------------------------------------------------------------- 1 | #ifndef _ATOMIC_INT_H 2 | #define _ATOMIC_INT_H 3 | 4 | #ifdef QT_CORE_LIB 5 | #include 6 | namespace mt{ 7 | typedef QAtomicInt atomicInt; 8 | } 9 | 10 | #elif defined(__APPLE__) 11 | # include "atomic_int_apple.h" 12 | 13 | 14 | //generic implementation using mutexes 15 | #else 16 | # include "atomic_int_generic.h" 17 | #endif 18 | 19 | /* 20 | #elif defined(_WIN32) 21 | # include "atomic_int_win32.h" 22 | #endif 23 | 24 | #elif defined(__linux__) 25 | # include "atomic_int_linux.h" 26 | #endif 27 | */ 28 | /* 29 | __linux__ 30 | __unix__ 31 | __posix__ 32 | */ 33 | 34 | #endif // _ATOMIC_INT_H 35 | 36 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/system/multithreading/base.h: -------------------------------------------------------------------------------- 1 | #ifndef MT_BASE_H 2 | #define MT_BASE_H 3 | 4 | #include 5 | 6 | #define MT_PREVENT_COPY(CLASS_NAME) \ 7 | private: \ 8 | CLASS_NAME (const CLASS_NAME &); \ 9 | CLASS_NAME & operator = (const CLASS_NAME &); 10 | 11 | #define MT_ASSERT assert 12 | 13 | namespace mt 14 | { 15 | 16 | } 17 | 18 | #endif // MT_BASE_H 19 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/system/multithreading/condition.h: -------------------------------------------------------------------------------- 1 | #ifndef MT_CONDITION_H 2 | #define MT_CONDITION_H 3 | 4 | #include "base.h" 5 | #include "mutex.h" 6 | 7 | #include 8 | 9 | namespace mt 10 | { 11 | 12 | class condition 13 | { 14 | MT_PREVENT_COPY(condition) 15 | 16 | public: 17 | 18 | typedef condition this_type; 19 | typedef void base_type; 20 | 21 | condition(void) 22 | { 23 | pthread_cond_init(&(this->c), 0); 24 | } 25 | 26 | ~condition(void) 27 | { 28 | pthread_cond_destroy(&(this->c)); 29 | } 30 | 31 | void signal(void) 32 | { 33 | pthread_cond_signal(&(this->c)); 34 | } 35 | 36 | void broadcast(void) 37 | { 38 | pthread_cond_broadcast(&(this->c)); 39 | } 40 | 41 | void wait(mutex & m) 42 | { 43 | pthread_cond_wait(&(this->c), &(m.m)); 44 | } 45 | 46 | private: 47 | 48 | pthread_cond_t c; 49 | }; 50 | 51 | } 52 | 53 | #endif // MT_CONDITION_H 54 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/system/multithreading/mt.h: -------------------------------------------------------------------------------- 1 | #ifndef MT_MT_H 2 | #define MT_MT_H 3 | 4 | 5 | #ifdef QT_CORE_LIB 6 | 7 | #include 8 | #include 9 | #include 10 | 11 | namespace mt { 12 | typedef QThread thread; 13 | typedef QMutex mutex; 14 | typedef QMutexLocker mutexlocker; 15 | typedef QSemaphore semaphore; 16 | 17 | //cache.h, token.h 18 | //QAtomicInt 19 | 20 | }//namespace 21 | 22 | 23 | #else 24 | 25 | #include "base.h" 26 | #include "mutex.h" 27 | #include "rw_lock.h" 28 | #include "semaphore.h" 29 | #include "thread.h" 30 | #include "scoped_mutex_lock.h" 31 | #include "scoped_read_lock.h" 32 | #include "scoped_write_lock.h" 33 | 34 | namespace mt{ 35 | typedef scoped_mutex_lock mutexlocker; 36 | } 37 | #endif 38 | 39 | #endif // MT_MT_H 40 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/system/multithreading/mutex.h: -------------------------------------------------------------------------------- 1 | #ifndef MT_MUTEX_H 2 | #define MT_MUTEX_H 3 | 4 | #include "base.h" 5 | 6 | #include 7 | 8 | namespace mt 9 | { 10 | 11 | class condition; 12 | 13 | class mutex 14 | { 15 | MT_PREVENT_COPY(mutex) 16 | 17 | public: 18 | 19 | typedef mutex this_type; 20 | typedef void base_type; 21 | 22 | mutex(void) 23 | { 24 | pthread_mutex_init(&(this->m), 0); 25 | } 26 | 27 | ~mutex(void) 28 | { 29 | pthread_mutex_destroy(&(this->m)); 30 | } 31 | 32 | void lock(void) 33 | { 34 | pthread_mutex_lock(&(this->m)); 35 | } 36 | 37 | void unlock(void) 38 | { 39 | pthread_mutex_unlock(&(this->m)); 40 | } 41 | bool tryLock(void) 42 | { 43 | int a = pthread_mutex_trylock(&(this->m)); 44 | return a == 0; 45 | } 46 | 47 | private: 48 | 49 | friend class condition; 50 | 51 | pthread_mutex_t m; 52 | }; 53 | 54 | } 55 | 56 | #endif // MT_MUTEX_H 57 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/system/multithreading/rw_lock.h: -------------------------------------------------------------------------------- 1 | #ifndef MT_RW_LOCK_H 2 | #define MT_RW_LOCK_H 3 | 4 | #include "base.h" 5 | 6 | #include 7 | 8 | namespace mt 9 | { 10 | 11 | class rw_lock 12 | { 13 | MT_PREVENT_COPY(rw_lock) 14 | 15 | public: 16 | 17 | typedef rw_lock this_type; 18 | typedef void base_type; 19 | 20 | rw_lock(void) 21 | { 22 | pthread_rwlock_init(&(this->rw), 0); 23 | } 24 | 25 | ~rw_lock(void) 26 | { 27 | pthread_rwlock_destroy(&(this->rw)); 28 | } 29 | 30 | void lock_read(void) 31 | { 32 | pthread_rwlock_rdlock(&(this->rw)); 33 | } 34 | 35 | void unlock_read(void) 36 | { 37 | pthread_rwlock_unlock(&(this->rw)); 38 | } 39 | 40 | void lock_write(void) 41 | { 42 | pthread_rwlock_wrlock(&(this->rw)); 43 | } 44 | 45 | void unlock_write(void) 46 | { 47 | pthread_rwlock_unlock(&(this->rw)); 48 | } 49 | 50 | private: 51 | 52 | pthread_rwlock_t rw; 53 | }; 54 | 55 | } 56 | 57 | #endif // MT_RW_LOCK_H 58 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/system/multithreading/scoped_mutex_lock.h: -------------------------------------------------------------------------------- 1 | #ifndef MT_SCOPED_MUTEX_LOCK_H 2 | #define MT_SCOPED_MUTEX_LOCK_H 3 | 4 | #include "mutex.h" 5 | 6 | namespace mt 7 | { 8 | 9 | class scoped_mutex_lock 10 | { 11 | MT_PREVENT_COPY(scoped_mutex_lock) 12 | 13 | public: 14 | 15 | typedef scoped_mutex_lock this_type; 16 | typedef void base_type; 17 | 18 | scoped_mutex_lock(mutex & m) : mtx(m) 19 | { 20 | this->mtx.lock(); 21 | } 22 | 23 | ~scoped_mutex_lock(void) 24 | { 25 | this->mtx.unlock(); 26 | } 27 | 28 | //jnoguera 14-12-2011 29 | //method added to mime QMutexLocker 30 | scoped_mutex_lock(mutex * m) : mtx( *m ) 31 | { 32 | this->mtx.lock(); 33 | } 34 | 35 | 36 | protected: 37 | 38 | mutex & mtx; 39 | }; 40 | 41 | } 42 | 43 | #endif // MT_SCOPED_MUTEX_LOCK_H 44 | 45 | 46 | 47 | 48 | 49 | /* 50 | #ifndef MT_SCOPED_MUTEX_LOCK_H 51 | #define MT_SCOPED_MUTEX_LOCK_H 52 | 53 | #include "mutex.h" 54 | 55 | namespace mt 56 | { 57 | 58 | class scoped_mutex_lock 59 | { 60 | MT_PREVENT_COPY(scoped_mutex_lock) 61 | 62 | public: 63 | 64 | typedef scoped_mutex_lock this_type; 65 | typedef void base_type; 66 | 67 | scoped_mutex_lock(mutex & m) : mtx(m) 68 | { 69 | this->mtx.lock(); 70 | } 71 | 72 | ~scoped_mutex_lock(void) 73 | { 74 | this->mtx.unlock(); 75 | } 76 | 77 | protected: 78 | 79 | mutex & mtx; 80 | }; 81 | 82 | } 83 | 84 | #endif // MT_SCOPED_MUTEX_LOCK_H 85 | 86 | */ 87 | 88 | 89 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/system/multithreading/scoped_read_lock.h: -------------------------------------------------------------------------------- 1 | #ifndef MT_SCOPED_READ_LOCK_H 2 | #define MT_SCOPED_READ_LOCK_H 3 | 4 | #include "rw_lock.h" 5 | 6 | namespace mt 7 | { 8 | 9 | class scoped_read_lock 10 | { 11 | MT_PREVENT_COPY(scoped_read_lock) 12 | 13 | public: 14 | 15 | typedef scoped_read_lock this_type; 16 | typedef void base_type; 17 | 18 | scoped_read_lock(rw_lock & rwl) : rw(rwl) 19 | { 20 | this->rw.lock_read(); 21 | } 22 | 23 | ~scoped_read_lock(void) 24 | { 25 | this->rw.unlock_read(); 26 | } 27 | 28 | protected: 29 | 30 | rw_lock & rw; 31 | }; 32 | 33 | } 34 | 35 | #endif // MT_SCOPED_READ_LOCK_H 36 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/system/multithreading/scoped_write_lock.h: -------------------------------------------------------------------------------- 1 | #ifndef MT_SCOPED_WRITE_LOCK_H 2 | #define MT_SCOPED_WRITE_LOCK_H 3 | 4 | #include "rw_lock.h" 5 | 6 | namespace mt 7 | { 8 | 9 | class scoped_write_lock 10 | { 11 | MT_PREVENT_COPY(scoped_write_lock) 12 | 13 | public: 14 | 15 | typedef scoped_write_lock this_type; 16 | typedef void base_type; 17 | 18 | scoped_write_lock(rw_lock & rwl) : rw(rwl) 19 | { 20 | this->rw.lock_write(); 21 | } 22 | 23 | ~scoped_write_lock(void) 24 | { 25 | this->rw.unlock_write(); 26 | } 27 | 28 | protected: 29 | 30 | rw_lock & rw; 31 | }; 32 | 33 | } 34 | 35 | #endif // MT_SCOPED_WRITE_LOCK_H 36 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/system/multithreading/semaphore.h: -------------------------------------------------------------------------------- 1 | #ifndef MT_SEMAPHORE_H 2 | #define MT_SEMAPHORE_H 3 | 4 | #include "base.h" 5 | 6 | #include 7 | #include 8 | 9 | namespace mt 10 | { 11 | 12 | class semaphore 13 | { 14 | MT_PREVENT_COPY(semaphore) 15 | 16 | public: 17 | 18 | typedef semaphore this_type; 19 | typedef void base_type; 20 | 21 | semaphore(void) 22 | { 23 | sem_init(&(this->s), 0, 0); 24 | } 25 | 26 | semaphore(int value) 27 | { 28 | sem_init(&(this->s), 0, value); 29 | } 30 | 31 | ~semaphore(void) 32 | { 33 | sem_destroy(&(this->s)); 34 | } 35 | 36 | void post(void) 37 | { 38 | sem_post(&(this->s)); 39 | } 40 | 41 | /* 42 | void post(int n) 43 | { 44 | sem_post_multiple(&(this->s), n); 45 | } 46 | */ 47 | 48 | void wait(void) 49 | { 50 | sem_wait(&(this->s)); 51 | } 52 | 53 | bool trywait(void) 54 | { 55 | return (sem_trywait(&(this->s)) == 0); 56 | } 57 | 58 | //methods added for conforming to the QT implementation 59 | //jnoguera 14-12-2011 60 | 61 | void release(int n=1) 62 | { 63 | if(n != 1) 64 | std::cout << "Error, mt::semaphore.release() not supported\n"; 65 | sem_post(&(this->s)); 66 | } 67 | 68 | void acquire(int n=1) 69 | { 70 | if(n != 1) 71 | std::cout << "Error, mt::semaphore.tryAcquire() not supported\n"; 72 | sem_wait(&(this->s)); 73 | } 74 | 75 | bool tryAcquire(int n=1) 76 | { 77 | if(n != 1) 78 | std::cout << "Error, mt::semaphore.tryAcquire() not supported\n"; 79 | return (sem_trywait(&(this->s)) == 0); 80 | } 81 | 82 | int available() 83 | { 84 | int value; 85 | sem_getvalue( &(this->s), &value ); 86 | return value; 87 | } 88 | 89 | private: 90 | 91 | sem_t s; 92 | }; 93 | 94 | } 95 | 96 | #endif // MT_SEMAPHORE_H 97 | -------------------------------------------------------------------------------- /CppNativePlugin/vcglib/wrap/system/multithreading/util.h: -------------------------------------------------------------------------------- 1 | #ifndef MT_UTIL_H 2 | #define MT_UTIL_H 3 | 4 | #if (defined(_MSC_VER)) 5 | #include 6 | #elif (defined(__MINGW32__)) 7 | #include 8 | #elif (defined(__linux__)) 9 | #include 10 | #else 11 | #include 12 | //#error "mt utils.h : unrecognized environment." 13 | #endif 14 | 15 | namespace mt 16 | { 17 | 18 | inline void sleep_ms(unsigned int msecs) 19 | { 20 | #if (defined(_MSC_VER)) 21 | Sleep(DWORD(msecs)); 22 | #elif (defined(__MINGW32__)) 23 | Sleep(DWORD(msecs)); 24 | #elif (defined(__linux__)) 25 | const unsigned int secs = ((unsigned int)(msecs / 1000)); 26 | const unsigned long usecs = ((unsigned long)((msecs % 1000) * 1000)); 27 | 28 | sleep(secs); 29 | usleep(usecs); 30 | #else 31 | const unsigned int secs = ((unsigned int)(msecs / 1000)); 32 | const unsigned long usecs = ((unsigned long)((msecs % 1000) * 1000)); 33 | 34 | sleep(secs); 35 | usleep(usecs); 36 | #endif 37 | } 38 | 39 | } 40 | 41 | #endif // MT_UTIL_H 42 | -------------------------------------------------------------------------------- /PlyLoader.unitypackage: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/warmtrue/UnityPlyLoader/4a0514f9e08423944df1a83fa9427eacf7032c32/PlyLoader.unitypackage -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | UnityPlyLoader 2 | === 3 | 4 | [![license](http://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/warmtrue/WDataTable/LICENSE) 5 | [![release](https://img.shields.io/badge/release-v1.0.0-blue.svg)](https://github.com/warmtrue/WDataTable/releases) 6 | [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-blue.svg)](https://github.com/warmtrue/WDataTable/pulls) 7 | 8 | 9 | Load ply mesh file in Unity 3D use vcglib. 10 | 11 | 12 | ## Feature 13 | * use [vcglib](https://github.com/cnr-isti-vclab/vcglib) 14 | * support per face uv (change to per vertex uv) 15 | * easy expand to other format (asc,ctm,dae,fbx,field,gts,nvm,obj,off,out,ptx,raw,smf,stl,vmi) 16 | 17 | 18 | ## Environment 19 | * Unity 5.5.0p1 20 | * Visual Studio 2015 21 | 22 | 23 | ## License 24 | MIT 25 | 26 | ## Author 27 | [warmtrue](http://www.warmtrue.com) -------------------------------------------------------------------------------- /UnityProject/.gitignore: -------------------------------------------------------------------------------- 1 | /.vs 2 | /Library 3 | /Temp 4 | *.csproj 5 | *.sln -------------------------------------------------------------------------------- /UnityProject/Assets/PlyLoader.meta: -------------------------------------------------------------------------------- 1 | fileFormatVersion: 2 2 | guid: 58117bb224e2155458aba9f902740808 3 | folderAsset: yes 4 | timeCreated: 1504696726 5 | licenseType: Pro 6 | DefaultImporter: 7 | userData: 8 | assetBundleName: 9 | assetBundleVariant: 10 | -------------------------------------------------------------------------------- /UnityProject/Assets/PlyLoader/PlyLoader.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/warmtrue/UnityPlyLoader/4a0514f9e08423944df1a83fa9427eacf7032c32/UnityProject/Assets/PlyLoader/PlyLoader.dll -------------------------------------------------------------------------------- /UnityProject/Assets/PlyLoader/PlyLoader.dll.meta: -------------------------------------------------------------------------------- 1 | fileFormatVersion: 2 2 | guid: 0cf4b8fb8f8f96048b25bf5e773bc9af 3 | timeCreated: 1504524244 4 | licenseType: Pro 5 | PluginImporter: 6 | serializedVersion: 1 7 | iconMap: {} 8 | executionOrder: {} 9 | isPreloaded: 0 10 | isOverridable: 0 11 | platformData: 12 | Any: 13 | enabled: 1 14 | settings: {} 15 | Editor: 16 | enabled: 0 17 | settings: 18 | DefaultValueInitialized: true 19 | userData: 20 | assetBundleName: 21 | assetBundleVariant: 22 | -------------------------------------------------------------------------------- /UnityProject/Assets/PlyLoader/PlyLoaderDll.cs.meta: -------------------------------------------------------------------------------- 1 | fileFormatVersion: 2 2 | guid: 9879bb6dabc9ba74b8a20d0279428af8 3 | timeCreated: 1504513255 4 | licenseType: Pro 5 | MonoImporter: 6 | serializedVersion: 2 7 | defaultReferences: [] 8 | executionOrder: 0 9 | icon: {instanceID: 0} 10 | userData: 11 | assetBundleName: 12 | assetBundleVariant: 13 | -------------------------------------------------------------------------------- /UnityProject/Assets/StreamingAssets.meta: -------------------------------------------------------------------------------- 1 | fileFormatVersion: 2 2 | guid: add75f3255c6fcd44aae1dcd0b35cfee 3 | folderAsset: yes 4 | timeCreated: 1504695938 5 | licenseType: Pro 6 | DefaultImporter: 7 | userData: 8 | assetBundleName: 9 | assetBundleVariant: 10 | -------------------------------------------------------------------------------- /UnityProject/Assets/StreamingAssets/mesh_UVtexture.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/warmtrue/UnityPlyLoader/4a0514f9e08423944df1a83fa9427eacf7032c32/UnityProject/Assets/StreamingAssets/mesh_UVtexture.jpg -------------------------------------------------------------------------------- /UnityProject/Assets/StreamingAssets/mesh_UVtexture.jpg.meta: -------------------------------------------------------------------------------- 1 | fileFormatVersion: 2 2 | guid: 9b86a74c546010e4784ef6669b016158 3 | timeCreated: 1504696113 4 | licenseType: Pro 5 | TextureImporter: 6 | fileIDToRecycleName: {} 7 | serializedVersion: 4 8 | mipmaps: 9 | mipMapMode: 0 10 | enableMipMap: 1 11 | sRGBTexture: 1 12 | linearTexture: 0 13 | fadeOut: 0 14 | borderMipMap: 0 15 | mipMapFadeDistanceStart: 1 16 | mipMapFadeDistanceEnd: 3 17 | bumpmap: 18 | convertToNormalMap: 0 19 | externalNormalMap: 0 20 | heightScale: 0.25 21 | normalMapFilter: 0 22 | isReadable: 0 23 | grayScaleToAlpha: 0 24 | generateCubemap: 6 25 | cubemapConvolution: 0 26 | seamlessCubemap: 0 27 | textureFormat: 1 28 | maxTextureSize: 2048 29 | textureSettings: 30 | filterMode: -1 31 | aniso: -1 32 | mipBias: -1 33 | wrapMode: -1 34 | nPOTScale: 1 35 | lightmap: 0 36 | compressionQuality: 50 37 | spriteMode: 0 38 | spriteExtrude: 1 39 | spriteMeshType: 1 40 | alignment: 0 41 | spritePivot: {x: 0.5, y: 0.5} 42 | spriteBorder: {x: 0, y: 0, z: 0, w: 0} 43 | spritePixelsToUnits: 100 44 | alphaUsage: 1 45 | alphaIsTransparency: 0 46 | spriteTessellationDetail: -1 47 | textureType: 0 48 | textureShape: 1 49 | maxTextureSizeSet: 0 50 | compressionQualitySet: 0 51 | textureFormatSet: 0 52 | platformSettings: 53 | - buildTarget: DefaultTexturePlatform 54 | maxTextureSize: 2048 55 | textureFormat: -1 56 | textureCompression: 1 57 | compressionQuality: 50 58 | crunchedCompression: 0 59 | allowsAlphaSplitting: 0 60 | overridden: 0 61 | - buildTarget: Standalone 62 | maxTextureSize: 2048 63 | textureFormat: -1 64 | textureCompression: 1 65 | compressionQuality: 50 66 | crunchedCompression: 0 67 | allowsAlphaSplitting: 0 68 | overridden: 0 69 | - buildTarget: Nintendo Switch 70 | maxTextureSize: 2048 71 | textureFormat: -1 72 | textureCompression: 1 73 | compressionQuality: 50 74 | crunchedCompression: 0 75 | allowsAlphaSplitting: 0 76 | overridden: 0 77 | spriteSheet: 78 | serializedVersion: 2 79 | sprites: [] 80 | outline: [] 81 | spritePackingTag: 82 | userData: 83 | assetBundleName: 84 | assetBundleVariant: 85 | -------------------------------------------------------------------------------- /UnityProject/Assets/StreamingAssets/mesh_textured.ply.meta: -------------------------------------------------------------------------------- 1 | fileFormatVersion: 2 2 | guid: 094b73b58d74d1c43b0fa6aaee69da7d 3 | timeCreated: 1504696048 4 | licenseType: Pro 5 | DefaultImporter: 6 | userData: 7 | assetBundleName: 8 | assetBundleVariant: 9 | -------------------------------------------------------------------------------- /UnityProject/Assets/TestLoader.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections; 3 | using System.Collections.Generic; 4 | using UnityEngine; 5 | 6 | public class TestLoader : MonoBehaviour 7 | { 8 | public string fileName; 9 | 10 | // Use this for initialization 11 | void Start() 12 | { 13 | string filePath = System.IO.Path.Combine(Application.streamingAssetsPath, fileName); 14 | IntPtr plyIntPtr = PlyLoaderDll.LoadPly(filePath); 15 | 16 | Mesh mesh = new Mesh(); 17 | mesh.vertices = PlyLoaderDll.GetVertices(plyIntPtr); 18 | mesh.uv = PlyLoaderDll.GetUvs(plyIntPtr); 19 | mesh.normals = PlyLoaderDll.GetNormals(plyIntPtr); 20 | mesh.colors32 = PlyLoaderDll.GetColors(plyIntPtr); 21 | mesh.SetIndices(PlyLoaderDll.GetIndexs(plyIntPtr), MeshTopology.Triangles, 0, true); 22 | mesh.name = "mesh"; 23 | 24 | GameObject go = new GameObject(); 25 | go.name = "meshNew"; 26 | MeshFilter mf = go.AddComponent(); 27 | mf.mesh = mesh; 28 | MeshRenderer mr = go.AddComponent(); 29 | mr.material = new Material(Shader.Find("Unlit/Texture")); 30 | string textureName = PlyLoaderDll.GetTextureName(plyIntPtr); 31 | if (textureName.Length > 0) 32 | { 33 | string texturePath = "file://" + System.IO.Path.Combine(Application.streamingAssetsPath, textureName); 34 | WWW www = new WWW(texturePath); 35 | while (!www.isDone) 36 | { 37 | } 38 | mr.material.mainTexture = www.texture; 39 | } 40 | 41 | PlyLoaderDll.UnLoadPly(plyIntPtr); 42 | } 43 | } -------------------------------------------------------------------------------- /UnityProject/Assets/TestLoader.cs.meta: -------------------------------------------------------------------------------- 1 | fileFormatVersion: 2 2 | guid: bb86dea7acaec414c8a1b6252db112c8 3 | timeCreated: 1504696153 4 | licenseType: Pro 5 | MonoImporter: 6 | serializedVersion: 2 7 | defaultReferences: [] 8 | executionOrder: 0 9 | icon: {instanceID: 0} 10 | userData: 11 | assetBundleName: 12 | assetBundleVariant: 13 | -------------------------------------------------------------------------------- /UnityProject/Assets/main.unity.meta: -------------------------------------------------------------------------------- 1 | fileFormatVersion: 2 2 | guid: 19b7060dcd8da2b4fbf5322471972141 3 | timeCreated: 1479143027 4 | licenseType: Free 5 | DefaultImporter: 6 | userData: 7 | assetBundleName: 8 | assetBundleVariant: 9 | -------------------------------------------------------------------------------- /UnityProject/ProjectSettings/AudioManager.asset: -------------------------------------------------------------------------------- 1 | %YAML 1.1 2 | %TAG !u! tag:unity3d.com,2011: 3 | --- !u!11 &1 4 | AudioManager: 5 | m_ObjectHideFlags: 0 6 | m_Volume: 1 7 | Rolloff Scale: 1 8 | Doppler Factor: 1 9 | Default Speaker Mode: 2 10 | m_SampleRate: 0 11 | m_DSPBufferSize: 0 12 | m_VirtualVoiceCount: 512 13 | m_RealVoiceCount: 32 14 | m_SpatializerPlugin: 15 | m_DisableAudio: 0 16 | m_VirtualizeEffects: 1 17 | -------------------------------------------------------------------------------- /UnityProject/ProjectSettings/ClusterInputManager.asset: -------------------------------------------------------------------------------- 1 | %YAML 1.1 2 | %TAG !u! tag:unity3d.com,2011: 3 | --- !u!236 &1 4 | ClusterInputManager: 5 | m_ObjectHideFlags: 0 6 | m_Inputs: [] 7 | -------------------------------------------------------------------------------- /UnityProject/ProjectSettings/DynamicsManager.asset: -------------------------------------------------------------------------------- 1 | %YAML 1.1 2 | %TAG !u! tag:unity3d.com,2011: 3 | --- !u!55 &1 4 | PhysicsManager: 5 | m_ObjectHideFlags: 0 6 | serializedVersion: 2 7 | m_Gravity: {x: 0, y: -9.81, z: 0} 8 | m_DefaultMaterial: {fileID: 0} 9 | m_BounceThreshold: 2 10 | m_SleepThreshold: 0.005 11 | m_DefaultContactOffset: 0.01 12 | m_SolverIterationCount: 6 13 | m_SolverVelocityIterations: 1 14 | m_QueriesHitTriggers: 1 15 | m_EnableAdaptiveForce: 0 16 | m_LayerCollisionMatrix: ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 17 | -------------------------------------------------------------------------------- /UnityProject/ProjectSettings/EditorBuildSettings.asset: -------------------------------------------------------------------------------- 1 | %YAML 1.1 2 | %TAG !u! tag:unity3d.com,2011: 3 | --- !u!1045 &1 4 | EditorBuildSettings: 5 | m_ObjectHideFlags: 0 6 | serializedVersion: 2 7 | m_Scenes: [] 8 | -------------------------------------------------------------------------------- /UnityProject/ProjectSettings/EditorSettings.asset: -------------------------------------------------------------------------------- 1 | %YAML 1.1 2 | %TAG !u! tag:unity3d.com,2011: 3 | --- !u!159 &1 4 | EditorSettings: 5 | m_ObjectHideFlags: 0 6 | serializedVersion: 3 7 | m_ExternalVersionControlSupport: Hidden Meta Files 8 | m_SerializationMode: 2 9 | m_WebSecurityEmulationEnabled: 0 10 | m_WebSecurityEmulationHostUrl: http://www.mydomain.com/mygame.unity3d 11 | m_DefaultBehaviorMode: 0 12 | m_SpritePackerMode: 2 13 | m_SpritePackerPaddingPower: 1 14 | m_ProjectGenerationIncludedExtensions: txt;xml;fnt;cd 15 | m_ProjectGenerationRootNamespace: 16 | -------------------------------------------------------------------------------- /UnityProject/ProjectSettings/GraphicsSettings.asset: -------------------------------------------------------------------------------- 1 | %YAML 1.1 2 | %TAG !u! tag:unity3d.com,2011: 3 | --- !u!30 &1 4 | GraphicsSettings: 5 | m_ObjectHideFlags: 0 6 | serializedVersion: 9 7 | m_Deferred: 8 | m_Mode: 1 9 | m_Shader: {fileID: 69, guid: 0000000000000000f000000000000000, type: 0} 10 | m_DeferredReflections: 11 | m_Mode: 1 12 | m_Shader: {fileID: 74, guid: 0000000000000000f000000000000000, type: 0} 13 | m_ScreenSpaceShadows: 14 | m_Mode: 1 15 | m_Shader: {fileID: 64, guid: 0000000000000000f000000000000000, type: 0} 16 | m_LegacyDeferred: 17 | m_Mode: 1 18 | m_Shader: {fileID: 63, guid: 0000000000000000f000000000000000, type: 0} 19 | m_DepthNormals: 20 | m_Mode: 1 21 | m_Shader: {fileID: 62, guid: 0000000000000000f000000000000000, type: 0} 22 | m_MotionVectors: 23 | m_Mode: 1 24 | m_Shader: {fileID: 75, guid: 0000000000000000f000000000000000, type: 0} 25 | m_LightHalo: 26 | m_Mode: 1 27 | m_Shader: {fileID: 105, guid: 0000000000000000f000000000000000, type: 0} 28 | m_LensFlare: 29 | m_Mode: 1 30 | m_Shader: {fileID: 102, guid: 0000000000000000f000000000000000, type: 0} 31 | m_AlwaysIncludedShaders: 32 | - {fileID: 7, guid: 0000000000000000f000000000000000, type: 0} 33 | - {fileID: 15104, guid: 0000000000000000f000000000000000, type: 0} 34 | - {fileID: 15105, guid: 0000000000000000f000000000000000, type: 0} 35 | - {fileID: 15106, guid: 0000000000000000f000000000000000, type: 0} 36 | - {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0} 37 | - {fileID: 10770, guid: 0000000000000000f000000000000000, type: 0} 38 | - {fileID: 10782, guid: 0000000000000000f000000000000000, type: 0} 39 | m_PreloadedShaders: [] 40 | m_SpritesDefaultMaterial: {fileID: 10754, guid: 0000000000000000f000000000000000, 41 | type: 0} 42 | m_TierSettings_Tier1: 43 | renderingPath: 1 44 | useCascadedShadowMaps: 1 45 | m_TierSettings_Tier2: 46 | renderingPath: 1 47 | useCascadedShadowMaps: 1 48 | m_TierSettings_Tier3: 49 | renderingPath: 1 50 | useCascadedShadowMaps: 1 51 | m_DefaultRenderingPath: 1 52 | m_DefaultMobileRenderingPath: 1 53 | m_TierSettings: [] 54 | m_LightmapStripping: 0 55 | m_FogStripping: 0 56 | m_LightmapKeepPlain: 1 57 | m_LightmapKeepDirCombined: 1 58 | m_LightmapKeepDirSeparate: 1 59 | m_LightmapKeepDynamicPlain: 1 60 | m_LightmapKeepDynamicDirCombined: 1 61 | m_LightmapKeepDynamicDirSeparate: 1 62 | m_FogKeepLinear: 1 63 | m_FogKeepExp: 1 64 | m_FogKeepExp2: 1 65 | -------------------------------------------------------------------------------- /UnityProject/ProjectSettings/NavMeshAreas.asset: -------------------------------------------------------------------------------- 1 | %YAML 1.1 2 | %TAG !u! tag:unity3d.com,2011: 3 | --- !u!126 &1 4 | NavMeshAreas: 5 | m_ObjectHideFlags: 0 6 | serializedVersion: 2 7 | areas: 8 | - name: Walkable 9 | cost: 1 10 | - name: Not Walkable 11 | cost: 1 12 | - name: Jump 13 | cost: 2 14 | - name: 15 | cost: 1 16 | - name: 17 | cost: 1 18 | - name: 19 | cost: 1 20 | - name: 21 | cost: 1 22 | - name: 23 | cost: 1 24 | - name: 25 | cost: 1 26 | - name: 27 | cost: 1 28 | - name: 29 | cost: 1 30 | - name: 31 | cost: 1 32 | - name: 33 | cost: 1 34 | - name: 35 | cost: 1 36 | - name: 37 | cost: 1 38 | - name: 39 | cost: 1 40 | - name: 41 | cost: 1 42 | - name: 43 | cost: 1 44 | - name: 45 | cost: 1 46 | - name: 47 | cost: 1 48 | - name: 49 | cost: 1 50 | - name: 51 | cost: 1 52 | - name: 53 | cost: 1 54 | - name: 55 | cost: 1 56 | - name: 57 | cost: 1 58 | - name: 59 | cost: 1 60 | - name: 61 | cost: 1 62 | - name: 63 | cost: 1 64 | - name: 65 | cost: 1 66 | - name: 67 | cost: 1 68 | - name: 69 | cost: 1 70 | - name: 71 | cost: 1 72 | -------------------------------------------------------------------------------- /UnityProject/ProjectSettings/NetworkManager.asset: -------------------------------------------------------------------------------- 1 | %YAML 1.1 2 | %TAG !u! tag:unity3d.com,2011: 3 | --- !u!149 &1 4 | NetworkManager: 5 | m_ObjectHideFlags: 0 6 | m_DebugLevel: 0 7 | m_Sendrate: 15 8 | m_AssetToPrefab: {} 9 | -------------------------------------------------------------------------------- /UnityProject/ProjectSettings/Physics2DSettings.asset: -------------------------------------------------------------------------------- 1 | %YAML 1.1 2 | %TAG !u! tag:unity3d.com,2011: 3 | --- !u!19 &1 4 | Physics2DSettings: 5 | m_ObjectHideFlags: 0 6 | serializedVersion: 2 7 | m_Gravity: {x: 0, y: -9.81} 8 | m_DefaultMaterial: {fileID: 0} 9 | m_VelocityIterations: 8 10 | m_PositionIterations: 3 11 | m_VelocityThreshold: 1 12 | m_MaxLinearCorrection: 0.2 13 | m_MaxAngularCorrection: 8 14 | m_MaxTranslationSpeed: 100 15 | m_MaxRotationSpeed: 360 16 | m_MinPenetrationForPenalty: 0.01 17 | m_BaumgarteScale: 0.2 18 | m_BaumgarteTimeOfImpactScale: 0.75 19 | m_TimeToSleep: 0.5 20 | m_LinearSleepTolerance: 0.01 21 | m_AngularSleepTolerance: 2 22 | m_QueriesHitTriggers: 1 23 | m_QueriesStartInColliders: 1 24 | m_ChangeStopsCallbacks: 0 25 | m_AlwaysShowColliders: 0 26 | m_ShowColliderSleep: 1 27 | m_ShowColliderContacts: 0 28 | m_ContactArrowScale: 0.2 29 | m_ColliderAwakeColor: {r: 0.5686275, g: 0.95686275, b: 0.54509807, a: 0.7529412} 30 | m_ColliderAsleepColor: {r: 0.5686275, g: 0.95686275, b: 0.54509807, a: 0.36078432} 31 | m_ColliderContactColor: {r: 1, g: 0, b: 1, a: 0.6862745} 32 | m_LayerCollisionMatrix: ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 33 | -------------------------------------------------------------------------------- /UnityProject/ProjectSettings/ProjectVersion.txt: -------------------------------------------------------------------------------- 1 | m_EditorVersion: 5.5.0p1 2 | -------------------------------------------------------------------------------- /UnityProject/ProjectSettings/TagManager.asset: -------------------------------------------------------------------------------- 1 | %YAML 1.1 2 | %TAG !u! tag:unity3d.com,2011: 3 | --- !u!78 &1 4 | TagManager: 5 | serializedVersion: 2 6 | tags: [] 7 | layers: 8 | - Default 9 | - TransparentFX 10 | - Ignore Raycast 11 | - 12 | - Water 13 | - UI 14 | - 15 | - 16 | - 17 | - 18 | - 19 | - 20 | - 21 | - 22 | - 23 | - 24 | - 25 | - 26 | - 27 | - 28 | - 29 | - 30 | - 31 | - 32 | - 33 | - 34 | - 35 | - 36 | - 37 | - 38 | - 39 | - 40 | m_SortingLayers: 41 | - name: Default 42 | uniqueID: 0 43 | locked: 0 44 | -------------------------------------------------------------------------------- /UnityProject/ProjectSettings/TimeManager.asset: -------------------------------------------------------------------------------- 1 | %YAML 1.1 2 | %TAG !u! tag:unity3d.com,2011: 3 | --- !u!5 &1 4 | TimeManager: 5 | m_ObjectHideFlags: 0 6 | Fixed Timestep: 0.02 7 | Maximum Allowed Timestep: 0.33333334 8 | m_TimeScale: 1 9 | -------------------------------------------------------------------------------- /UnityProject/ProjectSettings/UnityConnectSettings.asset: -------------------------------------------------------------------------------- 1 | %YAML 1.1 2 | %TAG !u! tag:unity3d.com,2011: 3 | --- !u!310 &1 4 | UnityConnectSettings: 5 | m_ObjectHideFlags: 0 6 | m_Enabled: 0 7 | m_TestMode: 0 8 | m_TestEventUrl: 9 | m_TestConfigUrl: 10 | CrashReportingSettings: 11 | m_EventUrl: https://perf-events.cloud.unity3d.com/api/events/crashes 12 | m_Enabled: 0 13 | m_CaptureEditorExceptions: 1 14 | UnityPurchasingSettings: 15 | m_Enabled: 0 16 | m_TestMode: 0 17 | UnityAnalyticsSettings: 18 | m_Enabled: 1 19 | m_InitializeOnStartup: 1 20 | m_TestMode: 0 21 | m_TestEventUrl: 22 | m_TestConfigUrl: 23 | UnityAdsSettings: 24 | m_Enabled: 0 25 | m_InitializeOnStartup: 1 26 | m_TestMode: 0 27 | m_EnabledPlatforms: 4294967295 28 | m_IosGameId: 29 | m_AndroidGameId: 30 | --------------------------------------------------------------------------------