├── .DS_Store ├── DevelopApp.sln ├── DevelopApp ├── Compute │ ├── Development │ │ ├── AndersonAcceleration.h │ │ ├── MeshDevelop.cpp │ │ ├── MeshDevelop.h │ │ ├── MeshLaplace.cpp │ │ ├── MeshLaplace.h │ │ ├── MeshTopo.cpp │ │ ├── MeshTopo.h │ │ ├── TriInequality.cpp │ │ ├── TriInequality.h │ │ ├── Types.h │ │ └── svd │ │ │ ├── Singular_Value_Decomposition_Givens_QR_Factorization_Kernel.hpp │ │ │ ├── Singular_Value_Decomposition_Jacobi_Conjugation_Kernel.hpp │ │ │ ├── Singular_Value_Decomposition_Kernel_Declarations.hpp │ │ │ ├── Singular_Value_Decomposition_Main_Kernel_Body.hpp │ │ │ ├── Singular_Value_Decomposition_Preamble.hpp │ │ │ └── svd.hpp │ ├── Optimization.cpp │ ├── Optimization.h │ ├── Refinement │ │ ├── GaussMin.cpp │ │ ├── GaussMin.h │ │ ├── Merge.cpp │ │ └── Merge.h │ ├── SegMesh.cpp │ ├── SegMesh.h │ └── Segmentation │ │ ├── CurSegCut.cpp │ │ ├── CurSegCut.h │ │ ├── DiffSegCut.cpp │ │ ├── DiffSegCut.h │ │ ├── FiedlerVector.cpp │ │ ├── FiedlerVector.h │ │ ├── SegCut.cpp │ │ ├── SegCut.h │ │ ├── Segment.cpp │ │ ├── Segment.h │ │ ├── matlab_utils.cpp │ │ └── matlab_utils.h ├── DevelopApp.cpp ├── DevelopApp.vcxproj ├── DevelopApp.vcxproj.filters ├── DevelopApp.vcxproj.user ├── Include │ ├── Eigen │ │ ├── CMakeLists.txt │ │ ├── Cholesky │ │ ├── CholmodSupport │ │ ├── Core │ │ ├── Dense │ │ ├── Eigen │ │ ├── Eigenvalues │ │ ├── Geometry │ │ ├── Householder │ │ ├── IterativeLinearSolvers │ │ ├── Jacobi │ │ ├── LU │ │ ├── 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_LAPACKE.h │ │ │ ├── CholmodSupport │ │ │ ├── CMakeLists.txt │ │ │ └── CholmodSupport.h │ │ │ ├── Core │ │ │ ├── Array.h │ │ │ ├── ArrayBase.h │ │ │ ├── ArrayWrapper.h │ │ │ ├── Assign.h │ │ │ ├── AssignEvaluator.h │ │ │ ├── Assign_MKL.h │ │ │ ├── BandMatrix.h │ │ │ ├── Block.h │ │ │ ├── BooleanRedux.h │ │ │ ├── CMakeLists.txt │ │ │ ├── CommaInitializer.h │ │ │ ├── ConditionEstimator.h │ │ │ ├── CoreEvaluators.h │ │ │ ├── CoreIterators.h │ │ │ ├── CwiseBinaryOp.h │ │ │ ├── CwiseNullaryOp.h │ │ │ ├── CwiseTernaryOp.h │ │ │ ├── CwiseUnaryOp.h │ │ │ ├── CwiseUnaryView.h │ │ │ ├── DenseBase.h │ │ │ ├── DenseCoeffsBase.h │ │ │ ├── DenseStorage.h │ │ │ ├── Diagonal.h │ │ │ ├── DiagonalMatrix.h │ │ │ ├── DiagonalProduct.h │ │ │ ├── Dot.h │ │ │ ├── EigenBase.h │ │ │ ├── ForceAlignedAccess.h │ │ │ ├── Fuzzy.h │ │ │ ├── GeneralProduct.h │ │ │ ├── GenericPacketMath.h │ │ │ ├── GlobalFunctions.h │ │ │ ├── IO.h │ │ │ ├── Inverse.h │ │ │ ├── Map.h │ │ │ ├── MapBase.h │ │ │ ├── MathFunctions.h │ │ │ ├── Matrix.h │ │ │ ├── MatrixBase.h │ │ │ ├── NestByValue.h │ │ │ ├── NoAlias.h │ │ │ ├── NumTraits.h │ │ │ ├── PermutationMatrix.h │ │ │ ├── PlainObjectBase.h │ │ │ ├── Product.h │ │ │ ├── ProductEvaluators.h │ │ │ ├── Random.h │ │ │ ├── Redux.h │ │ │ ├── Ref.h │ │ │ ├── Replicate.h │ │ │ ├── ReturnByValue.h │ │ │ ├── Reverse.h │ │ │ ├── Select.h │ │ │ ├── SelfAdjointView.h │ │ │ ├── SelfCwiseBinaryOp.h │ │ │ ├── Solve.h │ │ │ ├── SolveTriangular.h │ │ │ ├── SolverBase.h │ │ │ ├── StableNorm.h │ │ │ ├── Stride.h │ │ │ ├── Swap.h │ │ │ ├── Transpose.h │ │ │ ├── Transpositions.h │ │ │ ├── TriangularMatrix.h │ │ │ ├── VectorBlock.h │ │ │ ├── VectorwiseOp.h │ │ │ ├── Visitor.h │ │ │ ├── arch │ │ │ │ ├── AVX │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── Complex.h │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ ├── PacketMath.h │ │ │ │ │ └── TypeCasting.h │ │ │ │ ├── AltiVec │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── Complex.h │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ └── PacketMath.h │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── CUDA │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── Half.h │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ ├── PacketMath.h │ │ │ │ │ ├── PacketMathHalf.h │ │ │ │ │ └── TypeCasting.h │ │ │ │ ├── Default │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ └── Settings.h │ │ │ │ ├── NEON │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── Complex.h │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ └── PacketMath.h │ │ │ │ ├── SSE │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── Complex.h │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ ├── PacketMath.h │ │ │ │ │ └── TypeCasting.h │ │ │ │ └── ZVector │ │ │ │ │ ├── CMakeLists.txt │ │ │ │ │ ├── Complex.h │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ └── PacketMath.h │ │ │ ├── functors │ │ │ │ ├── AssignmentFunctors.h │ │ │ │ ├── BinaryFunctors.h │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── NullaryFunctors.h │ │ │ │ ├── StlFunctors.h │ │ │ │ ├── TernaryFunctors.h │ │ │ │ └── UnaryFunctors.h │ │ │ ├── products │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── GeneralBlockPanelKernel.h │ │ │ │ ├── GeneralMatrixMatrix.h │ │ │ │ ├── GeneralMatrixMatrixTriangular.h │ │ │ │ ├── GeneralMatrixMatrixTriangular_BLAS.h │ │ │ │ ├── GeneralMatrixMatrix_BLAS.h │ │ │ │ ├── GeneralMatrixVector.h │ │ │ │ ├── GeneralMatrixVector_BLAS.h │ │ │ │ ├── Parallelizer.h │ │ │ │ ├── SelfadjointMatrixMatrix.h │ │ │ │ ├── SelfadjointMatrixMatrix_BLAS.h │ │ │ │ ├── SelfadjointMatrixVector.h │ │ │ │ ├── SelfadjointMatrixVector_BLAS.h │ │ │ │ ├── SelfadjointProduct.h │ │ │ │ ├── SelfadjointRank2Update.h │ │ │ │ ├── TriangularMatrixMatrix.h │ │ │ │ ├── TriangularMatrixMatrix_BLAS.h │ │ │ │ ├── TriangularMatrixVector.h │ │ │ │ ├── TriangularMatrixVector_BLAS.h │ │ │ │ ├── TriangularSolverMatrix.h │ │ │ │ ├── TriangularSolverMatrix_BLAS.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 │ │ │ ├── Eigenvalues │ │ │ ├── CMakeLists.txt │ │ │ ├── ComplexEigenSolver.h │ │ │ ├── ComplexSchur.h │ │ │ ├── ComplexSchur_LAPACKE.h │ │ │ ├── EigenSolver.h │ │ │ ├── GeneralizedEigenSolver.h │ │ │ ├── GeneralizedSelfAdjointEigenSolver.h │ │ │ ├── HessenbergDecomposition.h │ │ │ ├── MatrixBaseEigenvalues.h │ │ │ ├── RealQZ.h │ │ │ ├── RealSchur.h │ │ │ ├── RealSchur_LAPACKE.h │ │ │ ├── SelfAdjointEigenSolver.h │ │ │ ├── SelfAdjointEigenSolver_LAPACKE.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 │ │ │ ├── IncompleteCholesky.h │ │ │ ├── IncompleteLUT.h │ │ │ ├── IterativeSolverBase.h │ │ │ ├── LeastSquareConjugateGradient.h │ │ │ └── SolveWithGuess.h │ │ │ ├── Jacobi │ │ │ ├── CMakeLists.txt │ │ │ └── Jacobi.h │ │ │ ├── LU │ │ │ ├── CMakeLists.txt │ │ │ ├── Determinant.h │ │ │ ├── FullPivLU.h │ │ │ ├── InverseImpl.h │ │ │ ├── PartialPivLU.h │ │ │ ├── PartialPivLU_LAPACKE.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_LAPACKE.h │ │ │ ├── CompleteOrthogonalDecomposition.h │ │ │ ├── FullPivHouseholderQR.h │ │ │ ├── HouseholderQR.h │ │ │ └── HouseholderQR_LAPACKE.h │ │ │ ├── SPQRSupport │ │ │ ├── CMakeLists.txt │ │ │ └── SuiteSparseQRSupport.h │ │ │ ├── SVD │ │ │ ├── BDCSVD.h │ │ │ ├── CMakeLists.txt │ │ │ ├── JacobiSVD.h │ │ │ ├── JacobiSVD_LAPACKE.h │ │ │ ├── SVDBase.h │ │ │ └── UpperBidiagonalization.h │ │ │ ├── SparseCholesky │ │ │ ├── CMakeLists.txt │ │ │ ├── SimplicialCholesky.h │ │ │ └── SimplicialCholesky_impl.h │ │ │ ├── SparseCore │ │ │ ├── AmbiVector.h │ │ │ ├── CMakeLists.txt │ │ │ ├── CompressedStorage.h │ │ │ ├── ConservativeSparseSparseProduct.h │ │ │ ├── MappedSparseMatrix.h │ │ │ ├── SparseAssign.h │ │ │ ├── SparseBlock.h │ │ │ ├── SparseColEtree.h │ │ │ ├── SparseCompressedBase.h │ │ │ ├── SparseCwiseBinaryOp.h │ │ │ ├── SparseCwiseUnaryOp.h │ │ │ ├── SparseDenseProduct.h │ │ │ ├── SparseDiagonalProduct.h │ │ │ ├── SparseDot.h │ │ │ ├── SparseFuzzy.h │ │ │ ├── SparseMap.h │ │ │ ├── SparseMatrix.h │ │ │ ├── SparseMatrixBase.h │ │ │ ├── SparsePermutation.h │ │ │ ├── SparseProduct.h │ │ │ ├── SparseRedux.h │ │ │ ├── SparseRef.h │ │ │ ├── SparseSelfAdjointView.h │ │ │ ├── SparseSolverBase.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 │ │ │ ├── RealSvd2x2.h │ │ │ ├── blas.h │ │ │ ├── lapack.h │ │ │ ├── lapacke.h │ │ │ └── lapacke_mangling.h │ │ │ └── plugins │ │ │ ├── ArrayCwiseBinaryOps.h │ │ │ ├── ArrayCwiseUnaryOps.h │ │ │ ├── BlockMethods.h │ │ │ ├── CMakeLists.txt │ │ │ ├── CommonCwiseBinaryOps.h │ │ │ ├── CommonCwiseUnaryOps.h │ │ │ ├── MatrixCwiseBinaryOps.h │ │ │ └── MatrixCwiseUnaryOps.h │ └── OpenMesh │ │ ├── Core │ │ ├── Geometry │ │ │ ├── Config.hh │ │ │ ├── EigenVectorT.hh │ │ │ ├── LoopSchemeMaskT.hh │ │ │ ├── MathDefs.hh │ │ │ ├── NormalConeT.hh │ │ │ ├── NormalConeT_impl.hh │ │ │ ├── Plane3d.hh │ │ │ ├── QuadricT.hh │ │ │ ├── Vector11T.hh │ │ │ ├── VectorT.hh │ │ │ └── VectorT_inc.hh │ │ ├── IO │ │ │ ├── BinaryHelper.hh │ │ │ ├── IOInstances.hh │ │ │ ├── IOManager.hh │ │ │ ├── MeshIO.hh │ │ │ ├── OFFFormat.hh │ │ │ ├── OMFormat.hh │ │ │ ├── OMFormatT_impl.hh │ │ │ ├── Options.hh │ │ │ ├── SR_binary.hh │ │ │ ├── SR_binary_spec.hh │ │ │ ├── SR_binary_vector_of_bool.inl │ │ │ ├── SR_binary_vector_of_fundamentals.inl │ │ │ ├── SR_binary_vector_of_string.inl │ │ │ ├── SR_rbo.hh │ │ │ ├── SR_store.hh │ │ │ ├── SR_types.hh │ │ │ ├── StoreRestore.hh │ │ │ ├── exporter │ │ │ │ ├── BaseExporter.hh │ │ │ │ └── ExporterT.hh │ │ │ ├── importer │ │ │ │ ├── BaseImporter.hh │ │ │ │ └── ImporterT.hh │ │ │ ├── reader │ │ │ │ ├── BaseReader.hh │ │ │ │ ├── OBJReader.hh │ │ │ │ ├── OFFReader.hh │ │ │ │ ├── OMReader.hh │ │ │ │ ├── PLYReader.hh │ │ │ │ └── STLReader.hh │ │ │ └── writer │ │ │ │ ├── BaseWriter.hh │ │ │ │ ├── OBJWriter.hh │ │ │ │ ├── OFFWriter.hh │ │ │ │ ├── OMWriter.hh │ │ │ │ ├── PLYWriter.hh │ │ │ │ ├── STLWriter.hh │ │ │ │ └── VTKWriter.hh │ │ ├── Mesh │ │ │ ├── ArrayItems.hh │ │ │ ├── ArrayKernel.hh │ │ │ ├── ArrayKernelT_impl.hh │ │ │ ├── AttribKernelT.hh │ │ │ ├── Attributes.hh │ │ │ ├── BaseKernel.hh │ │ │ ├── BaseMesh.hh │ │ │ ├── Casts.hh │ │ │ ├── CirculatorsT.hh │ │ │ ├── FinalMeshItemsT.hh │ │ │ ├── Handles.hh │ │ │ ├── IteratorsT.hh │ │ │ ├── PolyConnectivity.hh │ │ │ ├── PolyMeshT.hh │ │ │ ├── PolyMeshT_impl.hh │ │ │ ├── PolyMesh_ArrayKernelT.hh │ │ │ ├── Status.hh │ │ │ ├── Tags.hh │ │ │ ├── Traits.hh │ │ │ ├── TriConnectivity.hh │ │ │ ├── TriMeshT.hh │ │ │ ├── TriMeshT_impl.hh │ │ │ ├── TriMesh_ArrayKernelT.hh │ │ │ └── gen │ │ │ │ ├── circulators_header.hh │ │ │ │ ├── circulators_template.hh │ │ │ │ ├── footer.hh │ │ │ │ ├── iterators_header.hh │ │ │ │ └── iterators_template.hh │ │ ├── System │ │ │ ├── OpenMeshDLLMacros.hh │ │ │ ├── compiler.hh │ │ │ ├── config.h │ │ │ ├── config.hh │ │ │ ├── mostream.hh │ │ │ └── omstream.hh │ │ └── Utils │ │ │ ├── AutoPropertyHandleT.hh │ │ │ ├── BaseProperty.hh │ │ │ ├── Endian.hh │ │ │ ├── GenProg.hh │ │ │ ├── HandleToPropHandle.hh │ │ │ ├── Noncopyable.hh │ │ │ ├── Property.hh │ │ │ ├── PropertyContainer.hh │ │ │ ├── PropertyManager.hh │ │ │ ├── RandomNumberGenerator.hh │ │ │ ├── SingletonT.hh │ │ │ ├── SingletonT_impl.hh │ │ │ ├── color_cast.hh │ │ │ ├── vector_cast.hh │ │ │ └── vector_traits.hh │ │ └── Tools │ │ ├── Decimater │ │ ├── BaseDecimaterT.hh │ │ ├── BaseDecimaterT_impl.hh │ │ ├── CollapseInfoT.hh │ │ ├── DecimaterT.hh │ │ ├── DecimaterT_impl.hh │ │ ├── McDecimaterT.hh │ │ ├── McDecimaterT_impl.hh │ │ ├── MixedDecimaterT.hh │ │ ├── MixedDecimaterT_impl.hh │ │ ├── ModAspectRatioT.hh │ │ ├── ModAspectRatioT_impl.hh │ │ ├── ModBaseT.hh │ │ ├── ModEdgeLengthT.hh │ │ ├── ModEdgeLengthT_impl.hh │ │ ├── ModHausdorffT.hh │ │ ├── ModHausdorffT_impl.hh │ │ ├── ModIndependentSetsT.hh │ │ ├── ModNormalDeviationT.hh │ │ ├── ModNormalFlippingT.hh │ │ ├── ModProgMeshT.hh │ │ ├── ModProgMeshT_impl.hh │ │ ├── ModQuadricT.hh │ │ ├── ModQuadricT_impl.hh │ │ ├── ModRoundnessT.hh │ │ └── Observer.hh │ │ ├── Dualizer │ │ └── meshDualT.hh │ │ ├── Kernel_OSG │ │ ├── ArrayKernelT.hh │ │ ├── AttribKernelT.hh │ │ ├── PropertyKernel.hh │ │ ├── PropertyT.hh │ │ ├── Traits.hh │ │ ├── TriMesh_OSGArrayKernelT.hh │ │ ├── VectorAdapter.hh │ │ ├── bindT.hh │ │ └── color_cast.hh │ │ ├── SmartTagger │ │ ├── SmartTaggerT.hh │ │ └── SmartTaggerT_impl.hh │ │ ├── Smoother │ │ ├── JacobiLaplaceSmootherT.hh │ │ ├── JacobiLaplaceSmootherT_impl.hh │ │ ├── LaplaceSmootherT.hh │ │ ├── LaplaceSmootherT_impl.hh │ │ ├── SmootherT.hh │ │ ├── SmootherT_impl.hh │ │ └── smooth_mesh.hh │ │ ├── Subdivider │ │ ├── Adaptive │ │ │ └── Composite │ │ │ │ ├── CompositeT.hh │ │ │ │ ├── CompositeT_impl.hh │ │ │ │ ├── CompositeTraits.hh │ │ │ │ ├── RuleInterfaceT.hh │ │ │ │ ├── RulesT.hh │ │ │ │ ├── RulesT_impl.hh │ │ │ │ └── Traits.hh │ │ └── Uniform │ │ │ ├── CatmullClarkT.hh │ │ │ ├── CatmullClarkT_impl.hh │ │ │ ├── Composite │ │ │ ├── CompositeT.hh │ │ │ ├── CompositeT_impl.hh │ │ │ └── CompositeTraits.hh │ │ │ ├── CompositeLoopT.hh │ │ │ ├── CompositeSqrt3T.hh │ │ │ ├── LongestEdgeT.hh │ │ │ ├── LoopT.hh │ │ │ ├── MidpointT.hh │ │ │ ├── ModifiedButterFlyT.hh │ │ │ ├── Sqrt3InterpolatingSubdividerLabsikGreinerT.hh │ │ │ ├── Sqrt3T.hh │ │ │ └── SubdividerT.hh │ │ ├── Utils │ │ ├── Config.hh │ │ ├── GLConstAsString.hh │ │ ├── Gnuplot.hh │ │ ├── HeapT.hh │ │ ├── MeshCheckerT.hh │ │ ├── MeshCheckerT_impl.hh │ │ ├── NumLimitsT.hh │ │ ├── StripifierT.hh │ │ ├── StripifierT_impl.hh │ │ ├── TestingFramework.hh │ │ ├── Timer.hh │ │ ├── conio.hh │ │ └── getopt.h │ │ └── VDPM │ │ ├── MeshTraits.hh │ │ ├── StreamingDef.hh │ │ ├── VFront.hh │ │ ├── VHierarchy.hh │ │ ├── VHierarchyNode.hh │ │ ├── VHierarchyNodeIndex.hh │ │ ├── VHierarchyWindow.hh │ │ └── ViewingParameters.hh ├── Library │ ├── OpenMeshCore.lib │ ├── OpenMeshCored.lib │ ├── OpenMeshTools.lib │ └── OpenMeshToolsd.lib ├── MeshDefinition.cpp ├── MeshDefinition.h ├── mesh_data │ ├── Bunny │ │ ├── deform_0.obj │ │ ├── deform_1.obj │ │ ├── deform_2.obj │ │ ├── deform_3.obj │ │ ├── deform_4.obj │ │ ├── deform_5.obj │ │ ├── deform_6.obj │ │ ├── deform_7.obj │ │ ├── deform_8.obj │ │ ├── deform_9.obj │ │ ├── deform_and_seg_information.txt │ │ ├── deformation_energy.txt │ │ ├── final.obj │ │ ├── final_seg.txt │ │ ├── first_deform.obj │ │ ├── first_deform_seg.txt │ │ ├── min_0.obj │ │ ├── min_1.obj │ │ ├── min_2.obj │ │ ├── min_3.obj │ │ ├── min_4.obj │ │ ├── min_5.obj │ │ ├── min_seg_0.txt │ │ ├── min_seg_1.txt │ │ ├── min_seg_2.txt │ │ ├── min_seg_3.txt │ │ ├── min_seg_4.txt │ │ ├── min_seg_5.txt │ │ ├── smooth.obj │ │ └── smooth_seg.txt │ └── Tortiose │ │ ├── deform_0.obj │ │ ├── deform_1.obj │ │ ├── deform_2.obj │ │ ├── deform_3.obj │ │ ├── deform_4.obj │ │ ├── deform_5.obj │ │ ├── deform_6.obj │ │ ├── deform_7.obj │ │ ├── deform_8.obj │ │ ├── deform_9.obj │ │ ├── deform_and_seg_information.txt │ │ ├── deformation_energy.txt │ │ ├── final.obj │ │ ├── final_seg.txt │ │ ├── first_deform.obj │ │ ├── first_deform_seg.txt │ │ ├── min_0.obj │ │ ├── min_1.obj │ │ ├── min_2.obj │ │ ├── min_3.obj │ │ ├── min_4.obj │ │ ├── min_5.obj │ │ ├── min_6.obj │ │ ├── min_seg_0.txt │ │ ├── min_seg_1.txt │ │ ├── min_seg_2.txt │ │ ├── min_seg_3.txt │ │ ├── min_seg_4.txt │ │ ├── min_seg_5.txt │ │ ├── min_seg_6.txt │ │ ├── smooth.obj │ │ └── smooth_seg.txt └── model │ ├── Bunny.obj │ └── Tortoise.obj └── README.md /.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/QingFang1208/DevelopApp/cccfc3fbba6adc686ab9fa8602844ba221a49792/.DS_Store -------------------------------------------------------------------------------- /DevelopApp.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio Version 16 4 | VisualStudioVersion = 16.0.31313.79 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DevelopApp", "DevelopApp\DevelopApp.vcxproj", "{B304BABA-98CA-4B18-BFCD-945714819C2A}" 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 | {B304BABA-98CA-4B18-BFCD-945714819C2A}.Debug|x64.ActiveCfg = Debug|x64 17 | {B304BABA-98CA-4B18-BFCD-945714819C2A}.Debug|x64.Build.0 = Debug|x64 18 | {B304BABA-98CA-4B18-BFCD-945714819C2A}.Debug|x86.ActiveCfg = Debug|Win32 19 | {B304BABA-98CA-4B18-BFCD-945714819C2A}.Debug|x86.Build.0 = Debug|Win32 20 | {B304BABA-98CA-4B18-BFCD-945714819C2A}.Release|x64.ActiveCfg = Release|x64 21 | {B304BABA-98CA-4B18-BFCD-945714819C2A}.Release|x64.Build.0 = Release|x64 22 | {B304BABA-98CA-4B18-BFCD-945714819C2A}.Release|x86.ActiveCfg = Release|Win32 23 | {B304BABA-98CA-4B18-BFCD-945714819C2A}.Release|x86.Build.0 = Release|Win32 24 | EndGlobalSection 25 | GlobalSection(SolutionProperties) = preSolution 26 | HideSolutionNode = FALSE 27 | EndGlobalSection 28 | GlobalSection(ExtensibilityGlobals) = postSolution 29 | SolutionGuid = {D1B693AA-AD53-42F9-982E-93953948B620} 30 | EndGlobalSection 31 | EndGlobal 32 | -------------------------------------------------------------------------------- /DevelopApp/Compute/Development/MeshDevelop.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "MeshLaplace.h" 3 | #include "AndersonAcceleration.h" 4 | #include "TriInequality.h" 5 | using Eigen::MatrixXd; 6 | using Eigen::VectorXd; 7 | using Eigen::Vector3d; 8 | using Eigen::Matrix3d; 9 | using std::vector; 10 | using SPMatrixXd = Eigen::SparseMatrix; 11 | 12 | #define USE_FAST_SVD 13 | 14 | class MeshDevelop 15 | { 16 | public: 17 | MeshDevelop(); 18 | void oriMesh(const Mesh& mesh); 19 | void tarMesh(const Mesh& mesh, double dist); 20 | void outMesh(Mesh& mesh); 21 | 22 | double develop(int maxIter = 2e4); 23 | 24 | void GetDevelopEnergy(std::vector& energy) { 25 | energy = dev_energy; 26 | } 27 | 28 | 29 | private: 30 | Mesh tmp; 31 | MeshTopo m_topo; 32 | MatrixXd m_vpfnen; 33 | MatrixXd m_vpfnen0; 34 | MatrixXd m_eb0, m_vt; 35 | VectorXd m_el, m_ew, m_ed, m_es, m_eA, m_fA, m_vA; 36 | MatrixXd m_fDhDeReU; // 9 * size 37 | 38 | std::vector m_fixV; 39 | std::vector> m_svd; 40 | std::vector m_svdM, m_svdU, m_svdV; 41 | std::vector m_svdA; 42 | 43 | std::vector> m_eig; 44 | 45 | double m_wD = 1.0; 46 | //double m_wD = 0.1; 47 | double m_wP = 1e3; 48 | double m_similar = 0; 49 | double m_dist; 50 | double m_scale; 51 | 52 | SPMatrixXd m_lap, m_elap; 53 | Eigen::SimplicialLDLT m_ldlt; 54 | std::unique_ptr AA; 55 | TriInequality triNeq; 56 | 57 | // Develop energy 58 | std::vector dev_energy; 59 | 60 | 61 | private: 62 | void localStep(); 63 | void globalStep(); 64 | void updateN(); 65 | void updateV(); 66 | void updatePara(int iter); 67 | 68 | void calcEN(); 69 | void calcFN(); 70 | 71 | void updateD(); 72 | void updateEU(); 73 | void updateER(); 74 | void updateVP(); 75 | void updateVT(); 76 | void updateES(); 77 | 78 | double energy(); 79 | double energyD(); 80 | double energyFN(); 81 | double energyDP(); 82 | double energyRP(); 83 | 84 | bool inBound(); 85 | 86 | 87 | private: 88 | std::vector EN0_i_00; 89 | std::vector EN0_i_01; 90 | std::vector EN0_i_02; 91 | std::vector EN0_i_03; 92 | std::vector EN0_i_10; 93 | std::vector EN0_i_11; 94 | std::vector EN0_i_12; 95 | std::vector EN0_i_13; 96 | std::vector EN0_i_20; 97 | std::vector EN0_i_21; 98 | std::vector EN0_i_22; 99 | std::vector EN0_i_23; 100 | 101 | std::vector EN_i_00; 102 | std::vector EN_i_01; 103 | std::vector EN_i_02; 104 | std::vector EN_i_03; 105 | std::vector EN_i_10; 106 | std::vector EN_i_11; 107 | std::vector EN_i_12; 108 | std::vector EN_i_13; 109 | std::vector EN_i_20; 110 | std::vector EN_i_21; 111 | std::vector EN_i_22; 112 | std::vector EN_i_23; 113 | 114 | 115 | std::vector e0fn0_i_0; 116 | std::vector e0fn0_i_1; 117 | std::vector e0fn0_i_2; 118 | std::vector e0fn_i_0; 119 | std::vector e0fn_i_1; 120 | std::vector e0fn_i_2; 121 | std::vector e1fn0_i_0; 122 | std::vector e1fn0_i_1; 123 | std::vector e1fn0_i_2; 124 | std::vector e1fn_i_0; 125 | std::vector e1fn_i_1; 126 | std::vector e1fn_i_2; 127 | 128 | std::vector diag_i_0; 129 | std::vector diag_i_1; 130 | std::vector diag_i_2; 131 | std::vector diag_i_3; 132 | }; -------------------------------------------------------------------------------- /DevelopApp/Compute/Development/MeshLaplace.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "MeshTopo.h" 3 | #include 4 | 5 | void faceArea(const OpenMesh::Vec3d* points, const MeshTopo& topo, std::vector& fA); 6 | void faceArea(const Mesh& mesh, std::vector& fA); 7 | void vertArea(const OpenMesh::Vec3d* points, const MeshTopo& topo, std::vector& vA); 8 | void vertArea(const Mesh& mesh, std::vector& vA); 9 | void vertGauss(const OpenMesh::Vec3d* points, const MeshTopo& topo, std::vector& vK); 10 | void vertGauss(const Mesh& mesh, std::vector& vK); 11 | void vertNormal(const OpenMesh::Vec3d* points, const MeshTopo& topo, std::vector& vN); 12 | void vertNormal(const Mesh& mesh, std::vector& vN); 13 | void faceAngle(const OpenMesh::Vec3d* points, const MeshTopo& topo, std::vector& f2a); 14 | void faceAngle(const Mesh& mesh, std::vector& f2a); 15 | void laplaceTriplet(const OpenMesh::Vec3d* points, const MeshTopo& topo, std::vector>& trips); 16 | void laplaceTriplet(const Mesh& mesh, std::vector>& trips); 17 | 18 | -------------------------------------------------------------------------------- /DevelopApp/Compute/Development/MeshTopo.cpp: -------------------------------------------------------------------------------- 1 | #include "MeshTopo.h" 2 | using OpenMesh::Vec3i; 3 | 4 | MeshTopo::MeshTopo() 5 | { 6 | 7 | } 8 | 9 | MeshTopo::MeshTopo(const Mesh& mesh) 10 | { 11 | init(mesh); 12 | } 13 | 14 | void MeshTopo::init(const Mesh& mesh) 15 | { 16 | vN = mesh.n_vertices(); fN = mesh.n_faces(); eN = mesh.n_edges(); hN = mesh.n_halfedges(); 17 | 18 | vb.assign(vN, false); h2f.assign(hN, -1); h2v.assign(hN, -1); 19 | f2v.assign(fN, Vec3i(-1)); f2f.assign(fN, Vec3i(-1)); f2h.assign(fN, Vec3i(-1)); 20 | 21 | for (auto hh : mesh.halfedges()) 22 | { 23 | h2f[hh.idx()] = mesh.face_handle(hh).idx(); 24 | h2v[hh.idx()] = mesh.to_vertex_handle(hh).idx(); 25 | 26 | vb[h2v[hh.idx()]] = vb[h2v[hh.idx()]] || (h2f[hh.idx()] < 0); 27 | } 28 | 29 | for (auto fh : mesh.faces()) 30 | { 31 | auto fh_it(mesh.cfh_iter(fh)); 32 | f2h[fh.idx()][0] = fh_it->idx(); f2v[fh.idx()][0] = mesh.to_vertex_handle(*fh_it).idx(); ++fh_it; 33 | f2h[fh.idx()][1] = fh_it->idx(); f2v[fh.idx()][1] = mesh.to_vertex_handle(*fh_it).idx(); ++fh_it; 34 | f2h[fh.idx()][2] = fh_it->idx(); f2v[fh.idx()][2] = mesh.to_vertex_handle(*fh_it).idx(); 35 | 36 | f2f[fh.idx()][0] = h2f[f2h[fh.idx()][0] ^ 1]; 37 | f2f[fh.idx()][1] = h2f[f2h[fh.idx()][1] ^ 1]; 38 | f2f[fh.idx()][2] = h2f[f2h[fh.idx()][2] ^ 1]; 39 | } 40 | 41 | phfToE(); 42 | } 43 | 44 | void MeshTopo::clear() 45 | { 46 | vN = 0; fN = 0; hN = 0; 47 | 48 | vb.clear(); h2f.clear(); h2v.clear(); 49 | f2v.clear(); f2f.clear(); f2h.clear(); 50 | } 51 | 52 | void MeshTopo::phfToE() 53 | { 54 | phf2e.clear(); 55 | phf2e.assign(h2f.size(), Vec3i(-1)); 56 | 57 | for (auto fh : f2h) 58 | { 59 | if (h2f[fh[0] ^ 1] >= 0) 60 | { 61 | phf2e[fh[0]][0] = fh[0] >> 1; 62 | phf2e[fh[0]][1] = fh[2] >> 1; 63 | phf2e[fh[0] ^ 1][2] = fh[1] >> 1; 64 | } 65 | 66 | if (h2f[fh[1] ^ 1] >= 0) 67 | { 68 | phf2e[fh[1]][0] = fh[1] >> 1; 69 | phf2e[fh[1]][1] = fh[0] >> 1; 70 | phf2e[fh[1] ^ 1][2] = fh[2] >> 1; 71 | } 72 | 73 | if (h2f[fh[2] ^ 1] >= 0) 74 | { 75 | phf2e[fh[2]][0] = fh[2] >> 1; 76 | phf2e[fh[2]][1] = fh[1] >> 1; 77 | phf2e[fh[2] ^ 1][2] = fh[0] >> 1; 78 | } 79 | } 80 | } -------------------------------------------------------------------------------- /DevelopApp/Compute/Development/MeshTopo.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../MeshDefinition.h" 3 | 4 | struct MeshTopo 5 | { 6 | int vN = 0, fN = 0, eN=0, hN = 0; 7 | std::vector vb; 8 | std::vector h2f, h2v; 9 | std::vector f2v, f2f, f2h, phf2e; 10 | 11 | MeshTopo(); 12 | MeshTopo(const Mesh& mesh); 13 | void init(const Mesh& mesh); 14 | void clear(); 15 | 16 | void phfToE(); 17 | }; 18 | 19 | void phfToE(const MeshTopo& topo, std::vector& phf2e); 20 | -------------------------------------------------------------------------------- /DevelopApp/Compute/Development/TriInequality.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | using Eigen::VectorXd; 5 | using Eigen::MatrixXd; 6 | using Eigen::MatrixXi; 7 | using SPMatrixXd = Eigen::SparseMatrix; 8 | 9 | class TriInequality 10 | { 11 | public: 12 | TriInequality(); 13 | TriInequality(const VectorXd& l0_, const MatrixXi& E_, double similar, const VectorXd& eps_); 14 | void init(const VectorXd& l0_, const MatrixXi& E_, double similar_, const VectorXd& eps_); 15 | VectorXd opt(const VectorXd& lt_, int maxIters = 1e3); 16 | 17 | private: 18 | VectorXd m_l, m_lt, m_l0; 19 | MatrixXi m_E; 20 | 21 | MatrixXd m_SL, m_lambda; 22 | Eigen::SimplicialLDLT m_solver; 23 | 24 | public: 25 | VectorXd m_eps; 26 | double m_s; 27 | 28 | private: 29 | void updateL(); 30 | void updateSL(); 31 | void updateLambda(); 32 | bool istri(); 33 | bool converge(); 34 | }; 35 | 36 | 37 | 38 | -------------------------------------------------------------------------------- /DevelopApp/Compute/Development/Types.h: -------------------------------------------------------------------------------- 1 | #ifndef TYPES_H 2 | #define TYPES_H 3 | 4 | #include 5 | #include 6 | 7 | #ifdef USE_FLOAT_SCALAR 8 | typedef float Scalar 9 | #else 10 | typedef double Scalar; 11 | #endif 12 | 13 | typedef Eigen::SparseMatrix ColMajorSparseMatrix; 14 | typedef Eigen::SparseMatrix RowMajorSparseMatrix; 15 | typedef Eigen::Triplet Triplet; 16 | 17 | #ifdef EIGEN_DONT_ALIGN 18 | #define EIGEN_ALIGNMENT Eigen::DontAlign 19 | #else 20 | #define EIGEN_ALIGNMENT Eigen::AutoAlign 21 | #endif 22 | 23 | template 24 | using MatrixT = Eigen::Matrix; ///< A typedef of the dense matrix of Eigen. 25 | typedef MatrixT<2, 1> Vector2; ///< A 2d column vector. 26 | typedef MatrixT<2, 2> Matrix22; ///< A 2 by 2 matrix. 27 | typedef MatrixT<2, 3> Matrix23; ///< A 2 by 3 matrix. 28 | typedef MatrixT<3, 1> Vector3; ///< A 3d column vector. 29 | typedef MatrixT<3, 2> Matrix32; ///< A 3 by 2 matrix. 30 | typedef MatrixT<3, 3> Matrix33; ///< A 3 by 3 matrix. 31 | typedef MatrixT<3, 4> Matrix34; ///< A 3 by 4 matrix. 32 | typedef MatrixT<4, 1> Vector4; ///< A 4d column vector. 33 | typedef MatrixT<4, 4> Matrix44; ///< A 4 by 4 matrix. 34 | typedef MatrixT<4, Eigen::Dynamic> Matrix4X; ///< A 4 by n matrix. 35 | typedef MatrixT<3, Eigen::Dynamic> Matrix3X; ///< A 3 by n matrix. 36 | typedef MatrixT MatrixX3; ///< A n by 3 matrix. 37 | typedef MatrixT<2, Eigen::Dynamic> Matrix2X; ///< A 2 by n matrix. 38 | typedef MatrixT MatrixX2; ///< A n by 2 matrix. 39 | typedef MatrixT VectorX; ///< A nd column vector. 40 | typedef MatrixT MatrixXX; ///< A n by m matrix. 41 | 42 | // Conversion between a 3d vector type to Eigen::Vector3d 43 | template 44 | inline Vector3 to_eigen_vec3(const Vec_T &vec) { 45 | return Vector3(vec[0], vec[1], vec[2]); 46 | } 47 | 48 | template 49 | inline Vec_T from_eigen_vec3(const Vector3 &vec) { 50 | Vec_T v; 51 | v[0] = vec(0); 52 | v[1] = vec(1); 53 | v[2] = vec(2); 54 | 55 | return v; 56 | } 57 | 58 | #endif // TYPES_H 59 | /////////////////////////////////////////////////////////////////////////////// 60 | -------------------------------------------------------------------------------- /DevelopApp/Compute/Development/svd/Singular_Value_Decomposition_Preamble.hpp: -------------------------------------------------------------------------------- 1 | //##################################################################### 2 | // Copyright (c) 2010-2011, Eftychios Sifakis. 3 | // 4 | // Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 5 | // * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 6 | // * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or 7 | // other materials provided with the distribution. 8 | // 9 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, 10 | // BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 11 | // SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 12 | // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 13 | // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 14 | // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 15 | //##################################################################### 16 | 17 | #ifdef PRINT_DEBUGGING_OUTPUT 18 | #include 19 | #include 20 | #endif 21 | 22 | #ifdef USE_SCALAR_IMPLEMENTATION 23 | #define ENABLE_SCALAR_IMPLEMENTATION(X) X 24 | #else 25 | #define ENABLE_SCALAR_IMPLEMENTATION(X) 26 | #endif 27 | 28 | #ifdef USE_SSE_IMPLEMENTATION 29 | #define ENABLE_SSE_IMPLEMENTATION(X) X 30 | #else 31 | #define ENABLE_SSE_IMPLEMENTATION(X) 32 | #endif 33 | 34 | #ifdef USE_AVX_IMPLEMENTATION 35 | #include 36 | #define ENABLE_AVX_IMPLEMENTATION(X) X 37 | #else 38 | #include 39 | #define ENABLE_AVX_IMPLEMENTATION(X) 40 | #endif 41 | 42 | #ifdef USE_AVX512_IMPLEMENTATION 43 | #include 44 | #define ENABLE_AVX512_IMPLEMENTATION(X) X 45 | #else 46 | #include 47 | #define ENABLE_AVX512_IMPLEMENTATION(X) 48 | #endif 49 | 50 | #ifdef USE_SCALAR_IMPLEMENTATION 51 | float rsqrt(const float f) 52 | { 53 | float buf[4]; 54 | buf[0]=f; 55 | __m128 v=_mm_loadu_ps(buf); 56 | v=_mm_rsqrt_ss(v); 57 | _mm_storeu_ps(buf,v); 58 | return buf[0]; 59 | } 60 | #endif 61 | 62 | -------------------------------------------------------------------------------- /DevelopApp/Compute/Refinement/GaussMin.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "../SegMesh.h" 4 | 5 | typedef Eigen::SparseMatrix SpMat; 6 | typedef Eigen::Triplet T; 7 | 8 | class GaussMin 9 | { 10 | public: 11 | GaussMin(SegMesh& seg_mesh); 12 | 13 | void Reset(); 14 | 15 | void SetOriMesh(Mesh& mesh); 16 | 17 | void UpdateWeight() 18 | { 19 | lambda_dev_ *= update_lambda_precent_ * update_lambda_precent_; 20 | lambda_seam_ *= update_lambda_precent_; 21 | lambda_smooth_ *= update_lambda_precent_; 22 | } 23 | 24 | void Run(double max_cur); 25 | 26 | private: 27 | void Init(); 28 | 29 | void SetPosition(); 30 | void SetStepH(); 31 | 32 | void SetGloToLoc(); 33 | void SetIdentityMatrix(); 34 | void SetInnerSmoothMatrix(); 35 | void SetSeamSmoothMatrix(); 36 | 37 | //void SetInitJTJ(); 38 | void SetInitTriplet(); 39 | 40 | void Opt(); 41 | 42 | void ComputeNormK(); 43 | void ComputeR(); 44 | void UpdateEnergy(); 45 | void ComputeJ(); 46 | 47 | bool LinearSearch(double& alpha_k, double c2 = 0.9); 48 | 49 | //void Projection() 50 | //{ 51 | // for (int i = 0; i < new_pos_.rows(); ++i) 52 | // { 53 | // new_pos_.row(i) = ori_pos_.row(i) + (new_pos_.row(i) - ori_pos_.row(i)) 54 | // / std::max(1.0, (new_pos_.row(i) - ori_pos_.row(i)).norm() / m_dist_); 55 | // } 56 | //} 57 | 58 | std::vector ComputeTempTriplet(const int& start_idx, 59 | const int& thread_id); 60 | 61 | template 62 | inline Scalar AngleDefect(const VH& v_h, const Eigen::Matrix& temp_pos); 63 | 64 | private: 65 | SegMesh& seg_mesh_; 66 | Mesh& mesh_; 67 | 68 | Eigen::MatrixX3d ori_pos_; 69 | 70 | double m_dist_; 71 | 72 | std::vector step_h_; 73 | 74 | //int n_inner_, n_seam_; 75 | std::vector glo2inner_; 76 | //std::vector glo2seam_; 77 | std::vector inner2glo_; 78 | std::vector seam2glo_; 79 | 80 | //SpMat m_init_JTJ_; 81 | std::vector init_triplet_; 82 | 83 | Eigen::VectorXd r_; 84 | SpMat J_; 85 | SpMat m_JTJ_; 86 | 87 | SpMat m_sm_; 88 | SpMat m_se_; 89 | SpMat m_id_; 90 | SpMat m_de_; 91 | 92 | Eigen::MatrixX3d new_pos_; 93 | Eigen::VectorXd norm_K_; 94 | 95 | //SpMat partial_E_; 96 | //SpMat m_JTJ_; 97 | //Eigen::VectorXd v_JTd_; 98 | Eigen::VectorXd v_direction_; 99 | Eigen::MatrixX3d m_direction_; 100 | Eigen::VectorXd v_gradient_; 101 | 102 | double total_energy_; 103 | double smooth_energy_; 104 | double seam_energy_; 105 | double close_energy_; 106 | double dev_energy_; 107 | 108 | Eigen::SimplicialLDLT m_ldlt_; 109 | //Eigen::BiCGSTAB> m_bicg_; 110 | 111 | double cur_bound_ = DBL_MAX; 112 | 113 | double lambda_exp_close_ = 1.0; 114 | double lambda_exp_smooth_ = 1.0; 115 | double lambda_exp_seam_ = 1.0; 116 | Eigen::VectorXd r_exp_close_; 117 | Eigen::VectorXd r_exp_smooth_; 118 | Eigen::VectorXd r_exp_seam_; 119 | 120 | Eigen::VectorXd m_sm_sq_; 121 | Eigen::VectorXd m_se_sq_; 122 | 123 | int iter_num_ = 500; 124 | int output_num_ = 100; 125 | int update_lambda_num_ = 100; 126 | double small_gradient_precent_ = 0.001; 127 | double target_dist_ = 0.05;//0.05 128 | double step_precent_ = 0.01; 129 | 130 | double lambda_smooth_ = 2.0;//2.0 131 | double lambda_seam_ = 2.0;//2.0 132 | double lambda_close_ = 1.0;//1.0 133 | double lambda_dev_ = 1.0;//1.0 134 | 135 | double update_lambda_precent_ = (1 + 1e-1); 136 | 137 | double break_diff_; 138 | 139 | int p_ = 1; 140 | }; 141 | 142 | -------------------------------------------------------------------------------- /DevelopApp/Compute/Refinement/Merge.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../SegMesh.h" 3 | 4 | class Merge 5 | { 6 | public: 7 | Merge(SegMesh& seg_mesh); 8 | 9 | void RemoveOneTriangle(const double& merge_angle_bound = M_PI / 180 * 5); 10 | 11 | void SegMerge( 12 | const double& merge_angle_bound = M_PI / 180 * 5, 13 | const double& len_rate = 0.05); 14 | 15 | private: 16 | void ComputeStartandEndHalfedge(const std::vector& v_cout, 17 | std::vector>>& start_he_array, 18 | std::vector>>& end_he_array); 19 | 20 | void ComputeBoundNumAndFeatureStatus( 21 | const double& merge_angle_bound, 22 | const std::vector& v_cout, 23 | std::vector>& seg_bound_num, 24 | std::vector>& seg_feature_status); 25 | 26 | void ComputeLargeIdx( 27 | const double& len_rate, 28 | const int& min_idx, 29 | const std::vector>& seg_bound_num, 30 | const std::vector>& seg_feature_status, 31 | const std::vector>>& start_he_array, 32 | const std::vector>>& end_he_array, 33 | int& large_seg_idx); 34 | 35 | private: 36 | SegMesh& seg_mesh_; 37 | }; 38 | 39 | -------------------------------------------------------------------------------- /DevelopApp/Compute/SegMesh.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | #include "../MeshDefinition.h" 5 | 6 | class SegMesh 7 | { 8 | public: 9 | SegMesh(Mesh& mesh); 10 | 11 | void ReadSeg(const std::string& file_name); 12 | 13 | void Init(); 14 | 15 | Mesh& GetMesh(); 16 | 17 | std::vector& GetSeam(); 18 | void BoundToIdx(); 19 | 20 | std::vector& GetSegId(); 21 | void IdxToBound(); 22 | 23 | int& GetSegNum(); 24 | 25 | void ComputeVertexStatus(std::vector& seam_v_status); 26 | 27 | void ComputeSegFaceNum(std::vector& f_num); 28 | 29 | std::vector GetAbsGauss(bool remove_seam = false); 30 | 31 | void SetModifiedGauss(std::vector v_gauss); 32 | std::vector& GetModifiedGauss(); 33 | 34 | void ComputeVertexCount(std::vector& v_cout); 35 | 36 | void ComputeVertexSeg(std::vector& v_seg); 37 | 38 | void WriteSeg(const std::string& file_name); 39 | 40 | void WriteMesh(const std::string& file_name); 41 | 42 | 43 | private: 44 | Mesh& mesh_; 45 | 46 | int seg_num_; 47 | std::vector seam_status_; 48 | std::vector seg_id_; 49 | 50 | std::vector abs_v_gauss_; 51 | std::vector modified_gauss_; 52 | }; 53 | 54 | -------------------------------------------------------------------------------- /DevelopApp/Compute/Segmentation/CurSegCut.cpp: -------------------------------------------------------------------------------- 1 | #include "CurSegCut.h" 2 | 3 | CurSegCut::CurSegCut(SegMesh& seg_mesh, 4 | std::vector& glo2loc, 5 | std::vector& sub_fiedler) 6 | :SegCut(seg_mesh, glo2loc, sub_fiedler) 7 | { 8 | } 9 | 10 | void CurSegCut::ComputeMinCutDiff() 11 | { 12 | min_cut_diff_ = 0; 13 | } 14 | 15 | bool CurSegCut::ComputeCutBound() 16 | { 17 | Mesh& mesh = seg_mesh_.GetMesh(); 18 | const auto& seam_status = seg_mesh_.GetSeam(); 19 | auto abs_v_gauss = seg_mesh_.GetModifiedGauss(); 20 | 21 | ComputeDiff(); 22 | 23 | // cur bound 24 | 25 | while (diff_bound_.size() > 0) 26 | { 27 | double temp_diff = diff_bound_.back().first; 28 | double temp_bound = diff_bound_.back().second; 29 | diff_bound_.pop_back(); 30 | 31 | if (IsAcrossHighCur(mesh, seam_status, abs_v_gauss, temp_bound) 32 | && IsProperSize(mesh, temp_bound)) 33 | { 34 | cut_bound_ = temp_bound; 35 | return true; 36 | } 37 | } 38 | return false; 39 | } 40 | 41 | bool CurSegCut::IsAcrossHighCur(const Mesh& mesh, 42 | const std::vector& seam_status, 43 | const std::vector& abs_v_gauss, 44 | double temp_bound) 45 | { 46 | for (const EH& e_h : mesh.edges()) 47 | { 48 | if (mesh.is_boundary(e_h)) continue; 49 | 50 | HEH he_h = mesh.halfedge_handle(e_h, 0); 51 | FH f_0 = mesh.face_handle(he_h); 52 | FH f_1 = mesh.opposite_face_handle(he_h); 53 | 54 | if (glo2loc_[f_0.idx()] == -1 || glo2loc_[f_1.idx()] == -1) continue; 55 | 56 | double sign = (sub_fiedler_[f_0.idx()] - temp_bound) 57 | * (sub_fiedler_[f_1.idx()] - temp_bound); 58 | 59 | if (sign > 0) continue; 60 | 61 | VH to_v = mesh.to_vertex_handle(he_h); 62 | VH from_v = mesh.from_vertex_handle(he_h); 63 | 64 | if (abs_v_gauss[to_v.idx()] > DBL_EPSILON 65 | || abs_v_gauss[from_v.idx()] > DBL_EPSILON) 66 | { 67 | return true; 68 | } 69 | } 70 | 71 | return false; 72 | } 73 | 74 | bool CurSegCut::IsProperSize(const Mesh& mesh, const double& temp_bound) 75 | { 76 | int less_cout = 0, larger_cout = 0; 77 | size_t n_f = mesh.n_faces(); 78 | for (size_t f_id = 0; f_id < n_f; ++f_id) 79 | { 80 | if (glo2loc_[f_id] == -1) continue; 81 | 82 | if (sub_fiedler_[f_id] > temp_bound) 83 | { 84 | ++larger_cout; 85 | } 86 | else 87 | { 88 | ++less_cout; 89 | } 90 | } 91 | 92 | if (larger_cout > size_precent_ * glo2loc_.size() 93 | && less_cout > size_precent_ * glo2loc_.size()) 94 | { 95 | return true; 96 | } 97 | else 98 | { 99 | return false; 100 | } 101 | } -------------------------------------------------------------------------------- /DevelopApp/Compute/Segmentation/CurSegCut.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "SegCut.h" 3 | 4 | class CurSegCut : public SegCut 5 | { 6 | public: 7 | CurSegCut(SegMesh& seg_mesh, 8 | std::vector& glo2loc, 9 | std::vector& sub_fiedler); 10 | 11 | 12 | private: 13 | void ComputeMinCutDiff(); 14 | 15 | bool ComputeCutBound(); 16 | 17 | bool IsAcrossHighCur(const Mesh& mesh, 18 | const std::vector& seam_status, 19 | const std::vector& abs_v_gauss, 20 | double temp_bound); 21 | 22 | bool IsProperSize(const Mesh& mesh, const double& temp_bound); 23 | }; 24 | 25 | -------------------------------------------------------------------------------- /DevelopApp/Compute/Segmentation/DiffSegCut.cpp: -------------------------------------------------------------------------------- 1 | #include "DiffSegCut.h" 2 | 3 | DiffSegCut::DiffSegCut(SegMesh& seg_mesh, std::vector& glo2loc, std::vector& sub_fiedler) 4 | :SegCut(seg_mesh, glo2loc, sub_fiedler) 5 | { 6 | } 7 | 8 | void DiffSegCut::ComputeMinCutDiff() 9 | { 10 | int active_f_n = 0; 11 | for (size_t i = 0; i < glo2loc_.size(); i++) 12 | { 13 | if (glo2loc_[i] == -1) continue; 14 | active_f_n++; 15 | } 16 | 17 | // Threshold of the Fiedler vector difference 18 | min_cut_diff_ = (FiedlerPara::max_val_ - FiedlerPara::min_val_) * max_rate_ / active_f_n; 19 | } 20 | 21 | bool DiffSegCut::ComputeCutBound() 22 | { 23 | ComputeDiff(); 24 | 25 | // Determine whether to segment 26 | while (diff_bound_.size() > 0) 27 | { 28 | double temp_diff = diff_bound_.back().first; 29 | double temp_bound = diff_bound_.back().second; 30 | diff_bound_.pop_back(); 31 | 32 | int max_num = 0, min_num = 0; 33 | for (size_t i = 0; i < sort_fiedler_.size(); i++) 34 | { 35 | if (sort_fiedler_[i] > temp_bound) 36 | { 37 | max_num++; 38 | } 39 | else 40 | { 41 | min_num++; 42 | } 43 | } 44 | 45 | if (max_num > 0 * sub_fiedler_.size() && min_num > 0 * sub_fiedler_.size()) 46 | { 47 | cut_bound_ = temp_bound; 48 | return true; 49 | } 50 | } 51 | 52 | return false; 53 | } -------------------------------------------------------------------------------- /DevelopApp/Compute/Segmentation/DiffSegCut.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "SegCut.h" 4 | #include "FiedlerVector.h" 5 | 6 | class DiffSegCut : public SegCut 7 | { 8 | public: 9 | DiffSegCut(SegMesh& seg_mesh, 10 | std::vector& glo2loc, 11 | std::vector& sub_fiedler); 12 | 13 | private: 14 | void ComputeMinCutDiff(); 15 | 16 | bool ComputeCutBound(); 17 | 18 | private: 19 | // =========== 2021-9-27 ============== // 20 | double max_rate_ = 2; 21 | // =========== 2021-9-27 ============== // 22 | }; 23 | 24 | -------------------------------------------------------------------------------- /DevelopApp/Compute/Segmentation/FiedlerVector.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../../MeshDefinition.h" 3 | #include "matlab_utils.h" 4 | 5 | typedef Eigen::SparseMatrix SpMat; // declares a column-major sparse matrix type of double 6 | typedef Eigen::Triplet T; 7 | 8 | namespace FiedlerPara 9 | { 10 | const double min_val_ = 0.1; 11 | const double max_val_ = 0.99; 12 | } 13 | 14 | class FiedlerVector 15 | { 16 | public: 17 | FiedlerVector(Mesh& mesh, std::vector& glo2loc, std::vector& loc2glo, std::vector& sub_fiedler); 18 | 19 | void Run(); 20 | 21 | private: 22 | void ComputeGlobalDistance(); 23 | 24 | void ComputeLocalMeanDistance(); 25 | 26 | void ConstructAffinity(); 27 | 28 | void ComputeEigenFuntion(); 29 | 30 | private: 31 | Mesh& mesh_; 32 | std::vector& glo2loc_; 33 | std::vector& loc2glo_; 34 | std::vector& sub_fiedler_; // fiedler of sub seg 35 | 36 | double epsilon_1_ = 0.0001, epsilon_2_ = 0.1; 37 | 38 | std::vector angle_dist_; 39 | double loc_dis_mean_; 40 | 41 | SpMat aff_matrix_; 42 | }; 43 | 44 | -------------------------------------------------------------------------------- /DevelopApp/Compute/Segmentation/SegCut.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "../SegMesh.h" 4 | 5 | class SegCut 6 | { 7 | public: 8 | SegCut(SegMesh& seg_mesh, 9 | std::vector& glo2loc, 10 | std::vector& sub_fiedler); 11 | 12 | //bool DiffRun(); 13 | 14 | //bool CurRun(); 15 | 16 | bool Run(); 17 | 18 | protected: 19 | virtual void ComputeMinCutDiff() = 0; 20 | 21 | virtual bool ComputeCutBound() = 0; 22 | 23 | void SegBound(); 24 | 25 | void ComputeDiff(); 26 | 27 | protected: 28 | SegMesh& seg_mesh_; 29 | std::vector& glo2loc_; 30 | std::vector& sub_fiedler_; 31 | 32 | std::vector sort_fiedler_; 33 | std::vector> diff_bound_; 34 | double cut_bound_; 35 | 36 | double min_cut_diff_ = 0.0001; 37 | const double size_precent_ = 0.01; 38 | }; 39 | 40 | -------------------------------------------------------------------------------- /DevelopApp/Compute/Segmentation/Segment.cpp: -------------------------------------------------------------------------------- 1 | #include "Segment.h" 2 | 3 | Segment::Segment(SegMesh& seg_mesh, SegMode seg_mode) 4 | :seg_mesh_(seg_mesh) 5 | { 6 | Mesh& mesh = seg_mesh.GetMesh(); 7 | 8 | fiedler_ = new FiedlerVector(mesh, glo2loc_, loc2glo_, sub_fiedler_); 9 | 10 | if (seg_mode == DIFF) 11 | { 12 | seg_cut_ = new DiffSegCut(seg_mesh_, glo2loc_, sub_fiedler_); 13 | } 14 | if (seg_mode == CUR) 15 | { 16 | seg_cut_ = new CurSegCut(seg_mesh_, glo2loc_, sub_fiedler_); 17 | } 18 | 19 | glo2loc_.resize(mesh.n_faces()); 20 | loc2glo_.resize(mesh.n_faces()); 21 | for (size_t i = 0; i < mesh.n_faces(); i++) 22 | { 23 | glo2loc_[i] = i; 24 | loc2glo_[i] = i; 25 | } 26 | } 27 | 28 | Segment::~Segment() 29 | { 30 | if (fiedler_) 31 | { 32 | delete fiedler_; 33 | fiedler_ = NULL; 34 | } 35 | 36 | if (seg_cut_) 37 | { 38 | delete seg_cut_; 39 | seg_cut_ = NULL; 40 | } 41 | } 42 | 43 | bool Segment::Run() 44 | { 45 | std::cout << "------ Fiedler ------" << std::endl; 46 | fiedler_->Run(); 47 | 48 | std::cout << "------ Seg Cut ------" << std::endl; 49 | return seg_cut_->Run(); 50 | } 51 | 52 | void Segment::Init(const std::vector& f_status) 53 | { 54 | std::cout << "------ Glo2Loc Init ------" << std::endl; 55 | 56 | Mesh& mesh = seg_mesh_.GetMesh(); 57 | 58 | // Find the current patch 59 | // Local to global 60 | int count = 0; 61 | glo2loc_ = std::vector(mesh.n_faces(), -1); 62 | loc2glo_.resize(0); 63 | for (size_t i = 0; i < mesh.n_faces(); i++) 64 | { 65 | if (f_status[i]) 66 | { 67 | glo2loc_[i] = count; 68 | loc2glo_.push_back(i); 69 | count++; 70 | } 71 | } 72 | } 73 | 74 | //void Segment::AddNewSeam(std::vector& seam_e) 75 | //{ 76 | // seam_e = seg_bound_; 77 | //} 78 | // 79 | //void Segment::AddNewSeam(std::vector& seam_status) 80 | //{ 81 | // if (seg_bound_.size() < 20) 82 | // { 83 | // seam_status.assign(mesh_.n_edges(), false); 84 | // return; 85 | // } 86 | // 87 | // for (int i : seg_bound_) 88 | // { 89 | // seam_status[i] = true; 90 | // } 91 | //} 92 | // 93 | //void Segment::GetSegBound(std::vector& seg_bound) 94 | //{ 95 | // seg_bound = seg_bound_; 96 | //} 97 | // 98 | void Segment::GetFiedler(std::vector& sub_fiedler) 99 | { 100 | sub_fiedler = sub_fiedler_; 101 | } -------------------------------------------------------------------------------- /DevelopApp/Compute/Segmentation/Segment.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "FiedlerVector.h" 4 | 5 | #include "DiffSegCut.h" 6 | #include "CurSegCut.h" 7 | 8 | class Segment 9 | { 10 | public: 11 | enum SegMode { DIFF, CUR }; 12 | 13 | public: 14 | Segment(SegMesh& seg_mesh, SegMode seg_mode); 15 | 16 | ~Segment(); 17 | 18 | void Init(const std::vector& f_status); 19 | 20 | bool Run(); 21 | 22 | //void AddNewSeam(std::vector& seam_e); 23 | 24 | //void AddNewSeam(std::vector& seam_status); 25 | 26 | //void GetSegBound(std::vector& seg_bound); 27 | 28 | void GetFiedler(std::vector& sub_fiedler); 29 | 30 | private: 31 | SegMesh& seg_mesh_; 32 | 33 | std::vector glo2loc_, loc2glo_; 34 | 35 | FiedlerVector* fiedler_; 36 | std::vector sub_fiedler_; 37 | 38 | SegCut* seg_cut_; 39 | }; 40 | 41 | -------------------------------------------------------------------------------- /DevelopApp/Compute/Segmentation/matlab_utils.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace Eigen; 3 | 4 | #include "matlab_utils.h" 5 | 6 | #ifdef ENABLE_MATLAB 7 | 8 | MatlabEngine gMatEngine; 9 | 10 | // Matlab engine 11 | #pragma comment(lib, "libeng.lib") 12 | #pragma comment(lib, "libmx.lib") 13 | 14 | bool MatlabEngine::connect(const std::string &dir, bool closeAll) 15 | { 16 | if (eng) 17 | return true; 18 | 19 | if (0) { 20 | // 0 = success 21 | // -2 = error - second argument must be NULL 22 | // -3 = error - engOpenSingleUse failed 23 | int retstatus; 24 | if ( !(eng = engOpenSingleUse("\0", NULL, &retstatus)) ) { 25 | fprintf(stderr, "Can't start MATLAB engine: %d\n", retstatus); 26 | return false; 27 | } 28 | } 29 | else { 30 | printf( "Starting MATLAB engine ... " ); 31 | if (!(eng = engOpen("\0"))) { 32 | fprintf(stderr, "Failed!\n"); 33 | return false; 34 | } 35 | printf( "Succeed!\n"); 36 | } 37 | 38 | engBuffer[lenEngBuffer-1] = '\0'; 39 | engOutputBuffer(eng, engBuffer, lenEngBuffer); 40 | 41 | // set current path 42 | engEvalString(eng, ("cd " + dir).c_str()); 43 | 44 | //engEvalString(eng, "clear all; clc; rehash;"); 45 | if (closeAll) 46 | engEvalString(eng, "close all;"); 47 | 48 | return true; 49 | } 50 | 51 | void MatlabEngine::eval(const std::string &cmd) 52 | { 53 | ensure(connected(), "Not connected to Matlab!"); 54 | 55 | if (consoleOutput) 56 | engOutputBuffer(eng, engBuffer, lenEngBuffer); 57 | else 58 | engOutputBuffer(eng, nullptr, 0); 59 | 60 | //engEvalString(eng, "dbclear all;"); 61 | engEvalString(eng, "if ~isempty(dbstatus), warning('Clear all breakpoint, Matlab cannot be debugged from C++!'); dbclear all; end"); // debug will cause matlab to crash 62 | if (consoleOutput && *engBuffer) fprintf(stderr, "%s\n", engBuffer); 63 | 64 | int r = engEvalString(eng, cmd.c_str()); 65 | if (r != 0) { 66 | if (r == 1) fprintf(stderr, "Engine session no longer running!\n"); 67 | 68 | fprintf(stderr, "engEvalString error!\n"); 69 | } 70 | 71 | if (consoleOutput && *engBuffer) { 72 | fprintf(stdout, "--------------\n%s\n--------------\n%s\n", cmd.c_str(), engBuffer); 73 | } 74 | } 75 | 76 | 77 | void MatlabEngine::close() 78 | { 79 | printf( "Shutting down MATLAB engine ... " ); 80 | engClose(eng); 81 | printf( "done!\n" ); 82 | eng = nullptr; 83 | } 84 | 85 | MatlabEngine& getMatEngine() 86 | { 87 | return gMatEngine; 88 | } 89 | 90 | #endif 91 | -------------------------------------------------------------------------------- /DevelopApp/DevelopApp.cpp: -------------------------------------------------------------------------------- 1 | #include "Compute\Optimization.h" 2 | 3 | int main(int argc, char* argv[]) 4 | { 5 | // Input 6 | std::string input_name = "model/Bunny.obj"; 7 | //std::string input_name = "model/Tortoise.obj"; 8 | //std::cout << "Read mesh: " << filename << std::endl; 9 | Mesh input_mesh; 10 | MeshTools::ReadMesh(input_mesh, input_name); 11 | 12 | // ============ Deformation ============== 13 | SegMesh seg_mesh(input_mesh); 14 | std::cout << "opt " << std::endl; 15 | Optimization opt(seg_mesh); 16 | opt.Run(); 17 | 18 | //// ============ Deformation ============== 19 | //std::string filename = "model/input.obj"; 20 | //std::cout << "Read mesh: " << filename << std::endl; 21 | //Mesh mesh; 22 | //MeshTools::ReadMesh(mesh, filename); 23 | //std::cout << "Face num: " << mesh.n_faces() << std::endl; 24 | 25 | //SegMesh seg_mesh(mesh); 26 | //std::cout << "opt " << std::endl; 27 | //Optimization opt(seg_mesh); 28 | //opt.Deformation(); 29 | 30 | //// ============ Optimization with deformation ============== 31 | //std::string filename = "mesh_data/deform_9.obj"; 32 | //std::cout << "Read mesh: " << filename << std::endl; 33 | //Mesh def_mesh; 34 | //MeshTools::ReadMesh(def_mesh, filename); 35 | 36 | //std::cout << "Face num: " << def_mesh.n_faces() << std::endl; 37 | 38 | //SegMesh seg_mesh(def_mesh); 39 | //std::cout << "opt " << std::endl; 40 | //Optimization opt(seg_mesh); 41 | //opt.Segmentation(); 42 | 43 | 44 | //// ============ Optimization with deformation and segmentation ============== 45 | //// Deformed 46 | //std::string deformed_name = "mesh_data/first_deform.obj"; 47 | //Mesh mesh; 48 | //MeshTools::ReadMesh(mesh, deformed_name); 49 | 50 | //std::string segname = "mesh_data/first_deform_seg.txt"; 51 | //SegMesh seg_mesh(mesh); 52 | //seg_mesh.ReadSeg(segname); 53 | 54 | //std::cout << "opt " << std::endl; 55 | //Optimization opt(seg_mesh); 56 | //opt.SetOriMesh(input_mesh); 57 | //opt.Refinement(); 58 | 59 | return 0; 60 | } 61 | 62 | 63 | -------------------------------------------------------------------------------- /DevelopApp/DevelopApp.vcxproj.user: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | PATH=C:\Program Files\MATLAB\R2020b\bin\win64%3b 5 | $(LocalDebuggerEnvironment) 6 | WindowsLocalDebugger 7 | 8 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/Cholesky: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_CHOLESKY_MODULE_H 9 | #define EIGEN_CHOLESKY_MODULE_H 10 | 11 | #include "Core" 12 | 13 | #include "src/Core/util/DisableStupidWarnings.h" 14 | 15 | /** \defgroup Cholesky_Module Cholesky module 16 | * 17 | * 18 | * 19 | * This module provides two variants of the Cholesky decomposition for selfadjoint (hermitian) matrices. 20 | * Those decompositions are also accessible via the following methods: 21 | * - MatrixBase::llt() 22 | * - MatrixBase::ldlt() 23 | * - SelfAdjointView::llt() 24 | * - SelfAdjointView::ldlt() 25 | * 26 | * \code 27 | * #include 28 | * \endcode 29 | */ 30 | 31 | #include "src/Cholesky/LLT.h" 32 | #include "src/Cholesky/LDLT.h" 33 | #ifdef EIGEN_USE_LAPACKE 34 | #include "src/misc/lapacke.h" 35 | #include "src/Cholesky/LLT_LAPACKE.h" 36 | #endif 37 | 38 | #include "src/Core/util/ReenableStupidWarnings.h" 39 | 40 | #endif // EIGEN_CHOLESKY_MODULE_H 41 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 42 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/CholmodSupport: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_CHOLMODSUPPORT_MODULE_H 9 | #define EIGEN_CHOLMODSUPPORT_MODULE_H 10 | 11 | #include "SparseCore" 12 | 13 | #include "src/Core/util/DisableStupidWarnings.h" 14 | 15 | extern "C" { 16 | #include 17 | } 18 | 19 | /** \ingroup Support_modules 20 | * \defgroup CholmodSupport_Module CholmodSupport module 21 | * 22 | * This module provides an interface to the Cholmod library which is part of the suitesparse package. 23 | * It provides the two following main factorization classes: 24 | * - class CholmodSupernodalLLT: a supernodal LLT Cholesky factorization. 25 | * - class CholmodDecomposiiton: a general L(D)LT Cholesky factorization with automatic or explicit runtime selection of the underlying factorization method (supernodal or simplicial). 26 | * 27 | * For the sake of completeness, this module also propose the two following classes: 28 | * - class CholmodSimplicialLLT 29 | * - class CholmodSimplicialLDLT 30 | * Note that these classes does not bring any particular advantage compared to the built-in 31 | * SimplicialLLT and SimplicialLDLT factorization classes. 32 | * 33 | * \code 34 | * #include 35 | * \endcode 36 | * 37 | * 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. 38 | * The dependencies depend on how cholmod has been compiled. 39 | * For a cmake based project, you can use our FindCholmod.cmake module to help you in this task. 40 | * 41 | */ 42 | 43 | #include "src/CholmodSupport/CholmodSupport.h" 44 | 45 | #include "src/Core/util/ReenableStupidWarnings.h" 46 | 47 | #endif // EIGEN_CHOLMODSUPPORT_MODULE_H 48 | 49 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/Dense: -------------------------------------------------------------------------------- 1 | #include "Core" 2 | #include "LU" 3 | #include "Cholesky" 4 | #include "QR" 5 | #include "SVD" 6 | #include "Geometry" 7 | #include "Eigenvalues" 8 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/Eigen: -------------------------------------------------------------------------------- 1 | #include "Dense" 2 | #include "Sparse" 3 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/Eigenvalues: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_EIGENVALUES_MODULE_H 9 | #define EIGEN_EIGENVALUES_MODULE_H 10 | 11 | #include "Core" 12 | 13 | #include "src/Core/util/DisableStupidWarnings.h" 14 | 15 | #include "Cholesky" 16 | #include "Jacobi" 17 | #include "Householder" 18 | #include "LU" 19 | #include "Geometry" 20 | 21 | /** \defgroup Eigenvalues_Module Eigenvalues module 22 | * 23 | * 24 | * 25 | * This module mainly provides various eigenvalue solvers. 26 | * This module also provides some MatrixBase methods, including: 27 | * - MatrixBase::eigenvalues(), 28 | * - MatrixBase::operatorNorm() 29 | * 30 | * \code 31 | * #include 32 | * \endcode 33 | */ 34 | 35 | #include "src/misc/RealSvd2x2.h" 36 | #include "src/Eigenvalues/Tridiagonalization.h" 37 | #include "src/Eigenvalues/RealSchur.h" 38 | #include "src/Eigenvalues/EigenSolver.h" 39 | #include "src/Eigenvalues/SelfAdjointEigenSolver.h" 40 | #include "src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h" 41 | #include "src/Eigenvalues/HessenbergDecomposition.h" 42 | #include "src/Eigenvalues/ComplexSchur.h" 43 | #include "src/Eigenvalues/ComplexEigenSolver.h" 44 | #include "src/Eigenvalues/RealQZ.h" 45 | #include "src/Eigenvalues/GeneralizedEigenSolver.h" 46 | #include "src/Eigenvalues/MatrixBaseEigenvalues.h" 47 | #ifdef EIGEN_USE_LAPACKE 48 | #include "src/misc/lapacke.h" 49 | #include "src/Eigenvalues/RealSchur_LAPACKE.h" 50 | #include "src/Eigenvalues/ComplexSchur_LAPACKE.h" 51 | #include "src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h" 52 | #endif 53 | 54 | #include "src/Core/util/ReenableStupidWarnings.h" 55 | 56 | #endif // EIGEN_EIGENVALUES_MODULE_H 57 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 58 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/Geometry: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_GEOMETRY_MODULE_H 9 | #define EIGEN_GEOMETRY_MODULE_H 10 | 11 | #include "Core" 12 | 13 | #include "src/Core/util/DisableStupidWarnings.h" 14 | 15 | #include "SVD" 16 | #include "LU" 17 | #include 18 | 19 | /** \defgroup Geometry_Module Geometry module 20 | * 21 | * This module provides support for: 22 | * - fixed-size homogeneous transformations 23 | * - translation, scaling, 2D and 3D rotations 24 | * - \link Quaternion quaternions \endlink 25 | * - cross products (\ref MatrixBase::cross, \ref MatrixBase::cross3) 26 | * - orthognal vector generation (\ref MatrixBase::unitOrthogonal) 27 | * - some linear components: \link ParametrizedLine parametrized-lines \endlink and \link Hyperplane hyperplanes \endlink 28 | * - \link AlignedBox axis aligned bounding boxes \endlink 29 | * - \link umeyama least-square transformation fitting \endlink 30 | * 31 | * \code 32 | * #include 33 | * \endcode 34 | */ 35 | 36 | #include "src/Geometry/OrthoMethods.h" 37 | #include "src/Geometry/EulerAngles.h" 38 | 39 | #include "src/Geometry/Homogeneous.h" 40 | #include "src/Geometry/RotationBase.h" 41 | #include "src/Geometry/Rotation2D.h" 42 | #include "src/Geometry/Quaternion.h" 43 | #include "src/Geometry/AngleAxis.h" 44 | #include "src/Geometry/Transform.h" 45 | #include "src/Geometry/Translation.h" 46 | #include "src/Geometry/Scaling.h" 47 | #include "src/Geometry/Hyperplane.h" 48 | #include "src/Geometry/ParametrizedLine.h" 49 | #include "src/Geometry/AlignedBox.h" 50 | #include "src/Geometry/Umeyama.h" 51 | 52 | // Use the SSE optimized version whenever possible. At the moment the 53 | // SSE version doesn't compile when AVX is enabled 54 | #if defined EIGEN_VECTORIZE_SSE && !defined EIGEN_VECTORIZE_AVX 55 | #include "src/Geometry/arch/Geometry_SSE.h" 56 | #endif 57 | 58 | #include "src/Core/util/ReenableStupidWarnings.h" 59 | 60 | #endif // EIGEN_GEOMETRY_MODULE_H 61 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 62 | 63 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/Householder: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_HOUSEHOLDER_MODULE_H 9 | #define EIGEN_HOUSEHOLDER_MODULE_H 10 | 11 | #include "Core" 12 | 13 | #include "src/Core/util/DisableStupidWarnings.h" 14 | 15 | /** \defgroup Householder_Module Householder module 16 | * This module provides Householder transformations. 17 | * 18 | * \code 19 | * #include 20 | * \endcode 21 | */ 22 | 23 | #include "src/Householder/Householder.h" 24 | #include "src/Householder/HouseholderSequence.h" 25 | #include "src/Householder/BlockHouseholder.h" 26 | 27 | #include "src/Core/util/ReenableStupidWarnings.h" 28 | 29 | #endif // EIGEN_HOUSEHOLDER_MODULE_H 30 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 31 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/IterativeLinearSolvers: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_ITERATIVELINEARSOLVERS_MODULE_H 9 | #define EIGEN_ITERATIVELINEARSOLVERS_MODULE_H 10 | 11 | #include "SparseCore" 12 | #include "OrderingMethods" 13 | 14 | #include "src/Core/util/DisableStupidWarnings.h" 15 | 16 | /** 17 | * \defgroup IterativeLinearSolvers_Module IterativeLinearSolvers module 18 | * 19 | * 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. 20 | * Those solvers are accessible via the following classes: 21 | * - ConjugateGradient for selfadjoint (hermitian) matrices, 22 | * - LeastSquaresConjugateGradient for rectangular least-square problems, 23 | * - BiCGSTAB for general square matrices. 24 | * 25 | * These iterative solvers are associated with some preconditioners: 26 | * - IdentityPreconditioner - not really useful 27 | * - DiagonalPreconditioner - also called Jacobi preconditioner, work very well on diagonal dominant matrices. 28 | * - IncompleteLUT - incomplete LU factorization with dual thresholding 29 | * 30 | * Such problems can also be solved using the direct sparse decomposition modules: SparseCholesky, CholmodSupport, UmfPackSupport, SuperLUSupport. 31 | * 32 | \code 33 | #include 34 | \endcode 35 | */ 36 | 37 | #include "src/IterativeLinearSolvers/SolveWithGuess.h" 38 | #include "src/IterativeLinearSolvers/IterativeSolverBase.h" 39 | #include "src/IterativeLinearSolvers/BasicPreconditioners.h" 40 | #include "src/IterativeLinearSolvers/ConjugateGradient.h" 41 | #include "src/IterativeLinearSolvers/LeastSquareConjugateGradient.h" 42 | #include "src/IterativeLinearSolvers/BiCGSTAB.h" 43 | #include "src/IterativeLinearSolvers/IncompleteLUT.h" 44 | #include "src/IterativeLinearSolvers/IncompleteCholesky.h" 45 | 46 | #include "src/Core/util/ReenableStupidWarnings.h" 47 | 48 | #endif // EIGEN_ITERATIVELINEARSOLVERS_MODULE_H 49 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/Jacobi: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_JACOBI_MODULE_H 9 | #define EIGEN_JACOBI_MODULE_H 10 | 11 | #include "Core" 12 | 13 | #include "src/Core/util/DisableStupidWarnings.h" 14 | 15 | /** \defgroup Jacobi_Module Jacobi module 16 | * This module provides Jacobi and Givens rotations. 17 | * 18 | * \code 19 | * #include 20 | * \endcode 21 | * 22 | * In addition to listed classes, it defines the two following MatrixBase methods to apply a Jacobi or Givens rotation: 23 | * - MatrixBase::applyOnTheLeft() 24 | * - MatrixBase::applyOnTheRight(). 25 | */ 26 | 27 | #include "src/Jacobi/Jacobi.h" 28 | 29 | #include "src/Core/util/ReenableStupidWarnings.h" 30 | 31 | #endif // EIGEN_JACOBI_MODULE_H 32 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 33 | 34 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/LU: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_LU_MODULE_H 9 | #define EIGEN_LU_MODULE_H 10 | 11 | #include "Core" 12 | 13 | #include "src/Core/util/DisableStupidWarnings.h" 14 | 15 | /** \defgroup LU_Module LU module 16 | * This module includes %LU decomposition and related notions such as matrix inversion and determinant. 17 | * This module defines the following MatrixBase methods: 18 | * - MatrixBase::inverse() 19 | * - MatrixBase::determinant() 20 | * 21 | * \code 22 | * #include 23 | * \endcode 24 | */ 25 | 26 | #include "src/misc/Kernel.h" 27 | #include "src/misc/Image.h" 28 | #include "src/LU/FullPivLU.h" 29 | #include "src/LU/PartialPivLU.h" 30 | #ifdef EIGEN_USE_LAPACKE 31 | #include "src/misc/lapacke.h" 32 | #include "src/LU/PartialPivLU_LAPACKE.h" 33 | #endif 34 | #include "src/LU/Determinant.h" 35 | #include "src/LU/InverseImpl.h" 36 | 37 | // Use the SSE optimized version whenever possible. At the moment the 38 | // SSE version doesn't compile when AVX is enabled 39 | #if defined EIGEN_VECTORIZE_SSE && !defined EIGEN_VECTORIZE_AVX 40 | #include "src/LU/arch/Inverse_SSE.h" 41 | #endif 42 | 43 | #include "src/Core/util/ReenableStupidWarnings.h" 44 | 45 | #endif // EIGEN_LU_MODULE_H 46 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 47 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/MetisSupport: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_METISSUPPORT_MODULE_H 9 | #define EIGEN_METISSUPPORT_MODULE_H 10 | 11 | #include "SparseCore" 12 | 13 | #include "src/Core/util/DisableStupidWarnings.h" 14 | 15 | extern "C" { 16 | #include 17 | } 18 | 19 | 20 | /** \ingroup Support_modules 21 | * \defgroup MetisSupport_Module MetisSupport module 22 | * 23 | * \code 24 | * #include 25 | * \endcode 26 | * This module defines an interface to the METIS reordering package (http://glaros.dtc.umn.edu/gkhome/views/metis). 27 | * It can be used just as any other built-in method as explained in \link OrderingMethods_Module here. \endlink 28 | */ 29 | 30 | 31 | #include "src/MetisSupport/MetisSupport.h" 32 | 33 | #include "src/Core/util/ReenableStupidWarnings.h" 34 | 35 | #endif // EIGEN_METISSUPPORT_MODULE_H 36 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/OrderingMethods: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_ORDERINGMETHODS_MODULE_H 9 | #define EIGEN_ORDERINGMETHODS_MODULE_H 10 | 11 | #include "SparseCore" 12 | 13 | #include "src/Core/util/DisableStupidWarnings.h" 14 | 15 | /** 16 | * \defgroup OrderingMethods_Module OrderingMethods module 17 | * 18 | * This module is currently for internal use only 19 | * 20 | * It defines various built-in and external ordering methods for sparse matrices. 21 | * They are typically used to reduce the number of elements during 22 | * the sparse matrix decomposition (LLT, LU, QR). 23 | * Precisely, in a preprocessing step, a permutation matrix P is computed using 24 | * those ordering methods and applied to the columns of the matrix. 25 | * Using for instance the sparse Cholesky decomposition, it is expected that 26 | * the nonzeros elements in LLT(A*P) will be much smaller than that in LLT(A). 27 | * 28 | * 29 | * Usage : 30 | * \code 31 | * #include 32 | * \endcode 33 | * 34 | * A simple usage is as a template parameter in the sparse decomposition classes : 35 | * 36 | * \code 37 | * SparseLU > solver; 38 | * \endcode 39 | * 40 | * \code 41 | * SparseQR > solver; 42 | * \endcode 43 | * 44 | * It is possible as well to call directly a particular ordering method for your own purpose, 45 | * \code 46 | * AMDOrdering ordering; 47 | * PermutationMatrix perm; 48 | * SparseMatrix A; 49 | * //Fill the matrix ... 50 | * 51 | * ordering(A, perm); // Call AMD 52 | * \endcode 53 | * 54 | * \note Some of these methods (like AMD or METIS), need the sparsity pattern 55 | * of the input matrix to be symmetric. When the matrix is structurally unsymmetric, 56 | * Eigen computes internally the pattern of \f$A^T*A\f$ before calling the method. 57 | * If your matrix is already symmetric (at leat in structure), you can avoid that 58 | * by calling the method with a SelfAdjointView type. 59 | * 60 | * \code 61 | * // Call the ordering on the pattern of the lower triangular matrix A 62 | * ordering(A.selfadjointView(), perm); 63 | * \endcode 64 | */ 65 | 66 | #ifndef EIGEN_MPL2_ONLY 67 | #include "src/OrderingMethods/Amd.h" 68 | #endif 69 | 70 | #include "src/OrderingMethods/Ordering.h" 71 | #include "src/Core/util/ReenableStupidWarnings.h" 72 | 73 | #endif // EIGEN_ORDERINGMETHODS_MODULE_H 74 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/PaStiXSupport: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_PASTIXSUPPORT_MODULE_H 9 | #define EIGEN_PASTIXSUPPORT_MODULE_H 10 | 11 | #include "SparseCore" 12 | 13 | #include "src/Core/util/DisableStupidWarnings.h" 14 | 15 | extern "C" { 16 | #include 17 | #include 18 | } 19 | 20 | #ifdef complex 21 | #undef complex 22 | #endif 23 | 24 | /** \ingroup Support_modules 25 | * \defgroup PaStiXSupport_Module PaStiXSupport module 26 | * 27 | * This module provides an interface to the PaSTiX library. 28 | * PaSTiX is a general \b supernodal, \b parallel and \b opensource sparse solver. 29 | * It provides the two following main factorization classes: 30 | * - class PastixLLT : a supernodal, parallel LLt Cholesky factorization. 31 | * - class PastixLDLT: a supernodal, parallel LDLt Cholesky factorization. 32 | * - class PastixLU : a supernodal, parallel LU factorization (optimized for a symmetric pattern). 33 | * 34 | * \code 35 | * #include 36 | * \endcode 37 | * 38 | * 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. 39 | * The dependencies depend on how PaSTiX has been compiled. 40 | * For a cmake based project, you can use our FindPaSTiX.cmake module to help you in this task. 41 | * 42 | */ 43 | 44 | #include "src/PaStiXSupport/PaStiXSupport.h" 45 | 46 | #include "src/Core/util/ReenableStupidWarnings.h" 47 | 48 | #endif // EIGEN_PASTIXSUPPORT_MODULE_H 49 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/PardisoSupport: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_PARDISOSUPPORT_MODULE_H 9 | #define EIGEN_PARDISOSUPPORT_MODULE_H 10 | 11 | #include "SparseCore" 12 | 13 | #include "src/Core/util/DisableStupidWarnings.h" 14 | 15 | #include 16 | 17 | /** \ingroup Support_modules 18 | * \defgroup PardisoSupport_Module PardisoSupport module 19 | * 20 | * This module brings support for the Intel(R) MKL PARDISO direct sparse solvers. 21 | * 22 | * \code 23 | * #include 24 | * \endcode 25 | * 26 | * 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. 27 | * See this \ref TopicUsingIntelMKL "page" for more information on MKL-Eigen integration. 28 | * 29 | */ 30 | 31 | #include "src/PardisoSupport/PardisoSupport.h" 32 | 33 | #include "src/Core/util/ReenableStupidWarnings.h" 34 | 35 | #endif // EIGEN_PARDISOSUPPORT_MODULE_H 36 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/QR: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_QR_MODULE_H 9 | #define EIGEN_QR_MODULE_H 10 | 11 | #include "Core" 12 | 13 | #include "src/Core/util/DisableStupidWarnings.h" 14 | 15 | #include "Cholesky" 16 | #include "Jacobi" 17 | #include "Householder" 18 | 19 | /** \defgroup QR_Module QR module 20 | * 21 | * 22 | * 23 | * This module provides various QR decompositions 24 | * This module also provides some MatrixBase methods, including: 25 | * - MatrixBase::householderQr() 26 | * - MatrixBase::colPivHouseholderQr() 27 | * - MatrixBase::fullPivHouseholderQr() 28 | * 29 | * \code 30 | * #include 31 | * \endcode 32 | */ 33 | 34 | #include "src/QR/HouseholderQR.h" 35 | #include "src/QR/FullPivHouseholderQR.h" 36 | #include "src/QR/ColPivHouseholderQR.h" 37 | #include "src/QR/CompleteOrthogonalDecomposition.h" 38 | #ifdef EIGEN_USE_LAPACKE 39 | #include "src/misc/lapacke.h" 40 | #include "src/QR/HouseholderQR_LAPACKE.h" 41 | #include "src/QR/ColPivHouseholderQR_LAPACKE.h" 42 | #endif 43 | 44 | #include "src/Core/util/ReenableStupidWarnings.h" 45 | 46 | #endif // EIGEN_QR_MODULE_H 47 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 48 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/QtAlignedMalloc: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_QTMALLOC_MODULE_H 9 | #define EIGEN_QTMALLOC_MODULE_H 10 | 11 | #include "Core" 12 | 13 | #if (!EIGEN_MALLOC_ALREADY_ALIGNED) 14 | 15 | #include "src/Core/util/DisableStupidWarnings.h" 16 | 17 | void *qMalloc(size_t size) 18 | { 19 | return Eigen::internal::aligned_malloc(size); 20 | } 21 | 22 | void qFree(void *ptr) 23 | { 24 | Eigen::internal::aligned_free(ptr); 25 | } 26 | 27 | void *qRealloc(void *ptr, size_t size) 28 | { 29 | void* newPtr = Eigen::internal::aligned_malloc(size); 30 | memcpy(newPtr, ptr, size); 31 | Eigen::internal::aligned_free(ptr); 32 | return newPtr; 33 | } 34 | 35 | #include "src/Core/util/ReenableStupidWarnings.h" 36 | 37 | #endif 38 | 39 | #endif // EIGEN_QTMALLOC_MODULE_H 40 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 41 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/SPQRSupport: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_SPQRSUPPORT_MODULE_H 9 | #define EIGEN_SPQRSUPPORT_MODULE_H 10 | 11 | #include "SparseCore" 12 | 13 | #include "src/Core/util/DisableStupidWarnings.h" 14 | 15 | #include "SuiteSparseQR.hpp" 16 | 17 | /** \ingroup Support_modules 18 | * \defgroup SPQRSupport_Module SuiteSparseQR module 19 | * 20 | * This module provides an interface to the SPQR library, which is part of the suitesparse package. 21 | * 22 | * \code 23 | * #include 24 | * \endcode 25 | * 26 | * 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,...). 27 | * For a cmake based project, you can use our FindSPQR.cmake and FindCholmod.Cmake modules 28 | * 29 | */ 30 | 31 | #include "src/CholmodSupport/CholmodSupport.h" 32 | #include "src/SPQRSupport/SuiteSparseQRSupport.h" 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/SVD: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_SVD_MODULE_H 9 | #define EIGEN_SVD_MODULE_H 10 | 11 | #include "QR" 12 | #include "Householder" 13 | #include "Jacobi" 14 | 15 | #include "src/Core/util/DisableStupidWarnings.h" 16 | 17 | /** \defgroup SVD_Module SVD module 18 | * 19 | * 20 | * 21 | * This module provides SVD decomposition for matrices (both real and complex). 22 | * Two decomposition algorithms are provided: 23 | * - JacobiSVD implementing two-sided Jacobi iterations is numerically very accurate, fast for small matrices, but very slow for larger ones. 24 | * - BDCSVD implementing a recursive divide & conquer strategy on top of an upper-bidiagonalization which remains fast for large problems. 25 | * These decompositions are accessible via the respective classes and following MatrixBase methods: 26 | * - MatrixBase::jacobiSvd() 27 | * - MatrixBase::bdcSvd() 28 | * 29 | * \code 30 | * #include 31 | * \endcode 32 | */ 33 | 34 | #include "src/misc/RealSvd2x2.h" 35 | #include "src/SVD/UpperBidiagonalization.h" 36 | #include "src/SVD/SVDBase.h" 37 | #include "src/SVD/JacobiSVD.h" 38 | #include "src/SVD/BDCSVD.h" 39 | #if defined(EIGEN_USE_LAPACKE) && !defined(EIGEN_USE_LAPACKE_STRICT) 40 | #include "src/misc/lapacke.h" 41 | #include "src/SVD/JacobiSVD_LAPACKE.h" 42 | #endif 43 | 44 | #include "src/Core/util/ReenableStupidWarnings.h" 45 | 46 | #endif // EIGEN_SVD_MODULE_H 47 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 48 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/Sparse: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_SPARSE_MODULE_H 9 | #define EIGEN_SPARSE_MODULE_H 10 | 11 | /** \defgroup Sparse_Module Sparse meta-module 12 | * 13 | * Meta-module including all related modules: 14 | * - \ref SparseCore_Module 15 | * - \ref OrderingMethods_Module 16 | * - \ref SparseCholesky_Module 17 | * - \ref SparseLU_Module 18 | * - \ref SparseQR_Module 19 | * - \ref IterativeLinearSolvers_Module 20 | * 21 | \code 22 | #include 23 | \endcode 24 | */ 25 | 26 | #include "SparseCore" 27 | #include "OrderingMethods" 28 | #include "SparseCholesky" 29 | #include "SparseLU" 30 | #include "SparseQR" 31 | #include "IterativeLinearSolvers" 32 | 33 | #endif // EIGEN_SPARSE_MODULE_H 34 | 35 | -------------------------------------------------------------------------------- /DevelopApp/Include/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/SparseCholesky/SimplicialCholesky.h" 38 | 39 | #ifndef EIGEN_MPL2_ONLY 40 | #include "src/SparseCholesky/SimplicialCholesky_impl.h" 41 | #endif 42 | 43 | #include "src/Core/util/ReenableStupidWarnings.h" 44 | 45 | #endif // EIGEN_SPARSECHOLESKY_MODULE_H 46 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/SparseCore: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_SPARSECORE_MODULE_H 9 | #define EIGEN_SPARSECORE_MODULE_H 10 | 11 | #include "Core" 12 | 13 | #include "src/Core/util/DisableStupidWarnings.h" 14 | 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | 21 | /** 22 | * \defgroup SparseCore_Module SparseCore module 23 | * 24 | * This module provides a sparse matrix representation, and basic associated matrix manipulations 25 | * and operations. 26 | * 27 | * See the \ref TutorialSparse "Sparse tutorial" 28 | * 29 | * \code 30 | * #include 31 | * \endcode 32 | * 33 | * This module depends on: Core. 34 | */ 35 | 36 | #include "src/SparseCore/SparseUtil.h" 37 | #include "src/SparseCore/SparseMatrixBase.h" 38 | #include "src/SparseCore/SparseAssign.h" 39 | #include "src/SparseCore/CompressedStorage.h" 40 | #include "src/SparseCore/AmbiVector.h" 41 | #include "src/SparseCore/SparseCompressedBase.h" 42 | #include "src/SparseCore/SparseMatrix.h" 43 | #include "src/SparseCore/SparseMap.h" 44 | #include "src/SparseCore/MappedSparseMatrix.h" 45 | #include "src/SparseCore/SparseVector.h" 46 | #include "src/SparseCore/SparseRef.h" 47 | #include "src/SparseCore/SparseCwiseUnaryOp.h" 48 | #include "src/SparseCore/SparseCwiseBinaryOp.h" 49 | #include "src/SparseCore/SparseTranspose.h" 50 | #include "src/SparseCore/SparseBlock.h" 51 | #include "src/SparseCore/SparseDot.h" 52 | #include "src/SparseCore/SparseRedux.h" 53 | #include "src/SparseCore/SparseView.h" 54 | #include "src/SparseCore/SparseDiagonalProduct.h" 55 | #include "src/SparseCore/ConservativeSparseSparseProduct.h" 56 | #include "src/SparseCore/SparseSparseProductWithPruning.h" 57 | #include "src/SparseCore/SparseProduct.h" 58 | #include "src/SparseCore/SparseDenseProduct.h" 59 | #include "src/SparseCore/SparseSelfAdjointView.h" 60 | #include "src/SparseCore/SparseTriangularView.h" 61 | #include "src/SparseCore/TriangularSolver.h" 62 | #include "src/SparseCore/SparsePermutation.h" 63 | #include "src/SparseCore/SparseFuzzy.h" 64 | #include "src/SparseCore/SparseSolverBase.h" 65 | 66 | #include "src/Core/util/ReenableStupidWarnings.h" 67 | 68 | #endif // EIGEN_SPARSECORE_MODULE_H 69 | 70 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | // Ordering interface 24 | #include "OrderingMethods" 25 | 26 | #include "src/SparseLU/SparseLU_gemm_kernel.h" 27 | 28 | #include "src/SparseLU/SparseLU_Structs.h" 29 | #include "src/SparseLU/SparseLU_SupernodalMatrix.h" 30 | #include "src/SparseLU/SparseLUImpl.h" 31 | #include "src/SparseCore/SparseColEtree.h" 32 | #include "src/SparseLU/SparseLU_Memory.h" 33 | #include "src/SparseLU/SparseLU_heap_relax_snode.h" 34 | #include "src/SparseLU/SparseLU_relax_snode.h" 35 | #include "src/SparseLU/SparseLU_pivotL.h" 36 | #include "src/SparseLU/SparseLU_panel_dfs.h" 37 | #include "src/SparseLU/SparseLU_kernel_bmod.h" 38 | #include "src/SparseLU/SparseLU_panel_bmod.h" 39 | #include "src/SparseLU/SparseLU_column_dfs.h" 40 | #include "src/SparseLU/SparseLU_column_bmod.h" 41 | #include "src/SparseLU/SparseLU_copy_to_ucol.h" 42 | #include "src/SparseLU/SparseLU_pruneL.h" 43 | #include "src/SparseLU/SparseLU_Utils.h" 44 | #include "src/SparseLU/SparseLU.h" 45 | 46 | #endif // EIGEN_SPARSELU_MODULE_H 47 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/SparseQR: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_SPARSEQR_MODULE_H 9 | #define EIGEN_SPARSEQR_MODULE_H 10 | 11 | #include "SparseCore" 12 | #include "OrderingMethods" 13 | #include "src/Core/util/DisableStupidWarnings.h" 14 | 15 | /** \defgroup SparseQR_Module SparseQR module 16 | * \brief Provides QR decomposition for sparse matrices 17 | * 18 | * This module provides a simplicial version of the left-looking Sparse QR decomposition. 19 | * The columns of the input matrix should be reordered to limit the fill-in during the 20 | * decomposition. Built-in methods (COLAMD, AMD) or external methods (METIS) can be used to this end. 21 | * See the \link OrderingMethods_Module OrderingMethods\endlink module for the list 22 | * of built-in and external ordering methods. 23 | * 24 | * \code 25 | * #include 26 | * \endcode 27 | * 28 | * 29 | */ 30 | 31 | #include "OrderingMethods" 32 | #include "src/SparseCore/SparseColEtree.h" 33 | #include "src/SparseQR/SparseQR.h" 34 | 35 | #include "src/Core/util/ReenableStupidWarnings.h" 36 | 37 | #endif 38 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 EIGEN_COMP_MSVC && EIGEN_OS_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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 EIGEN_COMP_MSVC && EIGEN_OS_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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 EIGEN_COMP_MSVC && EIGEN_OS_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 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/SuperLUSupport: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_SUPERLUSUPPORT_MODULE_H 9 | #define EIGEN_SUPERLUSUPPORT_MODULE_H 10 | 11 | #include "SparseCore" 12 | 13 | #include "src/Core/util/DisableStupidWarnings.h" 14 | 15 | #ifdef EMPTY 16 | #define EIGEN_EMPTY_WAS_ALREADY_DEFINED 17 | #endif 18 | 19 | typedef int int_t; 20 | #include 21 | #include 22 | #include 23 | 24 | // slu_util.h defines a preprocessor token named EMPTY which is really polluting, 25 | // so we remove it in favor of a SUPERLU_EMPTY token. 26 | // If EMPTY was already defined then we don't undef it. 27 | 28 | #if defined(EIGEN_EMPTY_WAS_ALREADY_DEFINED) 29 | # undef EIGEN_EMPTY_WAS_ALREADY_DEFINED 30 | #elif defined(EMPTY) 31 | # undef EMPTY 32 | #endif 33 | 34 | #define SUPERLU_EMPTY (-1) 35 | 36 | namespace Eigen { struct SluMatrix; } 37 | 38 | /** \ingroup Support_modules 39 | * \defgroup SuperLUSupport_Module SuperLUSupport module 40 | * 41 | * This module provides an interface to the SuperLU library. 42 | * It provides the following factorization class: 43 | * - class SuperLU: a supernodal sequential LU factorization. 44 | * - class SuperILU: a supernodal sequential incomplete LU factorization (to be used as a preconditioner for iterative methods). 45 | * 46 | * \warning This wrapper requires at least versions 4.0 of SuperLU. The 3.x versions are not supported. 47 | * 48 | * \warning When including this module, you have to use SUPERLU_EMPTY instead of EMPTY which is no longer defined because it is too polluting. 49 | * 50 | * \code 51 | * #include 52 | * \endcode 53 | * 54 | * 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. 55 | * The dependencies depend on how superlu has been compiled. 56 | * For a cmake based project, you can use our FindSuperLU.cmake module to help you in this task. 57 | * 58 | */ 59 | 60 | #include "src/SuperLUSupport/SuperLUSupport.h" 61 | 62 | #include "src/Core/util/ReenableStupidWarnings.h" 63 | 64 | #endif // EIGEN_SUPERLUSUPPORT_MODULE_H 65 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/UmfPackSupport: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | #ifndef EIGEN_UMFPACKSUPPORT_MODULE_H 9 | #define EIGEN_UMFPACKSUPPORT_MODULE_H 10 | 11 | #include "SparseCore" 12 | 13 | #include "src/Core/util/DisableStupidWarnings.h" 14 | 15 | extern "C" { 16 | #include 17 | } 18 | 19 | /** \ingroup Support_modules 20 | * \defgroup UmfPackSupport_Module UmfPackSupport module 21 | * 22 | * This module provides an interface to the UmfPack library which is part of the suitesparse package. 23 | * It provides the following factorization class: 24 | * - class UmfPackLU: a multifrontal sequential LU factorization. 25 | * 26 | * \code 27 | * #include 28 | * \endcode 29 | * 30 | * 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. 31 | * The dependencies depend on how umfpack has been compiled. 32 | * For a cmake based project, you can use our FindUmfPack.cmake module to help you in this task. 33 | * 34 | */ 35 | 36 | #include "src/UmfPackSupport/UmfPackSupport.h" 37 | 38 | #include "src/Core/util/ReenableStupidWarnings.h" 39 | 40 | #endif // EIGEN_UMFPACKSUPPORT_MODULE_H 41 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Core/Assign.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2007 Michael Olbrich 5 | // Copyright (C) 2006-2010 Benoit Jacob 6 | // Copyright (C) 2008 Gael Guennebaud 7 | // 8 | // This Source Code Form is subject to the terms of the Mozilla 9 | // Public License v. 2.0. If a copy of the MPL was not distributed 10 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 11 | 12 | #ifndef EIGEN_ASSIGN_H 13 | #define EIGEN_ASSIGN_H 14 | 15 | namespace Eigen { 16 | 17 | template 18 | template 19 | EIGEN_STRONG_INLINE Derived& DenseBase 20 | ::lazyAssign(const DenseBase& other) 21 | { 22 | enum{ 23 | SameType = internal::is_same::value 24 | }; 25 | 26 | EIGEN_STATIC_ASSERT_LVALUE(Derived) 27 | EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Derived,OtherDerived) 28 | EIGEN_STATIC_ASSERT(SameType,YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) 29 | 30 | eigen_assert(rows() == other.rows() && cols() == other.cols()); 31 | internal::call_assignment_no_alias(derived(),other.derived()); 32 | 33 | return derived(); 34 | } 35 | 36 | template 37 | template 38 | EIGEN_DEVICE_FUNC 39 | EIGEN_STRONG_INLINE Derived& DenseBase::operator=(const DenseBase& other) 40 | { 41 | internal::call_assignment(derived(), other.derived()); 42 | return derived(); 43 | } 44 | 45 | template 46 | EIGEN_DEVICE_FUNC 47 | EIGEN_STRONG_INLINE Derived& DenseBase::operator=(const DenseBase& other) 48 | { 49 | internal::call_assignment(derived(), other.derived()); 50 | return derived(); 51 | } 52 | 53 | template 54 | EIGEN_DEVICE_FUNC 55 | EIGEN_STRONG_INLINE Derived& MatrixBase::operator=(const MatrixBase& other) 56 | { 57 | internal::call_assignment(derived(), other.derived()); 58 | return derived(); 59 | } 60 | 61 | template 62 | template 63 | EIGEN_DEVICE_FUNC 64 | EIGEN_STRONG_INLINE Derived& MatrixBase::operator=(const DenseBase& other) 65 | { 66 | internal::call_assignment(derived(), other.derived()); 67 | return derived(); 68 | } 69 | 70 | template 71 | template 72 | EIGEN_DEVICE_FUNC 73 | EIGEN_STRONG_INLINE Derived& MatrixBase::operator=(const EigenBase& other) 74 | { 75 | internal::call_assignment(derived(), other.derived()); 76 | return derived(); 77 | } 78 | 79 | template 80 | template 81 | EIGEN_DEVICE_FUNC 82 | EIGEN_STRONG_INLINE Derived& MatrixBase::operator=(const ReturnByValue& other) 83 | { 84 | other.derived().evalTo(derived()); 85 | return derived(); 86 | } 87 | 88 | } // end namespace Eigen 89 | 90 | #endif // EIGEN_ASSIGN_H 91 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | ADD_SUBDIRECTORY(functors) 12 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Core/DiagonalProduct.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) 2007-2009 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 EIGEN_DIAGONALPRODUCT_H 12 | #define EIGEN_DIAGONALPRODUCT_H 13 | 14 | namespace Eigen { 15 | 16 | /** \returns the diagonal matrix product of \c *this by the diagonal matrix \a diagonal. 17 | */ 18 | template 19 | template 20 | inline const Product 21 | MatrixBase::operator*(const DiagonalBase &a_diagonal) const 22 | { 23 | return Product(derived(),a_diagonal.derived()); 24 | } 25 | 26 | } // end namespace Eigen 27 | 28 | #endif // EIGEN_DIAGONALPRODUCT_H 29 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Core/Inverse.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2014 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_INVERSE_H 11 | #define EIGEN_INVERSE_H 12 | 13 | namespace Eigen { 14 | 15 | template class InverseImpl; 16 | 17 | namespace internal { 18 | 19 | template 20 | struct traits > 21 | : traits 22 | { 23 | typedef typename XprType::PlainObject PlainObject; 24 | typedef traits BaseTraits; 25 | enum { 26 | Flags = BaseTraits::Flags & RowMajorBit 27 | }; 28 | }; 29 | 30 | } // end namespace internal 31 | 32 | /** \class Inverse 33 | * 34 | * \brief Expression of the inverse of another expression 35 | * 36 | * \tparam XprType the type of the expression we are taking the inverse 37 | * 38 | * This class represents an abstract expression of A.inverse() 39 | * and most of the time this is the only way it is used. 40 | * 41 | */ 42 | template 43 | class Inverse : public InverseImpl::StorageKind> 44 | { 45 | public: 46 | typedef typename XprType::StorageIndex StorageIndex; 47 | typedef typename XprType::PlainObject PlainObject; 48 | typedef typename internal::ref_selector::type XprTypeNested; 49 | typedef typename internal::remove_all::type XprTypeNestedCleaned; 50 | typedef typename internal::ref_selector::type Nested; 51 | typedef typename internal::remove_all::type NestedExpression; 52 | 53 | explicit Inverse(const XprType &xpr) 54 | : m_xpr(xpr) 55 | {} 56 | 57 | EIGEN_DEVICE_FUNC Index rows() const { return m_xpr.rows(); } 58 | EIGEN_DEVICE_FUNC Index cols() const { return m_xpr.cols(); } 59 | 60 | EIGEN_DEVICE_FUNC const XprTypeNestedCleaned& nestedExpression() const { return m_xpr; } 61 | 62 | protected: 63 | XprTypeNested m_xpr; 64 | }; 65 | 66 | // Generic API dispatcher 67 | template 68 | class InverseImpl 69 | : public internal::generic_xpr_base >::type 70 | { 71 | public: 72 | typedef typename internal::generic_xpr_base >::type Base; 73 | typedef typename XprType::Scalar Scalar; 74 | private: 75 | 76 | Scalar coeff(Index row, Index col) const; 77 | Scalar coeff(Index i) const; 78 | }; 79 | 80 | namespace internal { 81 | 82 | /** \internal 83 | * \brief Default evaluator for Inverse expression. 84 | * 85 | * This default evaluator for Inverse expression simply evaluate the inverse into a temporary 86 | * by a call to internal::call_assignment_no_alias. 87 | * Therefore, inverse implementers only have to specialize Assignment, ...> for 88 | * there own nested expression. 89 | * 90 | * \sa class Inverse 91 | */ 92 | template 93 | struct unary_evaluator > 94 | : public evaluator::PlainObject> 95 | { 96 | typedef Inverse InverseType; 97 | typedef typename InverseType::PlainObject PlainObject; 98 | typedef evaluator Base; 99 | 100 | enum { Flags = Base::Flags | EvalBeforeNestingBit }; 101 | 102 | unary_evaluator(const InverseType& inv_xpr) 103 | : m_result(inv_xpr.rows(), inv_xpr.cols()) 104 | { 105 | ::new (static_cast(this)) Base(m_result); 106 | internal::call_assignment_no_alias(m_result, inv_xpr); 107 | } 108 | 109 | protected: 110 | PlainObject m_result; 111 | }; 112 | 113 | } // end namespace internal 114 | 115 | } // end namespace Eigen 116 | 117 | #endif // EIGEN_INVERSE_H 118 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Core/NestByValue.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) 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 | #ifndef EIGEN_NESTBYVALUE_H 12 | #define EIGEN_NESTBYVALUE_H 13 | 14 | namespace Eigen { 15 | 16 | namespace internal { 17 | template 18 | struct traits > : public traits 19 | {}; 20 | } 21 | 22 | /** \class NestByValue 23 | * \ingroup Core_Module 24 | * 25 | * \brief Expression which must be nested by value 26 | * 27 | * \tparam ExpressionType the type of the object of which we are requiring nesting-by-value 28 | * 29 | * This class is the return type of MatrixBase::nestByValue() 30 | * and most of the time this is the only way it is used. 31 | * 32 | * \sa MatrixBase::nestByValue() 33 | */ 34 | template class NestByValue 35 | : public internal::dense_xpr_base< NestByValue >::type 36 | { 37 | public: 38 | 39 | typedef typename internal::dense_xpr_base::type Base; 40 | EIGEN_DENSE_PUBLIC_INTERFACE(NestByValue) 41 | 42 | EIGEN_DEVICE_FUNC explicit inline NestByValue(const ExpressionType& matrix) : m_expression(matrix) {} 43 | 44 | EIGEN_DEVICE_FUNC inline Index rows() const { return m_expression.rows(); } 45 | EIGEN_DEVICE_FUNC inline Index cols() const { return m_expression.cols(); } 46 | EIGEN_DEVICE_FUNC inline Index outerStride() const { return m_expression.outerStride(); } 47 | EIGEN_DEVICE_FUNC inline Index innerStride() const { return m_expression.innerStride(); } 48 | 49 | EIGEN_DEVICE_FUNC inline const CoeffReturnType coeff(Index row, Index col) const 50 | { 51 | return m_expression.coeff(row, col); 52 | } 53 | 54 | EIGEN_DEVICE_FUNC inline Scalar& coeffRef(Index row, Index col) 55 | { 56 | return m_expression.const_cast_derived().coeffRef(row, col); 57 | } 58 | 59 | EIGEN_DEVICE_FUNC inline const CoeffReturnType coeff(Index index) const 60 | { 61 | return m_expression.coeff(index); 62 | } 63 | 64 | EIGEN_DEVICE_FUNC inline Scalar& coeffRef(Index index) 65 | { 66 | return m_expression.const_cast_derived().coeffRef(index); 67 | } 68 | 69 | template 70 | inline const PacketScalar packet(Index row, Index col) const 71 | { 72 | return m_expression.template packet(row, col); 73 | } 74 | 75 | template 76 | inline void writePacket(Index row, Index col, const PacketScalar& x) 77 | { 78 | m_expression.const_cast_derived().template writePacket(row, col, x); 79 | } 80 | 81 | template 82 | inline const PacketScalar packet(Index index) const 83 | { 84 | return m_expression.template packet(index); 85 | } 86 | 87 | template 88 | inline void writePacket(Index index, const PacketScalar& x) 89 | { 90 | m_expression.const_cast_derived().template writePacket(index, x); 91 | } 92 | 93 | EIGEN_DEVICE_FUNC operator const ExpressionType&() const { return m_expression; } 94 | 95 | protected: 96 | const ExpressionType m_expression; 97 | }; 98 | 99 | /** \returns an expression of the temporary version of *this. 100 | */ 101 | template 102 | inline const NestByValue 103 | DenseBase::nestByValue() const 104 | { 105 | return NestByValue(derived()); 106 | } 107 | 108 | } // end namespace Eigen 109 | 110 | #endif // EIGEN_NESTBYVALUE_H 111 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Core/NoAlias.h: -------------------------------------------------------------------------------- 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 | #ifndef EIGEN_NOALIAS_H 11 | #define EIGEN_NOALIAS_H 12 | 13 | namespace Eigen { 14 | 15 | /** \class NoAlias 16 | * \ingroup Core_Module 17 | * 18 | * \brief Pseudo expression providing an operator = assuming no aliasing 19 | * 20 | * \tparam ExpressionType the type of the object on which to do the lazy assignment 21 | * 22 | * This class represents an expression with special assignment operators 23 | * assuming no aliasing between the target expression and the source expression. 24 | * More precisely it alloas to bypass the EvalBeforeAssignBit flag of the source expression. 25 | * It is the return type of MatrixBase::noalias() 26 | * and most of the time this is the only way it is used. 27 | * 28 | * \sa MatrixBase::noalias() 29 | */ 30 | template class StorageBase> 31 | class NoAlias 32 | { 33 | public: 34 | typedef typename ExpressionType::Scalar Scalar; 35 | 36 | explicit NoAlias(ExpressionType& expression) : m_expression(expression) {} 37 | 38 | template 39 | EIGEN_DEVICE_FUNC 40 | EIGEN_STRONG_INLINE ExpressionType& operator=(const StorageBase& other) 41 | { 42 | call_assignment_no_alias(m_expression, other.derived(), internal::assign_op()); 43 | return m_expression; 44 | } 45 | 46 | template 47 | EIGEN_DEVICE_FUNC 48 | EIGEN_STRONG_INLINE ExpressionType& operator+=(const StorageBase& other) 49 | { 50 | call_assignment_no_alias(m_expression, other.derived(), internal::add_assign_op()); 51 | return m_expression; 52 | } 53 | 54 | template 55 | EIGEN_DEVICE_FUNC 56 | EIGEN_STRONG_INLINE ExpressionType& operator-=(const StorageBase& other) 57 | { 58 | call_assignment_no_alias(m_expression, other.derived(), internal::sub_assign_op()); 59 | return m_expression; 60 | } 61 | 62 | EIGEN_DEVICE_FUNC 63 | ExpressionType& expression() const 64 | { 65 | return m_expression; 66 | } 67 | 68 | protected: 69 | ExpressionType& m_expression; 70 | }; 71 | 72 | /** \returns a pseudo expression of \c *this with an operator= assuming 73 | * no aliasing between \c *this and the source expression. 74 | * 75 | * More precisely, noalias() allows to bypass the EvalBeforeAssignBit flag. 76 | * Currently, even though several expressions may alias, only product 77 | * expressions have this flag. Therefore, noalias() is only usefull when 78 | * the source expression contains a matrix product. 79 | * 80 | * Here are some examples where noalias is usefull: 81 | * \code 82 | * D.noalias() = A * B; 83 | * D.noalias() += A.transpose() * B; 84 | * D.noalias() -= 2 * A * B.adjoint(); 85 | * \endcode 86 | * 87 | * On the other hand the following example will lead to a \b wrong result: 88 | * \code 89 | * A.noalias() = A * B; 90 | * \endcode 91 | * because the result matrix A is also an operand of the matrix product. Therefore, 92 | * there is no alternative than evaluating A * B in a temporary, that is the default 93 | * behavior when you write: 94 | * \code 95 | * A = A * B; 96 | * \endcode 97 | * 98 | * \sa class NoAlias 99 | */ 100 | template 101 | NoAlias MatrixBase::noalias() 102 | { 103 | return NoAlias(derived()); 104 | } 105 | 106 | } // end namespace Eigen 107 | 108 | #endif // EIGEN_NOALIAS_H 109 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Core/SelfCwiseBinaryOp.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009-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_SELFCWISEBINARYOP_H 11 | #define EIGEN_SELFCWISEBINARYOP_H 12 | 13 | namespace Eigen { 14 | 15 | // TODO generalize the scalar type of 'other' 16 | 17 | template 18 | EIGEN_STRONG_INLINE Derived& DenseBase::operator*=(const Scalar& other) 19 | { 20 | typedef typename Derived::PlainObject PlainObject; 21 | internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::mul_assign_op()); 22 | return derived(); 23 | } 24 | 25 | template 26 | EIGEN_STRONG_INLINE Derived& ArrayBase::operator+=(const Scalar& other) 27 | { 28 | typedef typename Derived::PlainObject PlainObject; 29 | internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::add_assign_op()); 30 | return derived(); 31 | } 32 | 33 | template 34 | EIGEN_STRONG_INLINE Derived& ArrayBase::operator-=(const Scalar& other) 35 | { 36 | typedef typename Derived::PlainObject PlainObject; 37 | internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::sub_assign_op()); 38 | return derived(); 39 | } 40 | 41 | template 42 | EIGEN_STRONG_INLINE Derived& DenseBase::operator/=(const Scalar& other) 43 | { 44 | typedef typename Derived::PlainObject PlainObject; 45 | internal::call_assignment(this->derived(), PlainObject::Constant(rows(),cols(),other), internal::div_assign_op()); 46 | return derived(); 47 | } 48 | 49 | } // end namespace Eigen 50 | 51 | #endif // EIGEN_SELFCWISEBINARYOP_H 52 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Core/Swap.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2006-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_SWAP_H 11 | #define EIGEN_SWAP_H 12 | 13 | namespace Eigen { 14 | 15 | namespace internal { 16 | 17 | // Overload default assignPacket behavior for swapping them 18 | template 19 | class generic_dense_assignment_kernel, Specialized> 20 | : public generic_dense_assignment_kernel, BuiltIn> 21 | { 22 | protected: 23 | typedef generic_dense_assignment_kernel, BuiltIn> Base; 24 | using Base::m_dst; 25 | using Base::m_src; 26 | using Base::m_functor; 27 | 28 | public: 29 | typedef typename Base::Scalar Scalar; 30 | typedef typename Base::DstXprType DstXprType; 31 | typedef swap_assign_op Functor; 32 | 33 | EIGEN_DEVICE_FUNC generic_dense_assignment_kernel(DstEvaluatorTypeT &dst, const SrcEvaluatorTypeT &src, const Functor &func, DstXprType& dstExpr) 34 | : Base(dst, src, func, dstExpr) 35 | {} 36 | 37 | template 38 | void assignPacket(Index row, Index col) 39 | { 40 | PacketType tmp = m_src.template packet(row,col); 41 | const_cast(m_src).template writePacket(row,col, m_dst.template packet(row,col)); 42 | m_dst.template writePacket(row,col,tmp); 43 | } 44 | 45 | template 46 | void assignPacket(Index index) 47 | { 48 | PacketType tmp = m_src.template packet(index); 49 | const_cast(m_src).template writePacket(index, m_dst.template packet(index)); 50 | m_dst.template writePacket(index,tmp); 51 | } 52 | 53 | // TODO find a simple way not to have to copy/paste this function from generic_dense_assignment_kernel, by simple I mean no CRTP (Gael) 54 | template 55 | void assignPacketByOuterInner(Index outer, Index inner) 56 | { 57 | Index row = Base::rowIndexByOuterInner(outer, inner); 58 | Index col = Base::colIndexByOuterInner(outer, inner); 59 | assignPacket(row, col); 60 | } 61 | }; 62 | 63 | } // namespace internal 64 | 65 | } // end namespace Eigen 66 | 67 | #endif // EIGEN_SWAP_H 68 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Core/VectorBlock.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 | #ifndef EIGEN_VECTORBLOCK_H 12 | #define EIGEN_VECTORBLOCK_H 13 | 14 | namespace Eigen { 15 | 16 | namespace internal { 17 | template 18 | struct traits > 19 | : public traits::Flags & RowMajorBit ? 1 : Size, 21 | traits::Flags & RowMajorBit ? Size : 1> > 22 | { 23 | }; 24 | } 25 | 26 | /** \class VectorBlock 27 | * \ingroup Core_Module 28 | * 29 | * \brief Expression of a fixed-size or dynamic-size sub-vector 30 | * 31 | * \tparam VectorType the type of the object in which we are taking a sub-vector 32 | * \tparam Size size of the sub-vector we are taking at compile time (optional) 33 | * 34 | * This class represents an expression of either a fixed-size or dynamic-size sub-vector. 35 | * It is the return type of DenseBase::segment(Index,Index) and DenseBase::segment(Index) and 36 | * most of the time this is the only way it is used. 37 | * 38 | * However, if you want to directly maniputate sub-vector expressions, 39 | * for instance if you want to write a function returning such an expression, you 40 | * will need to use this class. 41 | * 42 | * Here is an example illustrating the dynamic case: 43 | * \include class_VectorBlock.cpp 44 | * Output: \verbinclude class_VectorBlock.out 45 | * 46 | * \note Even though this expression has dynamic size, in the case where \a VectorType 47 | * has fixed size, this expression inherits a fixed maximal size which means that evaluating 48 | * it does not cause a dynamic memory allocation. 49 | * 50 | * Here is an example illustrating the fixed-size case: 51 | * \include class_FixedVectorBlock.cpp 52 | * Output: \verbinclude class_FixedVectorBlock.out 53 | * 54 | * \sa class Block, DenseBase::segment(Index,Index,Index,Index), DenseBase::segment(Index,Index) 55 | */ 56 | template class VectorBlock 57 | : public Block::Flags & RowMajorBit ? 1 : Size, 59 | internal::traits::Flags & RowMajorBit ? Size : 1> 60 | { 61 | typedef Block::Flags & RowMajorBit ? 1 : Size, 63 | internal::traits::Flags & RowMajorBit ? Size : 1> Base; 64 | enum { 65 | IsColVector = !(internal::traits::Flags & RowMajorBit) 66 | }; 67 | public: 68 | EIGEN_DENSE_PUBLIC_INTERFACE(VectorBlock) 69 | 70 | using Base::operator=; 71 | 72 | /** Dynamic-size constructor 73 | */ 74 | EIGEN_DEVICE_FUNC 75 | inline VectorBlock(VectorType& vector, Index start, Index size) 76 | : Base(vector, 77 | IsColVector ? start : 0, IsColVector ? 0 : start, 78 | IsColVector ? size : 1, IsColVector ? 1 : size) 79 | { 80 | EIGEN_STATIC_ASSERT_VECTOR_ONLY(VectorBlock); 81 | } 82 | 83 | /** Fixed-size constructor 84 | */ 85 | EIGEN_DEVICE_FUNC 86 | inline VectorBlock(VectorType& vector, Index start) 87 | : Base(vector, IsColVector ? start : 0, IsColVector ? 0 : start) 88 | { 89 | EIGEN_STATIC_ASSERT_VECTOR_ONLY(VectorBlock); 90 | } 91 | }; 92 | 93 | 94 | } // end namespace Eigen 95 | 96 | #endif // EIGEN_VECTORBLOCK_H 97 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Core/arch/AVX/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_arch_AVX_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_arch_AVX_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/AVX COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Core/arch/AVX/TypeCasting.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2015 Benoit Steiner 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_TYPE_CASTING_AVX_H 11 | #define EIGEN_TYPE_CASTING_AVX_H 12 | 13 | namespace Eigen { 14 | 15 | namespace internal { 16 | 17 | // For now we use SSE to handle integers, so we can't use AVX instructions to cast 18 | // from int to float 19 | template <> 20 | struct type_casting_traits { 21 | enum { 22 | VectorizedCast = 0, 23 | SrcCoeffRatio = 1, 24 | TgtCoeffRatio = 1 25 | }; 26 | }; 27 | 28 | template <> 29 | struct type_casting_traits { 30 | enum { 31 | VectorizedCast = 0, 32 | SrcCoeffRatio = 1, 33 | TgtCoeffRatio = 1 34 | }; 35 | }; 36 | 37 | 38 | 39 | template<> EIGEN_STRONG_INLINE Packet8i pcast(const Packet8f& a) { 40 | return _mm256_cvtps_epi32(a); 41 | } 42 | 43 | template<> EIGEN_STRONG_INLINE Packet8f pcast(const Packet8i& a) { 44 | return _mm256_cvtepi32_ps(a); 45 | } 46 | 47 | } // end namespace internal 48 | 49 | } // end namespace Eigen 50 | 51 | #endif // EIGEN_TYPE_CASTING_AVX_H 52 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Core/arch/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | ADD_SUBDIRECTORY(AltiVec) 2 | ADD_SUBDIRECTORY(AVX) 3 | ADD_SUBDIRECTORY(CUDA) 4 | ADD_SUBDIRECTORY(Default) 5 | ADD_SUBDIRECTORY(NEON) 6 | ADD_SUBDIRECTORY(SSE) 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Core/arch/CUDA/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_arch_CUDA_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_arch_CUDA_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/CUDA COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Core/arch/CUDA/MathFunctions.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2014 Benoit Steiner 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_MATH_FUNCTIONS_CUDA_H 11 | #define EIGEN_MATH_FUNCTIONS_CUDA_H 12 | 13 | namespace Eigen { 14 | 15 | namespace internal { 16 | 17 | // Make sure this is only available when targeting a GPU: we don't want to 18 | // introduce conflicts between these packet_traits definitions and the ones 19 | // we'll use on the host side (SSE, AVX, ...) 20 | #if defined(__CUDACC__) && defined(EIGEN_USE_GPU) 21 | template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE 22 | float4 plog(const float4& a) 23 | { 24 | return make_float4(logf(a.x), logf(a.y), logf(a.z), logf(a.w)); 25 | } 26 | 27 | template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE 28 | double2 plog(const double2& a) 29 | { 30 | using ::log; 31 | return make_double2(log(a.x), log(a.y)); 32 | } 33 | 34 | template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE 35 | float4 pexp(const float4& a) 36 | { 37 | return make_float4(expf(a.x), expf(a.y), expf(a.z), expf(a.w)); 38 | } 39 | 40 | template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE 41 | double2 pexp(const double2& a) 42 | { 43 | using ::exp; 44 | return make_double2(exp(a.x), exp(a.y)); 45 | } 46 | 47 | template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE 48 | float4 psqrt(const float4& a) 49 | { 50 | return make_float4(sqrtf(a.x), sqrtf(a.y), sqrtf(a.z), sqrtf(a.w)); 51 | } 52 | 53 | template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE 54 | double2 psqrt(const double2& a) 55 | { 56 | using ::sqrt; 57 | return make_double2(sqrt(a.x), sqrt(a.y)); 58 | } 59 | 60 | template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE 61 | float4 prsqrt(const float4& a) 62 | { 63 | return make_float4(rsqrtf(a.x), rsqrtf(a.y), rsqrtf(a.z), rsqrtf(a.w)); 64 | } 65 | 66 | template<> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE 67 | double2 prsqrt(const double2& a) 68 | { 69 | return make_double2(rsqrt(a.x), rsqrt(a.y)); 70 | } 71 | 72 | 73 | #endif 74 | 75 | } // end namespace internal 76 | 77 | } // end namespace Eigen 78 | 79 | #endif // EIGEN_MATH_FUNCTIONS_CUDA_H 80 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Core/arch/NEON/MathFunctions.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // This Source Code Form is subject to the terms of the Mozilla 5 | // Public License v. 2.0. If a copy of the MPL was not distributed 6 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 7 | 8 | /* The sin, cos, exp, and log functions of this file come from 9 | * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/ 10 | */ 11 | 12 | #ifndef EIGEN_MATH_FUNCTIONS_NEON_H 13 | #define EIGEN_MATH_FUNCTIONS_NEON_H 14 | 15 | namespace Eigen { 16 | 17 | namespace internal { 18 | 19 | template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED 20 | Packet4f pexp(const Packet4f& _x) 21 | { 22 | Packet4f x = _x; 23 | Packet4f tmp, fx; 24 | 25 | _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f); 26 | _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f); 27 | _EIGEN_DECLARE_CONST_Packet4i(0x7f, 0x7f); 28 | _EIGEN_DECLARE_CONST_Packet4f(exp_hi, 88.3762626647950f); 29 | _EIGEN_DECLARE_CONST_Packet4f(exp_lo, -88.3762626647949f); 30 | _EIGEN_DECLARE_CONST_Packet4f(cephes_LOG2EF, 1.44269504088896341f); 31 | _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C1, 0.693359375f); 32 | _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C2, -2.12194440e-4f); 33 | _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p0, 1.9875691500E-4f); 34 | _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p1, 1.3981999507E-3f); 35 | _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p2, 8.3334519073E-3f); 36 | _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p3, 4.1665795894E-2f); 37 | _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p4, 1.6666665459E-1f); 38 | _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p5, 5.0000001201E-1f); 39 | 40 | x = vminq_f32(x, p4f_exp_hi); 41 | x = vmaxq_f32(x, p4f_exp_lo); 42 | 43 | /* express exp(x) as exp(g + n*log(2)) */ 44 | fx = vmlaq_f32(p4f_half, x, p4f_cephes_LOG2EF); 45 | 46 | /* perform a floorf */ 47 | tmp = vcvtq_f32_s32(vcvtq_s32_f32(fx)); 48 | 49 | /* if greater, substract 1 */ 50 | Packet4ui mask = vcgtq_f32(tmp, fx); 51 | mask = vandq_u32(mask, vreinterpretq_u32_f32(p4f_1)); 52 | 53 | fx = vsubq_f32(tmp, vreinterpretq_f32_u32(mask)); 54 | 55 | tmp = vmulq_f32(fx, p4f_cephes_exp_C1); 56 | Packet4f z = vmulq_f32(fx, p4f_cephes_exp_C2); 57 | x = vsubq_f32(x, tmp); 58 | x = vsubq_f32(x, z); 59 | 60 | Packet4f y = vmulq_f32(p4f_cephes_exp_p0, x); 61 | z = vmulq_f32(x, x); 62 | y = vaddq_f32(y, p4f_cephes_exp_p1); 63 | y = vmulq_f32(y, x); 64 | y = vaddq_f32(y, p4f_cephes_exp_p2); 65 | y = vmulq_f32(y, x); 66 | y = vaddq_f32(y, p4f_cephes_exp_p3); 67 | y = vmulq_f32(y, x); 68 | y = vaddq_f32(y, p4f_cephes_exp_p4); 69 | y = vmulq_f32(y, x); 70 | y = vaddq_f32(y, p4f_cephes_exp_p5); 71 | 72 | y = vmulq_f32(y, z); 73 | y = vaddq_f32(y, x); 74 | y = vaddq_f32(y, p4f_1); 75 | 76 | /* build 2^n */ 77 | int32x4_t mm; 78 | mm = vcvtq_s32_f32(fx); 79 | mm = vaddq_s32(mm, p4i_0x7f); 80 | mm = vshlq_n_s32(mm, 23); 81 | Packet4f pow2n = vreinterpretq_f32_s32(mm); 82 | 83 | y = vmulq_f32(y, pow2n); 84 | return y; 85 | } 86 | 87 | } // end namespace internal 88 | 89 | } // end namespace Eigen 90 | 91 | #endif // EIGEN_MATH_FUNCTIONS_NEON_H 92 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Core/arch/SSE/TypeCasting.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2015 Benoit Steiner 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_TYPE_CASTING_SSE_H 11 | #define EIGEN_TYPE_CASTING_SSE_H 12 | 13 | namespace Eigen { 14 | 15 | namespace internal { 16 | 17 | template <> 18 | struct type_casting_traits { 19 | enum { 20 | VectorizedCast = 1, 21 | SrcCoeffRatio = 1, 22 | TgtCoeffRatio = 1 23 | }; 24 | }; 25 | 26 | template<> EIGEN_STRONG_INLINE Packet4i pcast(const Packet4f& a) { 27 | return _mm_cvttps_epi32(a); 28 | } 29 | 30 | 31 | template <> 32 | struct type_casting_traits { 33 | enum { 34 | VectorizedCast = 1, 35 | SrcCoeffRatio = 1, 36 | TgtCoeffRatio = 1 37 | }; 38 | }; 39 | 40 | template<> EIGEN_STRONG_INLINE Packet4f pcast(const Packet4i& a) { 41 | return _mm_cvtepi32_ps(a); 42 | } 43 | 44 | 45 | template <> 46 | struct type_casting_traits { 47 | enum { 48 | VectorizedCast = 1, 49 | SrcCoeffRatio = 2, 50 | TgtCoeffRatio = 1 51 | }; 52 | }; 53 | 54 | template<> EIGEN_STRONG_INLINE Packet4f pcast(const Packet2d& a, const Packet2d& b) { 55 | return _mm_shuffle_ps(_mm_cvtpd_ps(a), _mm_cvtpd_ps(b), (1 << 2) | (1 << 6)); 56 | } 57 | 58 | template <> 59 | struct type_casting_traits { 60 | enum { 61 | VectorizedCast = 1, 62 | SrcCoeffRatio = 1, 63 | TgtCoeffRatio = 2 64 | }; 65 | }; 66 | 67 | template<> EIGEN_STRONG_INLINE Packet2d pcast(const Packet4f& a) { 68 | // Simply discard the second half of the input 69 | return _mm_cvtps_pd(a); 70 | } 71 | 72 | 73 | } // end namespace internal 74 | 75 | } // end namespace Eigen 76 | 77 | #endif // EIGEN_TYPE_CASTING_SSE_H 78 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Core/arch/ZVector/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_arch_ZVector_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_arch_ZVector_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/ZVector COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Core/functors/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_Functor_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_Functor_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/functors COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Core/functors/TernaryFunctors.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2016 Eugene Brevdo 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_TERNARY_FUNCTORS_H 11 | #define EIGEN_TERNARY_FUNCTORS_H 12 | 13 | namespace Eigen { 14 | 15 | namespace internal { 16 | 17 | //---------- associative ternary functors ---------- 18 | 19 | 20 | 21 | } // end namespace internal 22 | 23 | } // end namespace Eigen 24 | 25 | #endif // EIGEN_TERNARY_FUNCTORS_H 26 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | // 4503 - decorated name length exceeded, name was truncated 14 | // 4512 - assignment operator could not be generated 15 | // 4522 - 'class' : multiple assignment operators specified 16 | // 4700 - uninitialized local variable 'xyz' used 17 | // 4717 - 'function' : recursive on all control paths, function will cause runtime stack overflow 18 | // 4800 - 'type' : forcing value to bool 'true' or 'false' (performance warning) 19 | #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS 20 | #pragma warning( push ) 21 | #endif 22 | #pragma warning( disable : 4100 4101 4127 4181 4211 4244 4273 4324 4503 4512 4522 4700 4717 4800) 23 | 24 | #elif defined __INTEL_COMPILER 25 | // 2196 - routine is both "inline" and "noinline" ("noinline" assumed) 26 | // ICC 12 generates this warning even without any inline keyword, when defining class methods 'inline' i.e. inside of class body 27 | // typedef that may be a reference type. 28 | // 279 - controlling expression is constant 29 | // ICC 12 generates this warning on assert(constant_expression_depending_on_template_params) and frankly this is a legitimate use case. 30 | // 1684 - conversion from pointer to same-sized integral type (potential portability problem) 31 | // 2259 - non-pointer conversion from "Eigen::Index={ptrdiff_t={long}}" to "int" may lose significant bits 32 | #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS 33 | #pragma warning push 34 | #endif 35 | #pragma warning disable 2196 279 1684 2259 36 | 37 | #elif defined __clang__ 38 | // -Wconstant-logical-operand - warning: use of logical && with constant operand; switch to bitwise & or remove constant 39 | // this is really a stupid warning as it warns on compile-time expressions involving enums 40 | #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS 41 | #pragma clang diagnostic push 42 | #endif 43 | #pragma clang diagnostic ignored "-Wconstant-logical-operand" 44 | 45 | #elif defined __GNUC__ && __GNUC__>=6 46 | 47 | #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS 48 | #pragma GCC diagnostic push 49 | #endif 50 | #pragma GCC diagnostic ignored "-Wignored-attributes" 51 | 52 | #endif 53 | 54 | #if defined __NVCC__ 55 | // Disable the "statement is unreachable" message 56 | #pragma diag_suppress code_is_unreachable 57 | // Disable the "dynamic initialization in unreachable code" message 58 | #pragma diag_suppress initialization_not_reachable 59 | // Disable the "calling a __host__ function from a __host__ __device__ function is not allowed" messages (yes, there are 4 of them) 60 | #pragma diag_suppress 2651 61 | #pragma diag_suppress 2653 62 | #pragma diag_suppress 2668 63 | #pragma diag_suppress 2669 64 | #pragma diag_suppress 2670 65 | #pragma diag_suppress 2671 66 | #endif 67 | 68 | #endif // not EIGEN_WARNINGS_DISABLED 69 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Core/util/ReenableStupidWarnings.h: -------------------------------------------------------------------------------- 1 | #ifdef EIGEN_WARNINGS_DISABLED 2 | #undef EIGEN_WARNINGS_DISABLED 3 | 4 | #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS 5 | #ifdef _MSC_VER 6 | #pragma warning( pop ) 7 | #elif defined __INTEL_COMPILER 8 | #pragma warning pop 9 | #elif defined __clang__ 10 | #pragma clang diagnostic pop 11 | #elif defined __GNUC__ && __GNUC__>=6 12 | #pragma GCC diagnostic pop 13 | #endif 14 | 15 | #if defined __NVCC__ 16 | // Don't reenable the diagnostic messages, as it turns out these messages need 17 | // to be disabled at the point of the template instantiation (i.e the user code) 18 | // otherwise they'll be triggeredby nvcc. 19 | // #pragma diag_default code_is_unreachable 20 | // #pragma diag_default initialization_not_reachable 21 | // #pragma diag_default 2651 22 | // #pragma diag_default 2653 23 | #endif 24 | 25 | #endif 26 | 27 | #endif // EIGEN_WARNINGS_DISABLED 28 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2011, Intel Corporation. All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without modification, 5 | are permitted provided that the following conditions are met: 6 | 7 | * Redistributions of source code must retain the above copyright notice, this 8 | list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above copyright notice, 10 | this list of conditions and the following disclaimer in the documentation 11 | and/or other materials provided with the distribution. 12 | * Neither the name of Intel Corporation nor the names of its contributors may 13 | be used to endorse or promote products derived from this software without 14 | specific prior written permission. 15 | 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 20 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 23 | ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 | 27 | ******************************************************************************** 28 | * Content : Eigen bindings to LAPACKe 29 | * Real Schur needed to real unsymmetrical eigenvalues/eigenvectors. 30 | ******************************************************************************** 31 | */ 32 | 33 | #ifndef EIGEN_REAL_SCHUR_LAPACKE_H 34 | #define EIGEN_REAL_SCHUR_LAPACKE_H 35 | 36 | namespace Eigen { 37 | 38 | /** \internal Specialization for the data types supported by LAPACKe */ 39 | 40 | #define EIGEN_LAPACKE_SCHUR_REAL(EIGTYPE, LAPACKE_TYPE, LAPACKE_PREFIX, LAPACKE_PREFIX_U, EIGCOLROW, LAPACKE_COLROW) \ 41 | template<> template inline \ 42 | RealSchur >& \ 43 | RealSchur >::compute(const EigenBase& matrix, bool computeU) \ 44 | { \ 45 | eigen_assert(matrix.cols() == matrix.rows()); \ 46 | \ 47 | lapack_int n = internal::convert_index(matrix.cols()), sdim, info; \ 48 | lapack_int matrix_order = LAPACKE_COLROW; \ 49 | char jobvs, sort='N'; \ 50 | LAPACK_##LAPACKE_PREFIX_U##_SELECT2 select = 0; \ 51 | jobvs = (computeU) ? 'V' : 'N'; \ 52 | m_matU.resize(n, n); \ 53 | lapack_int ldvs = internal::convert_index(m_matU.outerStride()); \ 54 | m_matT = matrix; \ 55 | lapack_int lda = internal::convert_index(m_matT.outerStride()); \ 56 | Matrix wr, wi; \ 57 | wr.resize(n, 1); wi.resize(n, 1); \ 58 | info = LAPACKE_##LAPACKE_PREFIX##gees( matrix_order, jobvs, sort, select, n, (LAPACKE_TYPE*)m_matT.data(), lda, &sdim, (LAPACKE_TYPE*)wr.data(), (LAPACKE_TYPE*)wi.data(), (LAPACKE_TYPE*)m_matU.data(), ldvs ); \ 59 | if(info == 0) \ 60 | m_info = Success; \ 61 | else \ 62 | m_info = NoConvergence; \ 63 | \ 64 | m_isInitialized = true; \ 65 | m_matUisUptodate = computeU; \ 66 | return *this; \ 67 | \ 68 | } 69 | 70 | EIGEN_LAPACKE_SCHUR_REAL(double, double, d, D, ColMajor, LAPACK_COL_MAJOR) 71 | EIGEN_LAPACKE_SCHUR_REAL(float, float, s, S, ColMajor, LAPACK_COL_MAJOR) 72 | EIGEN_LAPACKE_SCHUR_REAL(double, double, d, D, RowMajor, LAPACK_ROW_MAJOR) 73 | EIGEN_LAPACKE_SCHUR_REAL(float, float, s, S, RowMajor, LAPACK_ROW_MAJOR) 74 | 75 | } // end namespace Eigen 76 | 77 | #endif // EIGEN_REAL_SCHUR_LAPACKE_H 78 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/Geometry/EulerAngles.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_EULERANGLES_H 11 | #define EIGEN_EULERANGLES_H 12 | 13 | namespace Eigen { 14 | 15 | /** \geometry_module \ingroup Geometry_Module 16 | * 17 | * 18 | * \returns the Euler-angles of the rotation matrix \c *this using the convention defined by the triplet (\a a0,\a a1,\a a2) 19 | * 20 | * Each of the three parameters \a a0,\a a1,\a a2 represents the respective rotation axis as an integer in {0,1,2}. 21 | * For instance, in: 22 | * \code Vector3f ea = mat.eulerAngles(2, 0, 2); \endcode 23 | * "2" represents the z axis and "0" the x axis, etc. The returned angles are such that 24 | * we have the following equality: 25 | * \code 26 | * mat == AngleAxisf(ea[0], Vector3f::UnitZ()) 27 | * * AngleAxisf(ea[1], Vector3f::UnitX()) 28 | * * AngleAxisf(ea[2], Vector3f::UnitZ()); \endcode 29 | * This corresponds to the right-multiply conventions (with right hand side frames). 30 | * 31 | * The returned angles are in the ranges [0:pi]x[-pi:pi]x[-pi:pi]. 32 | * 33 | * \sa class AngleAxis 34 | */ 35 | template 36 | inline Matrix::Scalar,3,1> 37 | MatrixBase::eulerAngles(Index a0, Index a1, Index a2) const 38 | { 39 | using std::atan2; 40 | using std::sin; 41 | using std::cos; 42 | /* Implemented from Graphics Gems IV */ 43 | EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(Derived,3,3) 44 | 45 | Matrix res; 46 | typedef Matrix Vector2; 47 | 48 | const Index odd = ((a0+1)%3 == a1) ? 0 : 1; 49 | const Index i = a0; 50 | const Index j = (a0 + 1 + odd)%3; 51 | const Index k = (a0 + 2 - odd)%3; 52 | 53 | if (a0==a2) 54 | { 55 | res[0] = atan2(coeff(j,i), coeff(k,i)); 56 | if((odd && res[0]Scalar(0))) 57 | { 58 | res[0] = (res[0] > Scalar(0)) ? res[0] - Scalar(EIGEN_PI) : res[0] + Scalar(EIGEN_PI); 59 | Scalar s2 = Vector2(coeff(j,i), coeff(k,i)).norm(); 60 | res[1] = -atan2(s2, coeff(i,i)); 61 | } 62 | else 63 | { 64 | Scalar s2 = Vector2(coeff(j,i), coeff(k,i)).norm(); 65 | res[1] = atan2(s2, coeff(i,i)); 66 | } 67 | 68 | // With a=(0,1,0), we have i=0; j=1; k=2, and after computing the first two angles, 69 | // we can compute their respective rotation, and apply its inverse to M. Since the result must 70 | // be a rotation around x, we have: 71 | // 72 | // c2 s1.s2 c1.s2 1 0 0 73 | // 0 c1 -s1 * M = 0 c3 s3 74 | // -s2 s1.c2 c1.c2 0 -s3 c3 75 | // 76 | // Thus: m11.c1 - m21.s1 = c3 & m12.c1 - m22.s1 = s3 77 | 78 | Scalar s1 = sin(res[0]); 79 | Scalar c1 = cos(res[0]); 80 | res[2] = atan2(c1*coeff(j,k)-s1*coeff(k,k), c1*coeff(j,j) - s1 * coeff(k,j)); 81 | } 82 | else 83 | { 84 | res[0] = atan2(coeff(j,k), coeff(k,k)); 85 | Scalar c2 = Vector2(coeff(i,i), coeff(i,j)).norm(); 86 | if((odd && res[0]Scalar(0))) { 87 | res[0] = (res[0] > Scalar(0)) ? res[0] - Scalar(EIGEN_PI) : res[0] + Scalar(EIGEN_PI); 88 | res[1] = atan2(-coeff(i,k), -c2); 89 | } 90 | else 91 | res[1] = atan2(-coeff(i,k), c2); 92 | Scalar s1 = sin(res[0]); 93 | Scalar c1 = cos(res[0]); 94 | res[2] = atan2(s1*coeff(k,i)-c1*coeff(j,i), c1*coeff(j,j) - s1 * coeff(k,j)); 95 | } 96 | if (!odd) 97 | res = -res; 98 | 99 | return res; 100 | } 101 | 102 | } // end namespace Eigen 103 | 104 | #endif // EIGEN_EULERANGLES_H 105 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/LU/Determinant.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_DETERMINANT_H 11 | #define EIGEN_DETERMINANT_H 12 | 13 | namespace Eigen { 14 | 15 | namespace internal { 16 | 17 | template 18 | inline const typename Derived::Scalar bruteforce_det3_helper 19 | (const MatrixBase& matrix, int a, int b, int c) 20 | { 21 | return matrix.coeff(0,a) 22 | * (matrix.coeff(1,b) * matrix.coeff(2,c) - matrix.coeff(1,c) * matrix.coeff(2,b)); 23 | } 24 | 25 | template 26 | const typename Derived::Scalar bruteforce_det4_helper 27 | (const MatrixBase& matrix, int j, int k, int m, int n) 28 | { 29 | return (matrix.coeff(j,0) * matrix.coeff(k,1) - matrix.coeff(k,0) * matrix.coeff(j,1)) 30 | * (matrix.coeff(m,2) * matrix.coeff(n,3) - matrix.coeff(n,2) * matrix.coeff(m,3)); 31 | } 32 | 33 | template struct determinant_impl 36 | { 37 | static inline typename traits::Scalar run(const Derived& m) 38 | { 39 | if(Derived::ColsAtCompileTime==Dynamic && m.rows()==0) 40 | return typename traits::Scalar(1); 41 | return m.partialPivLu().determinant(); 42 | } 43 | }; 44 | 45 | template struct determinant_impl 46 | { 47 | static inline typename traits::Scalar run(const Derived& m) 48 | { 49 | return m.coeff(0,0); 50 | } 51 | }; 52 | 53 | template struct determinant_impl 54 | { 55 | static inline typename traits::Scalar run(const Derived& m) 56 | { 57 | return m.coeff(0,0) * m.coeff(1,1) - m.coeff(1,0) * m.coeff(0,1); 58 | } 59 | }; 60 | 61 | template struct determinant_impl 62 | { 63 | static inline typename traits::Scalar run(const Derived& m) 64 | { 65 | return bruteforce_det3_helper(m,0,1,2) 66 | - bruteforce_det3_helper(m,1,0,2) 67 | + bruteforce_det3_helper(m,2,0,1); 68 | } 69 | }; 70 | 71 | template struct determinant_impl 72 | { 73 | static typename traits::Scalar run(const Derived& m) 74 | { 75 | // trick by Martin Costabel to compute 4x4 det with only 30 muls 76 | return bruteforce_det4_helper(m,0,1,2,3) 77 | - bruteforce_det4_helper(m,0,2,1,3) 78 | + bruteforce_det4_helper(m,0,3,1,2) 79 | + bruteforce_det4_helper(m,1,2,0,3) 80 | - bruteforce_det4_helper(m,1,3,0,2) 81 | + bruteforce_det4_helper(m,2,3,0,1); 82 | } 83 | }; 84 | 85 | } // end namespace internal 86 | 87 | /** \lu_module 88 | * 89 | * \returns the determinant of this matrix 90 | */ 91 | template 92 | inline typename internal::traits::Scalar MatrixBase::determinant() const 93 | { 94 | eigen_assert(rows() == cols()); 95 | typedef typename internal::nested_eval::type Nested; 96 | return internal::determinant_impl::type>::run(derived()); 97 | } 98 | 99 | } // end namespace Eigen 100 | 101 | #endif // EIGEN_DETERMINANT_H 102 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/LU/PartialPivLU_LAPACKE.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2011, Intel Corporation. All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without modification, 5 | are permitted provided that the following conditions are met: 6 | 7 | * Redistributions of source code must retain the above copyright notice, this 8 | list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above copyright notice, 10 | this list of conditions and the following disclaimer in the documentation 11 | and/or other materials provided with the distribution. 12 | * Neither the name of Intel Corporation nor the names of its contributors may 13 | be used to endorse or promote products derived from this software without 14 | specific prior written permission. 15 | 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 20 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 23 | ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 | 27 | ******************************************************************************** 28 | * Content : Eigen bindings to LAPACKe 29 | * LU decomposition with partial pivoting based on LAPACKE_?getrf function. 30 | ******************************************************************************** 31 | */ 32 | 33 | #ifndef EIGEN_PARTIALLU_LAPACK_H 34 | #define EIGEN_PARTIALLU_LAPACK_H 35 | 36 | namespace Eigen { 37 | 38 | namespace internal { 39 | 40 | /** \internal Specialization for the data types supported by LAPACKe */ 41 | 42 | #define EIGEN_LAPACKE_LU_PARTPIV(EIGTYPE, LAPACKE_TYPE, LAPACKE_PREFIX) \ 43 | template \ 44 | struct partial_lu_impl \ 45 | { \ 46 | /* \internal performs the LU decomposition in-place of the matrix represented */ \ 47 | static lapack_int blocked_lu(Index rows, Index cols, EIGTYPE* lu_data, Index luStride, lapack_int* row_transpositions, lapack_int& nb_transpositions, lapack_int maxBlockSize=256) \ 48 | { \ 49 | EIGEN_UNUSED_VARIABLE(maxBlockSize);\ 50 | lapack_int matrix_order, first_zero_pivot; \ 51 | lapack_int m, n, lda, *ipiv, info; \ 52 | EIGTYPE* a; \ 53 | /* Set up parameters for ?getrf */ \ 54 | matrix_order = StorageOrder==RowMajor ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; \ 55 | lda = convert_index(luStride); \ 56 | a = lu_data; \ 57 | ipiv = row_transpositions; \ 58 | m = convert_index(rows); \ 59 | n = convert_index(cols); \ 60 | nb_transpositions = 0; \ 61 | \ 62 | info = LAPACKE_##LAPACKE_PREFIX##getrf( matrix_order, m, n, (LAPACKE_TYPE*)a, lda, ipiv ); \ 63 | \ 64 | for(int i=0;i= 0); \ 67 | /* something should be done with nb_transpositions */ \ 68 | \ 69 | first_zero_pivot = info; \ 70 | return first_zero_pivot; \ 71 | } \ 72 | }; 73 | 74 | EIGEN_LAPACKE_LU_PARTPIV(double, double, d) 75 | EIGEN_LAPACKE_LU_PARTPIV(float, float, s) 76 | EIGEN_LAPACKE_LU_PARTPIV(dcomplex, lapack_complex_double, z) 77 | EIGEN_LAPACKE_LU_PARTPIV(scomplex, lapack_complex_float, c) 78 | 79 | } // end namespace internal 80 | 81 | } // end namespace Eigen 82 | 83 | #endif // EIGEN_PARTIALLU_LAPACK_H 84 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/QR/HouseholderQR_LAPACKE.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2011, Intel Corporation. All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without modification, 5 | are permitted provided that the following conditions are met: 6 | 7 | * Redistributions of source code must retain the above copyright notice, this 8 | list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above copyright notice, 10 | this list of conditions and the following disclaimer in the documentation 11 | and/or other materials provided with the distribution. 12 | * Neither the name of Intel Corporation nor the names of its contributors may 13 | be used to endorse or promote products derived from this software without 14 | specific prior written permission. 15 | 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 20 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 23 | ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 | 27 | ******************************************************************************** 28 | * Content : Eigen bindings to LAPACKe 29 | * Householder QR decomposition of a matrix w/o pivoting based on 30 | * LAPACKE_?geqrf function. 31 | ******************************************************************************** 32 | */ 33 | 34 | #ifndef EIGEN_QR_LAPACKE_H 35 | #define EIGEN_QR_LAPACKE_H 36 | 37 | namespace Eigen { 38 | 39 | namespace internal { 40 | 41 | /** \internal Specialization for the data types supported by LAPACKe */ 42 | 43 | #define EIGEN_LAPACKE_QR_NOPIV(EIGTYPE, LAPACKE_TYPE, LAPACKE_PREFIX) \ 44 | template \ 45 | struct householder_qr_inplace_blocked \ 46 | { \ 47 | static void run(MatrixQR& mat, HCoeffs& hCoeffs, Index = 32, \ 48 | typename MatrixQR::Scalar* = 0) \ 49 | { \ 50 | lapack_int m = (lapack_int) mat.rows(); \ 51 | lapack_int n = (lapack_int) mat.cols(); \ 52 | lapack_int lda = (lapack_int) mat.outerStride(); \ 53 | lapack_int matrix_order = (MatrixQR::IsRowMajor) ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; \ 54 | LAPACKE_##LAPACKE_PREFIX##geqrf( matrix_order, m, n, (LAPACKE_TYPE*)mat.data(), lda, (LAPACKE_TYPE*)hCoeffs.data()); \ 55 | hCoeffs.adjointInPlace(); \ 56 | } \ 57 | }; 58 | 59 | EIGEN_LAPACKE_QR_NOPIV(double, double, d) 60 | EIGEN_LAPACKE_QR_NOPIV(float, float, s) 61 | EIGEN_LAPACKE_QR_NOPIV(dcomplex, lapack_complex_double, z) 62 | EIGEN_LAPACKE_QR_NOPIV(scomplex, lapack_complex_float, c) 63 | 64 | } // end namespace internal 65 | 66 | } // end namespace Eigen 67 | 68 | #endif // EIGEN_QR_LAPACKE_H 69 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/SparseCore/MappedSparseMatrix.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008-2014 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_MAPPED_SPARSEMATRIX_H 11 | #define EIGEN_MAPPED_SPARSEMATRIX_H 12 | 13 | namespace Eigen { 14 | 15 | /** \deprecated Use Map > 16 | * \class MappedSparseMatrix 17 | * 18 | * \brief Sparse matrix 19 | * 20 | * \param _Scalar the scalar type, i.e. the type of the coefficients 21 | * 22 | * See http://www.netlib.org/linalg/html_templates/node91.html for details on the storage scheme. 23 | * 24 | */ 25 | namespace internal { 26 | template 27 | struct traits > : traits > 28 | {}; 29 | } // end namespace internal 30 | 31 | template 32 | class MappedSparseMatrix 33 | : public Map > 34 | { 35 | typedef Map > Base; 36 | 37 | public: 38 | 39 | typedef typename Base::StorageIndex StorageIndex; 40 | typedef typename Base::Scalar Scalar; 41 | 42 | inline MappedSparseMatrix(Index rows, Index cols, Index nnz, StorageIndex* outerIndexPtr, StorageIndex* innerIndexPtr, Scalar* valuePtr, StorageIndex* innerNonZeroPtr = 0) 43 | : Base(rows, cols, nnz, outerIndexPtr, innerIndexPtr, valuePtr, innerNonZeroPtr) 44 | {} 45 | 46 | /** Empty destructor */ 47 | inline ~MappedSparseMatrix() {} 48 | }; 49 | 50 | namespace internal { 51 | 52 | template 53 | struct evaluator > 54 | : evaluator > > 55 | { 56 | typedef MappedSparseMatrix<_Scalar,_Options,_StorageIndex> XprType; 57 | typedef evaluator > Base; 58 | 59 | evaluator() : Base() {} 60 | explicit evaluator(const XprType &mat) : Base(mat) {} 61 | }; 62 | 63 | } 64 | 65 | } // end namespace Eigen 66 | 67 | #endif // EIGEN_MAPPED_SPARSEMATRIX_H 68 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/SparseCore/SparseDot.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_DOT_H 11 | #define EIGEN_SPARSE_DOT_H 12 | 13 | namespace Eigen { 14 | 15 | template 16 | template 17 | typename internal::traits::Scalar 18 | SparseMatrixBase::dot(const MatrixBase& other) const 19 | { 20 | EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 21 | EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived) 22 | EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived) 23 | EIGEN_STATIC_ASSERT((internal::is_same::value), 24 | YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) 25 | 26 | eigen_assert(size() == other.size()); 27 | eigen_assert(other.size()>0 && "you are using a non initialized vector"); 28 | 29 | internal::evaluator thisEval(derived()); 30 | typename internal::evaluator::InnerIterator i(thisEval, 0); 31 | Scalar res(0); 32 | while (i) 33 | { 34 | res += numext::conj(i.value()) * other.coeff(i.index()); 35 | ++i; 36 | } 37 | return res; 38 | } 39 | 40 | template 41 | template 42 | typename internal::traits::Scalar 43 | SparseMatrixBase::dot(const SparseMatrixBase& other) const 44 | { 45 | EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 46 | EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived) 47 | EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived) 48 | EIGEN_STATIC_ASSERT((internal::is_same::value), 49 | YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) 50 | 51 | eigen_assert(size() == other.size()); 52 | 53 | internal::evaluator thisEval(derived()); 54 | typename internal::evaluator::InnerIterator i(thisEval, 0); 55 | 56 | internal::evaluator otherEval(other.derived()); 57 | typename internal::evaluator::InnerIterator j(otherEval, 0); 58 | 59 | Scalar res(0); 60 | while (i && j) 61 | { 62 | if (i.index()==j.index()) 63 | { 64 | res += numext::conj(i.value()) * j.value(); 65 | ++i; ++j; 66 | } 67 | else if (i.index() 76 | inline typename NumTraits::Scalar>::Real 77 | SparseMatrixBase::squaredNorm() const 78 | { 79 | return numext::real((*this).cwiseAbs2().sum()); 80 | } 81 | 82 | template 83 | inline typename NumTraits::Scalar>::Real 84 | SparseMatrixBase::norm() const 85 | { 86 | using std::sqrt; 87 | return sqrt(squaredNorm()); 88 | } 89 | 90 | template 91 | inline typename NumTraits::Scalar>::Real 92 | SparseMatrixBase::blueNorm() const 93 | { 94 | return internal::blueNorm_impl(*this); 95 | } 96 | } // end namespace Eigen 97 | 98 | #endif // EIGEN_SPARSE_DOT_H 99 | -------------------------------------------------------------------------------- /DevelopApp/Include/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-2014 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 | namespace Eigen { 14 | 15 | template 16 | template 17 | bool SparseMatrixBase::isApprox(const SparseMatrixBase& other, const RealScalar &prec) const 18 | { 19 | const typename internal::nested_eval::type actualA(derived()); 20 | typename internal::conditional::type, 22 | const PlainObject>::type actualB(other.derived()); 23 | 24 | return (actualA - actualB).squaredNorm() <= prec * prec * numext::mini(actualA.squaredNorm(), actualB.squaredNorm()); 25 | } 26 | 27 | } // end namespace Eigen 28 | 29 | #endif // EIGEN_SPARSE_FUZZY_H 30 | -------------------------------------------------------------------------------- /DevelopApp/Include/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-2014 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 | internal::evaluator thisEval(derived()); 22 | for (Index j=0; j::InnerIterator iter(thisEval,j); iter; ++iter) 24 | res += iter.value(); 25 | return res; 26 | } 27 | 28 | template 29 | typename internal::traits >::Scalar 30 | SparseMatrix<_Scalar,_Options,_Index>::sum() const 31 | { 32 | eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix"); 33 | if(this->isCompressed()) 34 | return Matrix::Map(m_data.valuePtr(), m_data.size()).sum(); 35 | else 36 | return Base::sum(); 37 | } 38 | 39 | template 40 | typename internal::traits >::Scalar 41 | SparseVector<_Scalar,_Options,_Index>::sum() const 42 | { 43 | eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix"); 44 | return Matrix::Map(m_data.valuePtr(), m_data.size()).sum(); 45 | } 46 | 47 | } // end namespace Eigen 48 | 49 | #endif // EIGEN_SPARSEREDUX_H 50 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | StorageIndex 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 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/SparseLU/SparseLU_relax_snode.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 | /* This file is a modified version of heap_relax_snode.c file in SuperLU 11 | * -- SuperLU routine (version 3.0) -- 12 | * Univ. of California Berkeley, Xerox Palo Alto Research Center, 13 | * and Lawrence Berkeley National Lab. 14 | * October 15, 2003 15 | * 16 | * Copyright (c) 1994 by Xerox Corporation. All rights reserved. 17 | * 18 | * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY 19 | * EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. 20 | * 21 | * Permission is hereby granted to use or copy this program for any 22 | * purpose, provided the above notices are retained on all copies. 23 | * Permission to modify the code and to distribute modified code is 24 | * granted, provided the above notices are retained, and a notice that 25 | * the code was modified is included with the above copyright notice. 26 | */ 27 | 28 | #ifndef SPARSELU_RELAX_SNODE_H 29 | #define SPARSELU_RELAX_SNODE_H 30 | 31 | namespace Eigen { 32 | 33 | namespace internal { 34 | 35 | /** 36 | * \brief Identify the initial relaxed supernodes 37 | * 38 | * This routine is applied to a column elimination tree. 39 | * It assumes that the matrix has been reordered according to the postorder of the etree 40 | * \param n the number of columns 41 | * \param et elimination tree 42 | * \param relax_columns Maximum number of columns allowed in a relaxed snode 43 | * \param descendants Number of descendants of each node in the etree 44 | * \param relax_end last column in a supernode 45 | */ 46 | template 47 | void SparseLUImpl::relax_snode (const Index n, IndexVector& et, const Index relax_columns, IndexVector& descendants, IndexVector& relax_end) 48 | { 49 | 50 | // compute the number of descendants of each node in the etree 51 | Index parent; 52 | relax_end.setConstant(emptyIdxLU); 53 | descendants.setZero(); 54 | for (Index j = 0; j < n; j++) 55 | { 56 | parent = et(j); 57 | if (parent != n) // not the dummy root 58 | descendants(parent) += descendants(j) + 1; 59 | } 60 | // Identify the relaxed supernodes by postorder traversal of the etree 61 | Index snode_start; // beginning of a snode 62 | for (Index j = 0; j < n; ) 63 | { 64 | parent = et(j); 65 | snode_start = j; 66 | while ( parent != n && descendants(parent) < relax_columns ) 67 | { 68 | j = parent; 69 | parent = et(j); 70 | } 71 | // Found a supernode in postordered etree, j is the last column 72 | relax_end(snode_start) = StorageIndex(j); // Record last column 73 | j++; 74 | // Search for a new leaf 75 | while (descendants(j) != 0 && j < n) j++; 76 | } // End postorder traversal of the etree 77 | 78 | } 79 | 80 | } // end namespace internal 81 | 82 | } // end namespace Eigen 83 | #endif 84 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/StlSupport/details.h: -------------------------------------------------------------------------------- 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_STL_DETAILS_H 12 | #define EIGEN_STL_DETAILS_H 13 | 14 | #ifndef EIGEN_ALIGNED_ALLOCATOR 15 | #define EIGEN_ALIGNED_ALLOCATOR Eigen::aligned_allocator 16 | #endif 17 | 18 | namespace Eigen { 19 | 20 | // This one is needed to prevent reimplementing the whole std::vector. 21 | template 22 | class aligned_allocator_indirection : public EIGEN_ALIGNED_ALLOCATOR 23 | { 24 | public: 25 | typedef size_t size_type; 26 | typedef ptrdiff_t difference_type; 27 | typedef T* pointer; 28 | typedef const T* const_pointer; 29 | typedef T& reference; 30 | typedef const T& const_reference; 31 | typedef T value_type; 32 | 33 | template 34 | struct rebind 35 | { 36 | typedef aligned_allocator_indirection other; 37 | }; 38 | 39 | aligned_allocator_indirection() {} 40 | aligned_allocator_indirection(const aligned_allocator_indirection& ) : EIGEN_ALIGNED_ALLOCATOR() {} 41 | aligned_allocator_indirection(const EIGEN_ALIGNED_ALLOCATOR& ) {} 42 | template 43 | aligned_allocator_indirection(const aligned_allocator_indirection& ) {} 44 | template 45 | aligned_allocator_indirection(const EIGEN_ALIGNED_ALLOCATOR& ) {} 46 | ~aligned_allocator_indirection() {} 47 | }; 48 | 49 | #if EIGEN_COMP_MSVC 50 | 51 | // sometimes, MSVC detects, at compile time, that the argument x 52 | // in std::vector::resize(size_t s,T x) won't be aligned and generate an error 53 | // even if this function is never called. Whence this little wrapper. 54 | #define EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T) \ 55 | typename Eigen::internal::conditional< \ 56 | Eigen::internal::is_arithmetic::value, \ 57 | T, \ 58 | Eigen::internal::workaround_msvc_stl_support \ 59 | >::type 60 | 61 | namespace internal { 62 | template struct workaround_msvc_stl_support : public T 63 | { 64 | inline workaround_msvc_stl_support() : T() {} 65 | inline workaround_msvc_stl_support(const T& other) : T(other) {} 66 | inline operator T& () { return *static_cast(this); } 67 | inline operator const T& () const { return *static_cast(this); } 68 | template 69 | inline T& operator=(const OtherT& other) 70 | { T::operator=(other); return *this; } 71 | inline workaround_msvc_stl_support& operator=(const workaround_msvc_stl_support& other) 72 | { T::operator=(other); return *this; } 73 | }; 74 | } 75 | 76 | #else 77 | 78 | #define EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T) T 79 | 80 | #endif 81 | 82 | } 83 | 84 | #endif // EIGEN_STL_DETAILS_H 85 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/misc/Image.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009 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_MISC_IMAGE_H 11 | #define EIGEN_MISC_IMAGE_H 12 | 13 | namespace Eigen { 14 | 15 | namespace internal { 16 | 17 | /** \class image_retval_base 18 | * 19 | */ 20 | template 21 | struct traits > 22 | { 23 | typedef typename DecompositionType::MatrixType MatrixType; 24 | typedef Matrix< 25 | typename MatrixType::Scalar, 26 | MatrixType::RowsAtCompileTime, // the image is a subspace of the destination space, whose 27 | // dimension is the number of rows of the original matrix 28 | Dynamic, // we don't know at compile time the dimension of the image (the rank) 29 | MatrixType::Options, 30 | MatrixType::MaxRowsAtCompileTime, // the image matrix will consist of columns from the original matrix, 31 | MatrixType::MaxColsAtCompileTime // so it has the same number of rows and at most as many columns. 32 | > ReturnType; 33 | }; 34 | 35 | template struct image_retval_base 36 | : public ReturnByValue > 37 | { 38 | typedef _DecompositionType DecompositionType; 39 | typedef typename DecompositionType::MatrixType MatrixType; 40 | typedef ReturnByValue Base; 41 | 42 | image_retval_base(const DecompositionType& dec, const MatrixType& originalMatrix) 43 | : m_dec(dec), m_rank(dec.rank()), 44 | m_cols(m_rank == 0 ? 1 : m_rank), 45 | m_originalMatrix(originalMatrix) 46 | {} 47 | 48 | inline Index rows() const { return m_dec.rows(); } 49 | inline Index cols() const { return m_cols; } 50 | inline Index rank() const { return m_rank; } 51 | inline const DecompositionType& dec() const { return m_dec; } 52 | inline const MatrixType& originalMatrix() const { return m_originalMatrix; } 53 | 54 | template inline void evalTo(Dest& dst) const 55 | { 56 | static_cast*>(this)->evalTo(dst); 57 | } 58 | 59 | protected: 60 | const DecompositionType& m_dec; 61 | Index m_rank, m_cols; 62 | const MatrixType& m_originalMatrix; 63 | }; 64 | 65 | } // end namespace internal 66 | 67 | #define EIGEN_MAKE_IMAGE_HELPERS(DecompositionType) \ 68 | typedef typename DecompositionType::MatrixType MatrixType; \ 69 | typedef typename MatrixType::Scalar Scalar; \ 70 | typedef typename MatrixType::RealScalar RealScalar; \ 71 | typedef Eigen::internal::image_retval_base Base; \ 72 | using Base::dec; \ 73 | using Base::originalMatrix; \ 74 | using Base::rank; \ 75 | using Base::rows; \ 76 | using Base::cols; \ 77 | image_retval(const DecompositionType& dec, const MatrixType& originalMatrix) \ 78 | : Base(dec, originalMatrix) {} 79 | 80 | } // end namespace Eigen 81 | 82 | #endif // EIGEN_MISC_IMAGE_H 83 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/misc/Kernel.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009 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_MISC_KERNEL_H 11 | #define EIGEN_MISC_KERNEL_H 12 | 13 | namespace Eigen { 14 | 15 | namespace internal { 16 | 17 | /** \class kernel_retval_base 18 | * 19 | */ 20 | template 21 | struct traits > 22 | { 23 | typedef typename DecompositionType::MatrixType MatrixType; 24 | typedef Matrix< 25 | typename MatrixType::Scalar, 26 | MatrixType::ColsAtCompileTime, // the number of rows in the "kernel matrix" 27 | // is the number of cols of the original matrix 28 | // so that the product "matrix * kernel = zero" makes sense 29 | Dynamic, // we don't know at compile-time the dimension of the kernel 30 | MatrixType::Options, 31 | MatrixType::MaxColsAtCompileTime, // see explanation for 2nd template parameter 32 | MatrixType::MaxColsAtCompileTime // the kernel is a subspace of the domain space, 33 | // whose dimension is the number of columns of the original matrix 34 | > ReturnType; 35 | }; 36 | 37 | template struct kernel_retval_base 38 | : public ReturnByValue > 39 | { 40 | typedef _DecompositionType DecompositionType; 41 | typedef ReturnByValue Base; 42 | 43 | explicit kernel_retval_base(const DecompositionType& dec) 44 | : m_dec(dec), 45 | m_rank(dec.rank()), 46 | m_cols(m_rank==dec.cols() ? 1 : dec.cols() - m_rank) 47 | {} 48 | 49 | inline Index rows() const { return m_dec.cols(); } 50 | inline Index cols() const { return m_cols; } 51 | inline Index rank() const { return m_rank; } 52 | inline const DecompositionType& dec() const { return m_dec; } 53 | 54 | template inline void evalTo(Dest& dst) const 55 | { 56 | static_cast*>(this)->evalTo(dst); 57 | } 58 | 59 | protected: 60 | const DecompositionType& m_dec; 61 | Index m_rank, m_cols; 62 | }; 63 | 64 | } // end namespace internal 65 | 66 | #define EIGEN_MAKE_KERNEL_HELPERS(DecompositionType) \ 67 | typedef typename DecompositionType::MatrixType MatrixType; \ 68 | typedef typename MatrixType::Scalar Scalar; \ 69 | typedef typename MatrixType::RealScalar RealScalar; \ 70 | typedef Eigen::internal::kernel_retval_base Base; \ 71 | using Base::dec; \ 72 | using Base::rank; \ 73 | using Base::rows; \ 74 | using Base::cols; \ 75 | kernel_retval(const DecompositionType& dec) : Base(dec) {} 76 | 77 | } // end namespace Eigen 78 | 79 | #endif // EIGEN_MISC_KERNEL_H 80 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/misc/RealSvd2x2.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009-2010 Benoit Jacob 5 | // Copyright (C) 2013-2016 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_REALSVD2X2_H 12 | #define EIGEN_REALSVD2X2_H 13 | 14 | namespace Eigen { 15 | 16 | namespace internal { 17 | 18 | template 19 | void real_2x2_jacobi_svd(const MatrixType& matrix, Index p, Index q, 20 | JacobiRotation *j_left, 21 | JacobiRotation *j_right) 22 | { 23 | using std::sqrt; 24 | using std::abs; 25 | Matrix m; 26 | m << numext::real(matrix.coeff(p,p)), numext::real(matrix.coeff(p,q)), 27 | numext::real(matrix.coeff(q,p)), numext::real(matrix.coeff(q,q)); 28 | JacobiRotation rot1; 29 | RealScalar t = m.coeff(0,0) + m.coeff(1,1); 30 | RealScalar d = m.coeff(1,0) - m.coeff(0,1); 31 | 32 | if(abs(d) < (std::numeric_limits::min)()) 33 | { 34 | rot1.s() = RealScalar(0); 35 | rot1.c() = RealScalar(1); 36 | } 37 | else 38 | { 39 | // If d!=0, then t/d cannot overflow because the magnitude of the 40 | // entries forming d are not too small compared to the ones forming t. 41 | RealScalar u = t / d; 42 | RealScalar tmp = sqrt(RealScalar(1) + numext::abs2(u)); 43 | rot1.s() = RealScalar(1) / tmp; 44 | rot1.c() = u / tmp; 45 | } 46 | m.applyOnTheLeft(0,1,rot1); 47 | j_right->makeJacobi(m,0,1); 48 | *j_left = rot1 * j_right->transpose(); 49 | } 50 | 51 | } // end namespace internal 52 | 53 | } // end namespace Eigen 54 | 55 | #endif // EIGEN_REALSVD2X2_H 56 | -------------------------------------------------------------------------------- /DevelopApp/Include/Eigen/src/misc/lapacke_mangling.h: -------------------------------------------------------------------------------- 1 | #ifndef LAPACK_HEADER_INCLUDED 2 | #define LAPACK_HEADER_INCLUDED 3 | 4 | #ifndef LAPACK_GLOBAL 5 | #if defined(LAPACK_GLOBAL_PATTERN_LC) || defined(ADD_) 6 | #define LAPACK_GLOBAL(lcname,UCNAME) lcname##_ 7 | #elif defined(LAPACK_GLOBAL_PATTERN_UC) || defined(UPPER) 8 | #define LAPACK_GLOBAL(lcname,UCNAME) UCNAME 9 | #elif defined(LAPACK_GLOBAL_PATTERN_MC) || defined(NOCHANGE) 10 | #define LAPACK_GLOBAL(lcname,UCNAME) lcname 11 | #else 12 | #define LAPACK_GLOBAL(lcname,UCNAME) lcname##_ 13 | #endif 14 | #endif 15 | 16 | #endif 17 | 18 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 | -------------------------------------------------------------------------------- /DevelopApp/Include/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-2016 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-,difference) 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+,sum) 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_DEVICE_FUNC 42 | EIGEN_STRONG_INLINE const CwiseBinaryOp 43 | binaryExpr(const EIGEN_CURRENT_STORAGE_BASE_CLASS &other, const CustomBinaryOp& func = CustomBinaryOp()) const 44 | { 45 | return CwiseBinaryOp(derived(), other.derived(), func); 46 | } 47 | 48 | 49 | #ifndef EIGEN_PARSED_BY_DOXYGEN 50 | EIGEN_MAKE_SCALAR_BINARY_OP(operator*,product) 51 | #else 52 | /** \returns an expression of \c *this scaled by the scalar factor \a scalar 53 | * 54 | * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression. 55 | */ 56 | template 57 | const CwiseBinaryOp,Derived,Constant > operator*(const T& scalar) const; 58 | /** \returns an expression of \a expr scaled by the scalar factor \a scalar 59 | * 60 | * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression. 61 | */ 62 | template friend 63 | const CwiseBinaryOp,Constant,Derived> operator*(const T& scalar, const StorageBaseType& expr); 64 | #endif 65 | 66 | 67 | 68 | #ifndef EIGEN_PARSED_BY_DOXYGEN 69 | EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(operator/,quotient) 70 | #else 71 | /** \returns an expression of \c *this divided by the scalar value \a scalar 72 | * 73 | * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression. 74 | */ 75 | template 76 | const CwiseBinaryOp,Derived,Constant > operator/(const T& scalar) const; 77 | #endif 78 | -------------------------------------------------------------------------------- /DevelopApp/Include/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 included into the body of the base classes supporting matrix specific coefficient-wise functions. 12 | // This include MatrixBase and SparseMatrixBase. 13 | 14 | typedef CwiseUnaryOp, const Derived> CwiseAbsReturnType; 15 | typedef CwiseUnaryOp, const Derived> CwiseAbs2ReturnType; 16 | typedef CwiseUnaryOp, const Derived> CwiseSqrtReturnType; 17 | typedef CwiseUnaryOp, const Derived> CwiseSignReturnType; 18 | typedef CwiseUnaryOp, const Derived> CwiseInverseReturnType; 19 | 20 | /** \returns an expression of the coefficient-wise absolute value of \c *this 21 | * 22 | * Example: \include MatrixBase_cwiseAbs.cpp 23 | * Output: \verbinclude MatrixBase_cwiseAbs.out 24 | * 25 | * \sa cwiseAbs2() 26 | */ 27 | EIGEN_DEVICE_FUNC 28 | EIGEN_STRONG_INLINE const CwiseAbsReturnType 29 | cwiseAbs() const { return CwiseAbsReturnType(derived()); } 30 | 31 | /** \returns an expression of the coefficient-wise squared absolute value of \c *this 32 | * 33 | * Example: \include MatrixBase_cwiseAbs2.cpp 34 | * Output: \verbinclude MatrixBase_cwiseAbs2.out 35 | * 36 | * \sa cwiseAbs() 37 | */ 38 | EIGEN_DEVICE_FUNC 39 | EIGEN_STRONG_INLINE const CwiseAbs2ReturnType 40 | cwiseAbs2() const { return CwiseAbs2ReturnType(derived()); } 41 | 42 | /** \returns an expression of the coefficient-wise square root of *this. 43 | * 44 | * Example: \include MatrixBase_cwiseSqrt.cpp 45 | * Output: \verbinclude MatrixBase_cwiseSqrt.out 46 | * 47 | * \sa cwisePow(), cwiseSquare() 48 | */ 49 | EIGEN_DEVICE_FUNC 50 | inline const CwiseSqrtReturnType 51 | cwiseSqrt() const { return CwiseSqrtReturnType(derived()); } 52 | 53 | /** \returns an expression of the coefficient-wise signum of *this. 54 | * 55 | * Example: \include MatrixBase_cwiseSign.cpp 56 | * Output: \verbinclude MatrixBase_cwiseSign.out 57 | * 58 | */ 59 | EIGEN_DEVICE_FUNC 60 | inline const CwiseSignReturnType 61 | cwiseSign() const { return CwiseSignReturnType(derived()); } 62 | 63 | 64 | /** \returns an expression of the coefficient-wise inverse of *this. 65 | * 66 | * Example: \include MatrixBase_cwiseInverse.cpp 67 | * Output: \verbinclude MatrixBase_cwiseInverse.out 68 | * 69 | * \sa cwiseProduct() 70 | */ 71 | EIGEN_DEVICE_FUNC 72 | inline const CwiseInverseReturnType 73 | cwiseInverse() const { return CwiseInverseReturnType(derived()); } 74 | -------------------------------------------------------------------------------- /DevelopApp/Include/OpenMesh/Core/IO/SR_binary_vector_of_bool.inl: -------------------------------------------------------------------------------- 1 | 2 | template <> struct binary< std::vector > 3 | { 4 | 5 | typedef std::vector< bool > value_type; 6 | typedef value_type::value_type elem_type; 7 | 8 | static const bool is_streamable = true; 9 | 10 | static size_t size_of(void) { return UnknownSize; } 11 | static size_t size_of(const value_type& _v) 12 | { 13 | return _v.size() / 8 + ((_v.size() % 8)!=0); 14 | } 15 | 16 | static 17 | size_t store( std::ostream& _ostr, const value_type& _v, bool ) 18 | { 19 | size_t bytes = 0; 20 | 21 | size_t N = _v.size() / 8; 22 | size_t R = _v.size() % 8; 23 | 24 | size_t idx; // element index 25 | unsigned char bits; // bitset 26 | 27 | for (idx=0; idx < N; ++idx) 28 | { 29 | bits = static_cast(_v[idx]) 30 | | (static_cast(_v[idx+1]) << 1) 31 | | (static_cast(_v[idx+2]) << 2) 32 | | (static_cast(_v[idx+3]) << 3) 33 | | (static_cast(_v[idx+4]) << 4) 34 | | (static_cast(_v[idx+5]) << 5) 35 | | (static_cast(_v[idx+6]) << 6) 36 | | (static_cast(_v[idx+7]) << 7); 37 | _ostr << bits; 38 | } 39 | bytes = N; 40 | 41 | if (R) 42 | { 43 | bits = 0; 44 | switch(R) 45 | { 46 | case 7: bits |= (static_cast(_v[idx+6]) << 6); 47 | case 6: bits |= (static_cast(_v[idx+5]) << 5); 48 | case 5: bits |= (static_cast(_v[idx+4]) << 4); 49 | case 4: bits |= (static_cast(_v[idx+3]) << 3); 50 | case 3: bits |= (static_cast(_v[idx+2]) << 2); 51 | case 2: bits |= (static_cast(_v[idx+1]) << 1); 52 | case 1: bits |= static_cast(_v[idx+0]); 53 | } 54 | _ostr << bits; 55 | ++bytes; 56 | } 57 | 58 | assert( bytes == size_of(_v) ); 59 | 60 | return bytes; 61 | } 62 | 63 | static 64 | size_t restore( std::istream& _istr, value_type& _v, bool ) 65 | { 66 | size_t bytes = 0; 67 | 68 | size_t N = _v.size() / 8; 69 | size_t R = _v.size() % 8; 70 | 71 | size_t idx; // element index 72 | unsigned char bits; // bitset 73 | 74 | for (idx=0; idx < N; ++idx) 75 | { 76 | _istr >> bits; 77 | _v[idx+0] = ((bits & 0x01)!=0); 78 | _v[idx+1] = ((bits & 0x02)!=0); 79 | _v[idx+2] = ((bits & 0x04)!=0); 80 | _v[idx+3] = ((bits & 0x08)!=0); 81 | _v[idx+4] = ((bits & 0x10)!=0); 82 | _v[idx+5] = ((bits & 0x20)!=0); 83 | _v[idx+6] = ((bits & 0x40)!=0); 84 | _v[idx+7] = ((bits & 0x80)!=0); 85 | } 86 | bytes = N; 87 | 88 | if (R) 89 | { 90 | _istr >> bits; 91 | for(; idx < _v.size(); ++idx) 92 | _v[idx] = (bits & (1 << (idx%8)))!=0; 93 | ++bytes; 94 | } 95 | 96 | return bytes; 97 | } 98 | }; 99 | -------------------------------------------------------------------------------- /DevelopApp/Include/OpenMesh/Core/IO/SR_binary_vector_of_fundamentals.inl: -------------------------------------------------------------------------------- 1 | 2 | #define BINARY_VECTOR( T ) \ 3 | template <> struct binary< std::vector< T > > { \ 4 | typedef std::vector< T > value_type; \ 5 | typedef value_type::value_type elem_type; \ 6 | \ 7 | static const bool is_streamable = true; \ 8 | \ 9 | static size_t size_of(void) \ 10 | { return IO::UnknownSize; } \ 11 | \ 12 | static size_t size_of(const value_type& _v) \ 13 | { return sizeof(elem_type)*_v.size(); } \ 14 | \ 15 | static \ 16 | size_t store(std::ostream& _os, const value_type& _v, bool _swap=false) { \ 17 | size_t bytes=0; \ 18 | \ 19 | if (_swap) \ 20 | bytes = std::accumulate( _v.begin(), _v.end(), bytes, \ 21 | FunctorStore(_os,_swap) ); \ 22 | else { \ 23 | bytes = size_of(_v); \ 24 | _os.write( reinterpret_cast(&_v[0]), bytes ); \ 25 | } \ 26 | return _os.good() ? bytes : 0; \ 27 | } \ 28 | \ 29 | static size_t restore(std::istream& _is, value_type& _v, bool _swap=false) { \ 30 | size_t bytes=0; \ 31 | \ 32 | if ( _swap) \ 33 | bytes = std::accumulate( _v.begin(), _v.end(), size_t(0), \ 34 | FunctorRestore(_is, _swap) ); \ 35 | else \ 36 | { \ 37 | bytes = size_of(_v); \ 38 | _is.read( reinterpret_cast(&_v[0]), bytes ); \ 39 | } \ 40 | return _is.good() ? bytes : 0; \ 41 | } \ 42 | } 43 | 44 | BINARY_VECTOR( short ); 45 | BINARY_VECTOR( unsigned short ); 46 | BINARY_VECTOR( int ); 47 | BINARY_VECTOR( unsigned int ); 48 | BINARY_VECTOR( long ); 49 | BINARY_VECTOR( unsigned long ); 50 | BINARY_VECTOR( float ); 51 | BINARY_VECTOR( double ); 52 | 53 | #undef BINARY_VECTOR 54 | -------------------------------------------------------------------------------- /DevelopApp/Include/OpenMesh/Core/IO/SR_binary_vector_of_string.inl: -------------------------------------------------------------------------------- 1 | 2 | template <> struct binary< std::vector< std::string > > 3 | { 4 | // struct binary interface 5 | 6 | typedef std::vector< std::string > value_type; 7 | typedef value_type::value_type elem_type; 8 | 9 | static const bool is_streamable = true; 10 | 11 | // Helper 12 | 13 | struct Sum 14 | { 15 | size_t operator() ( size_t _v1, const elem_type& _s2 ) 16 | { return _v1 + binary::size_of(_s2); } 17 | }; 18 | 19 | // struct binary interface 20 | 21 | static size_t size_of(void) { return UnknownSize; } 22 | 23 | static size_t size_of(const value_type& _v) 24 | { return std::accumulate( _v.begin(), _v.end(), size_t(0), Sum() ); } 25 | 26 | static 27 | size_t store(std::ostream& _os, const value_type& _v, bool _swap=false) 28 | { 29 | return std::accumulate( _v.begin(), _v.end(), size_t(0), 30 | FunctorStore(_os, _swap) ); 31 | } 32 | 33 | static 34 | size_t restore(std::istream& _is, value_type& _v, bool _swap=false) 35 | { 36 | return std::accumulate( _v.begin(), _v.end(), size_t(0), 37 | FunctorRestore(_is, _swap) ); 38 | } 39 | }; 40 | -------------------------------------------------------------------------------- /DevelopApp/Include/OpenMesh/Core/IO/writer/VTKWriter.hh: -------------------------------------------------------------------------------- 1 | //============================================================================= 2 | // 3 | // Implements an IOManager writer module for VTK files 4 | // 5 | //============================================================================= 6 | 7 | #ifndef __VTKWRITER_HH__ 8 | #define __VTKWRITER_HH__ 9 | 10 | //=== INCLUDES ================================================================ 11 | 12 | #include 13 | #include 14 | 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | //== NAMESPACES =============================================================== 21 | 22 | namespace OpenMesh { 23 | namespace IO { 24 | 25 | //=== IMPLEMENTATION ========================================================== 26 | 27 | class OPENMESHDLLEXPORT _VTKWriter_ : public BaseWriter 28 | { 29 | public: 30 | _VTKWriter_(); 31 | 32 | std::string get_description() const { return "VTK"; } 33 | std::string get_extensions() const { return "vtk"; } 34 | 35 | bool write(const std::string&, BaseExporter&, Options, std::streamsize _precision = 6) const; 36 | bool write(std::ostream&, BaseExporter&, Options, std::streamsize _precision = 6) const; 37 | 38 | size_t binary_size(BaseExporter&, Options) const { return 0; } 39 | }; 40 | 41 | //== TYPE DEFINITION ========================================================== 42 | 43 | /// Declare the single entity of the OBJ writer 44 | extern _VTKWriter_ __VTKWriterinstance; 45 | OPENMESHDLLEXPORT _VTKWriter_& VTKWriter(); 46 | 47 | //============================================================================= 48 | } // namespace IO 49 | } // namespace OpenMesh 50 | //============================================================================= 51 | #endif 52 | //============================================================================= 53 | -------------------------------------------------------------------------------- /DevelopApp/Include/OpenMesh/Core/Mesh/Tags.hh: -------------------------------------------------------------------------------- 1 | /* ========================================================================= * 2 | * * 3 | * OpenMesh * 4 | * Copyright (c) 2001-2015, RWTH-Aachen University * 5 | * Department of Computer Graphics and Multimedia * 6 | * All rights reserved. * 7 | * www.openmesh.org * 8 | * * 9 | *---------------------------------------------------------------------------* 10 | * This file is part of OpenMesh. * 11 | *---------------------------------------------------------------------------* 12 | * * 13 | * Redistribution and use in source and binary forms, with or without * 14 | * modification, are permitted provided that the following conditions * 15 | * are met: * 16 | * * 17 | * 1. Redistributions of source code must retain the above copyright notice, * 18 | * this list of conditions and the following disclaimer. * 19 | * * 20 | * 2. Redistributions in binary form must reproduce the above copyright * 21 | * notice, this list of conditions and the following disclaimer in the * 22 | * documentation and/or other materials provided with the distribution. * 23 | * * 24 | * 3. Neither the name of the copyright holder nor the names of its * 25 | * contributors may be used to endorse or promote products derived from * 26 | * this software without specific prior written permission. * 27 | * * 28 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * 29 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * 30 | * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * 31 | * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER * 32 | * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * 33 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * 34 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * 35 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * 36 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * 37 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * 38 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * 39 | * * 40 | * ========================================================================= */ 41 | 42 | #pragma once 43 | 44 | namespace OpenMesh { 45 | 46 | /// Connectivity tag indicating that the tagged mesh has polygon connectivity. 47 | struct PolyConnectivityTag {}; 48 | /// Connectivity tag indicating that the tagged mesh has triangle connectivity. 49 | struct TriConnectivityTag {}; 50 | 51 | } // namespace OpenMesh 52 | 53 | -------------------------------------------------------------------------------- /DevelopApp/Include/OpenMesh/Core/Mesh/gen/footer.hh: -------------------------------------------------------------------------------- 1 | //============================================================================= 2 | } // namespace Iterators 3 | } // namespace OpenMesh 4 | //============================================================================= 5 | #endif 6 | //============================================================================= 7 | -------------------------------------------------------------------------------- /DevelopApp/Include/OpenMesh/Core/System/OpenMeshDLLMacros.hh: -------------------------------------------------------------------------------- 1 | /* ========================================================================= * 2 | * * 3 | * OpenMesh * 4 | * Copyright (c) 2001-2015, RWTH-Aachen University * 5 | * Department of Computer Graphics and Multimedia * 6 | * All rights reserved. * 7 | * www.openmesh.org * 8 | * * 9 | *---------------------------------------------------------------------------* 10 | * This file is part of OpenMesh. * 11 | *---------------------------------------------------------------------------* 12 | * * 13 | * Redistribution and use in source and binary forms, with or without * 14 | * modification, are permitted provided that the following conditions * 15 | * are met: * 16 | * * 17 | * 1. Redistributions of source code must retain the above copyright notice, * 18 | * this list of conditions and the following disclaimer. * 19 | * * 20 | * 2. Redistributions in binary form must reproduce the above copyright * 21 | * notice, this list of conditions and the following disclaimer in the * 22 | * documentation and/or other materials provided with the distribution. * 23 | * * 24 | * 3. Neither the name of the copyright holder nor the names of its * 25 | * contributors may be used to endorse or promote products derived from * 26 | * this software without specific prior written permission. * 27 | * * 28 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * 29 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * 30 | * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * 31 | * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER * 32 | * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * 33 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * 34 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * 35 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * 36 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * 37 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * 38 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * 39 | * * 40 | * ========================================================================= */ 41 | 42 | // Disable the warnings about needs to have DLL interface as we have tons of vector templates 43 | #ifdef _MSC_VER 44 | #pragma warning( disable: 4251 ) 45 | #endif 46 | 47 | #ifndef OPENMESHDLLEXPORT 48 | #ifdef WIN32 49 | #ifdef OPENMESHDLL 50 | #ifdef BUILDOPENMESHDLL 51 | #define OPENMESHDLLEXPORT __declspec(dllexport) 52 | #define OPENMESHDLLEXPORTONLY __declspec(dllexport) 53 | #else 54 | #define OPENMESHDLLEXPORT __declspec(dllimport) 55 | #define OPENMESHDLLEXPORTONLY 56 | #endif 57 | #else 58 | #define OPENMESHDLLEXPORT 59 | #define OPENMESHDLLEXPORTONLY 60 | #endif 61 | #else 62 | #define OPENMESHDLLEXPORT 63 | #define OPENMESHDLLEXPORTONLY 64 | #endif 65 | #endif 66 | -------------------------------------------------------------------------------- /DevelopApp/Include/OpenMesh/Core/System/config.hh: -------------------------------------------------------------------------------- 1 | /* ========================================================================= * 2 | * * 3 | * OpenMesh * 4 | * Copyright (c) 2001-2015, RWTH-Aachen University * 5 | * Department of Computer Graphics and Multimedia * 6 | * All rights reserved. * 7 | * www.openmesh.org * 8 | * * 9 | *---------------------------------------------------------------------------* 10 | * This file is part of OpenMesh. * 11 | *---------------------------------------------------------------------------* 12 | * * 13 | * Redistribution and use in source and binary forms, with or without * 14 | * modification, are permitted provided that the following conditions * 15 | * are met: * 16 | * * 17 | * 1. Redistributions of source code must retain the above copyright notice, * 18 | * this list of conditions and the following disclaimer. * 19 | * * 20 | * 2. Redistributions in binary form must reproduce the above copyright * 21 | * notice, this list of conditions and the following disclaimer in the * 22 | * documentation and/or other materials provided with the distribution. * 23 | * * 24 | * 3. Neither the name of the copyright holder nor the names of its * 25 | * contributors may be used to endorse or promote products derived from * 26 | * this software without specific prior written permission. * 27 | * * 28 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * 29 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * 30 | * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * 31 | * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER * 32 | * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * 33 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * 34 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * 35 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * 36 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * 37 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * 38 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * 39 | * * 40 | * ========================================================================= */ 41 | 42 | 43 | 44 | #include 45 | -------------------------------------------------------------------------------- /DevelopApp/Include/OpenMesh/Core/Utils/HandleToPropHandle.hh: -------------------------------------------------------------------------------- 1 | #ifndef HANDLETOPROPHANDLE_HH_ 2 | #define HANDLETOPROPHANDLE_HH_ 3 | 4 | #include 5 | #include 6 | 7 | namespace OpenMesh { 8 | 9 | template 10 | struct HandleToPropHandle { 11 | }; 12 | 13 | template 14 | struct HandleToPropHandle { 15 | using type = OpenMesh::VPropHandleT; 16 | }; 17 | 18 | template 19 | struct HandleToPropHandle { 20 | using type = OpenMesh::HPropHandleT; 21 | }; 22 | 23 | template 24 | struct HandleToPropHandle { 25 | using type = OpenMesh::EPropHandleT; 26 | }; 27 | 28 | template 29 | struct HandleToPropHandle { 30 | using type = OpenMesh::FPropHandleT; 31 | }; 32 | 33 | template 34 | struct HandleToPropHandle { 35 | using type = OpenMesh::MPropHandleT; 36 | }; 37 | 38 | } // namespace OpenMesh 39 | 40 | #endif // HANDLETOPROPHANDLE_HH_ -------------------------------------------------------------------------------- /DevelopApp/Include/OpenMesh/Tools/Utils/getopt.h: -------------------------------------------------------------------------------- 1 | #ifndef _GETOPT_H_ 2 | #define _GETOPT_H_ 3 | 4 | #include 5 | #include 6 | 7 | #if defined(_MSC_VER) 8 | #if defined(__cplusplus) 9 | 10 | extern "C" { 11 | 12 | extern OPENMESHDLLEXPORT int opterr; 13 | extern OPENMESHDLLEXPORT int optind; 14 | extern OPENMESHDLLEXPORT int optopt; 15 | extern OPENMESHDLLEXPORT int optreset; 16 | extern OPENMESHDLLEXPORT char *optarg; 17 | 18 | OPENMESHDLLEXPORT extern int getopt(int nargc, char * const *nargv, const char *ostr); 19 | 20 | } 21 | 22 | #endif 23 | 24 | #elif defined __APPLE__ 25 | #include 26 | #else 27 | #include 28 | #endif 29 | 30 | #endif /* _GETOPT_H_ */ 31 | -------------------------------------------------------------------------------- /DevelopApp/Library/OpenMeshCore.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/QingFang1208/DevelopApp/cccfc3fbba6adc686ab9fa8602844ba221a49792/DevelopApp/Library/OpenMeshCore.lib -------------------------------------------------------------------------------- /DevelopApp/Library/OpenMeshCored.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/QingFang1208/DevelopApp/cccfc3fbba6adc686ab9fa8602844ba221a49792/DevelopApp/Library/OpenMeshCored.lib -------------------------------------------------------------------------------- /DevelopApp/Library/OpenMeshTools.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/QingFang1208/DevelopApp/cccfc3fbba6adc686ab9fa8602844ba221a49792/DevelopApp/Library/OpenMeshTools.lib -------------------------------------------------------------------------------- /DevelopApp/Library/OpenMeshToolsd.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/QingFang1208/DevelopApp/cccfc3fbba6adc686ab9fa8602844ba221a49792/DevelopApp/Library/OpenMeshToolsd.lib -------------------------------------------------------------------------------- /DevelopApp/MeshDefinition.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | #ifdef _DEBUG 5 | #pragma comment(lib, "OpenMeshCored.lib") 6 | #pragma comment(lib, "OpenMeshToolsd.lib") 7 | #else 8 | #pragma comment(lib, "OpenMeshCore.lib") 9 | #pragma comment(lib, "OpenMeshTools.lib") 10 | #endif 11 | struct MeshTraits : public OpenMesh::DefaultTraits 12 | { 13 | typedef OpenMesh::Vec3d Point; 14 | typedef OpenMesh::Vec3d Normal; 15 | typedef OpenMesh::Vec3d TexCoord3D; 16 | VertexAttributes(OpenMesh::Attributes::Status | OpenMesh::Attributes::Normal); 17 | FaceAttributes(OpenMesh::Attributes::Status | OpenMesh::Attributes::Normal); 18 | EdgeAttributes(OpenMesh::Attributes::Status); 19 | HalfedgeAttributes(OpenMesh::Attributes::Status); 20 | 21 | typedef typename std::pair Link; // for local links 22 | typedef typename std::vector Link_vector; // for out links 23 | typedef typename std::deque Link_deque; // for in links 24 | 25 | FaceTraits 26 | { 27 | public: 28 | int m_tag = 0; // general-purpose tag 29 | // links 30 | Link_vector m_face_out_links; // point links from this facet 31 | Link_deque m_face_in_links; // point links to this facet 32 | Link_deque m_edge_in_links; 33 | Link_deque m_vertex_in_links; 34 | }; 35 | 36 | EdgeTraits 37 | { 38 | public: 39 | // links 40 | Link_vector m_edge_out_links; // point link from this edge 41 | }; 42 | 43 | HalfedgeTraits 44 | { 45 | HalfedgeT() :face_he_var(-1) 46 | { 47 | }; 48 | private: 49 | int face_he_var; 50 | public: 51 | int get_face_he_var()const { return face_he_var; }; 52 | void set_face_he_var(int fhe) { face_he_var = fhe; }; 53 | }; 54 | 55 | VertexTraits 56 | { 57 | VertexT() : new_pos_fixed(false) 58 | { 59 | }; 60 | private: 61 | OpenMesh::Vec3d new_pos;//can be used for deformation and parameterization 62 | bool new_pos_fixed; 63 | public: 64 | void set_New_Pos(const OpenMesh::Vec3d& n_p) { new_pos = n_p; } 65 | const OpenMesh::Vec3d& get_New_Pos()const { return new_pos; } 66 | void set_new_pos_fixed(bool f) { new_pos_fixed = f; } 67 | bool get_new_pos_fixed()const { return new_pos_fixed; } 68 | 69 | // links 70 | Link m_vertex_out_link; // Links from this vertex 71 | }; 72 | }; 73 | typedef OpenMesh::TriMesh_ArrayKernelT Mesh; 74 | 75 | typedef OpenMesh::EdgeHandle EH; 76 | typedef OpenMesh::FaceHandle FH; 77 | typedef OpenMesh::HalfedgeHandle HEH; 78 | typedef OpenMesh::VertexHandle VH; 79 | 80 | class MeshTools 81 | { 82 | public: 83 | static bool ReadMesh(Mesh & mesh, const std::string & filename); 84 | static bool ReadOBJ(Mesh & mesh, const std::string & filename); 85 | //static bool ReadOFF(Mesh & mesh, const std::string & filename); 86 | static bool WriteMesh(const Mesh & mesh, const std::string & filename, const std::streamsize & precision = 6); 87 | static bool WriteOBJ(const Mesh & mesh, const std::string & filename, const std::streamsize & precision = 6); 88 | static double Area(const Mesh & mesh); 89 | static double AverageEdgeLength(const Mesh & mesh); 90 | static bool HasBoundary(const Mesh & mesh); 91 | static bool HasOneComponent(const Mesh & mesh); 92 | static int Genus(const Mesh & mesh); 93 | static void BoundingBox(const Mesh & mesh, Mesh::Point & bmax, Mesh::Point & bmin); 94 | static void Reassign(const Mesh & mesh1, Mesh & mesh2); 95 | static void ComputeGaussianCurvature(const Mesh& mesh, std::vector& v_gauss, const bool& bound_remove = true); 96 | }; 97 | -------------------------------------------------------------------------------- /DevelopApp/mesh_data/Bunny/deform_and_seg_information.txt: -------------------------------------------------------------------------------- 1 | Iter Num: 10 2 | Prev energy: 4.0416 3 | Cur energy: 3.96974 4 | Energy diff: 0.0718581 5 | Max Curvature: 0.164637 6 | Seg Num: 18 7 | Seg Energy and Curvature: 8 | 0th energy: 0.0013059 high curvature: 0.014158 9 | 1th energy: 0.00326432 high curvature: 0.0506263 10 | 2th energy: 0.00586372 high curvature: 0.0788813 11 | 3th energy: 0.00317671 high curvature: 0.0169104 12 | 4th energy: 0.00502595 high curvature: 0.0746147 13 | 5th energy: 0.00154183 high curvature: 0.0182808 14 | 6th energy: 0.0123487 high curvature: 0.140834 15 | 7th energy: 0.013297 high curvature: 0.164637 16 | 8th energy: 0.00312228 high curvature: 0.0428633 17 | 9th energy: 0.0213493 high curvature: 0.103052 18 | 10th energy: 0.000861906 high curvature: 0.013489 19 | 11th energy: 0.0223092 high curvature: 0.131909 20 | 12th energy: 0.00221404 high curvature: 0.0283076 21 | 13th energy: 0.00624748 high curvature: 0.042322 22 | 14th energy: 0.00138716 high curvature: 0.0207039 23 | 15th energy: 0.00793005 high curvature: 0.146951 24 | 16th energy: 0.00271859 high curvature: 0.0580411 25 | 17th energy: 0.00596057 high curvature: 0.0491608 26 | -------------------------------------------------------------------------------- /DevelopApp/mesh_data/Tortiose/deform_and_seg_information.txt: -------------------------------------------------------------------------------- 1 | Iter Num: 10 2 | Prev energy: 3.85932 3 | Cur energy: 3.8133 4 | Energy diff: 0.0460172 5 | Max Curvature: 2.0913 6 | Seg Num: 25 7 | Seg Energy and Curvature: 8 | 0th energy: 0.00509711 high curvature: 0.599452 9 | 1th energy: 0.00278639 high curvature: 1.05854 10 | 2th energy: 0.00846518 high curvature: 0.23319 11 | 3th energy: 0.000266146 high curvature: 0.00749321 12 | 4th energy: 0.0029139 high curvature: 0.0673376 13 | 5th energy: 0.00613291 high curvature: 0.076704 14 | 6th energy: 0.00466896 high curvature: 0.287296 15 | 7th energy: 0.00372192 high curvature: 0.0696012 16 | 8th energy: 0.00323593 high curvature: 0.214445 17 | 9th energy: 0.00231199 high curvature: 0.0754167 18 | 10th energy: 0.00183367 high curvature: 0.0433807 19 | 11th energy: 0.00234818 high curvature: 1.33093 20 | 12th energy: 0.00230186 high curvature: 0.0560396 21 | 13th energy: 0.000412281 high curvature: 0.00523247 22 | 14th energy: 0.00275428 high curvature: 1.21435 23 | 15th energy: 0.00077996 high curvature: 0.705509 24 | 16th energy: 0.00289593 high curvature: 0.0554971 25 | 17th energy: 0.00203039 high curvature: 0.0125204 26 | 18th energy: 0.0102158 high curvature: 0.00588295 27 | 19th energy: 0.026485 high curvature: 2.0913 28 | 20th energy: 0.0054142 high curvature: 0.298461 29 | 21th energy: 0.000197885 high curvature: 0.0120144 30 | 22th energy: 0.000584361 high curvature: 0.0123142 31 | 23th energy: 0.000514643 high curvature: 0.00467742 32 | 24th energy: 0.00281427 high curvature: 0.0409345 33 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | DevelopApp 2 | === 3 | 4 | This is a C++ implementation of the piecewise developable approximation in the following paper: 5 | 6 | [Developability-Driven Piecewise Approximations for Triangular Meshes](https://rec.ustc.edu.cn/share/d5e47230-f81b-11ec-9466-2ba4385ffe49). 7 | Zheng-Yu Zhao\*, [Qing Fang](https://qingfang1208.github.io/)\*, Wenqing Ouyang, Zheng Zhang, [Ligang Liu](http://staff.ustc.edu.cn/~lgliu/), [Xiao-Ming Fu](https://ustc-gcl-f.github.io/). 8 | *ACM Transactions on Graphics (SIGGRAPH)*, 41(4), 2022. (*Joint first authors) 9 | 10 | The code is written by Zheng-Yu Zhao and Qing Fang using Microsoft Visual Studio 2019 based on the [Surface Mesh Framework](http://staff.ustc.edu.cn/~fuxm/code/index.html#sec_surface_framework), with OpenMP support for parallel programming. 11 | 12 | ## External Libraries 13 | 14 | * [Matlab](https://www.mathworks.com/) (2020b) 15 | * [Eigen](http://eigen.tuxfamily.org/) (3.4) 16 | * [OpenMesh](https://www.openmesh.org/) (8.0) 17 | * OpenMP support 18 | 19 | ## Output 20 | 21 | * final.obj --- the final piecewise approximated result. 22 | * final_seg.txt --- the parts id for triangles in the final result. 23 | --------------------------------------------------------------------------------