Initial snapshot: hand motion pipeline (Dyn-HaMR + dex-retargeting + SPIDER)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

third_party/Dyn-HaMR/third-party/DROID-SLAM/thirdparty/eigen/lapack/CMakeLists.txt

@@ -0,0 +1,459 @@
+project(EigenLapack CXX)
+
+include(CheckLanguage)
+check_language(Fortran)
+if(CMAKE_Fortran_COMPILER)
+  enable_language(Fortran)
+  if("${CMAKE_Fortran_COMPILER_ID}" STREQUAL "GNU")
+    if ("${CMAKE_Fortran_COMPILER_VERSION}" VERSION_GREATER_EQUAL 10.0)
+      # We use an old version of LAPACK with argument type mismatches.
+      # Allow them to compile anyway with newer GNU versions.
+      set(CMAKE_Fortran_FLAGS  "${CMAKE_Fortran_FLAGS} -fallow-argument-mismatch")
+    endif()
+  endif()
+  set(EIGEN_Fortran_COMPILER_WORKS ON)
+else()
+  set(EIGEN_Fortran_COMPILER_WORKS OFF)
+endif()
+
+add_custom_target(lapack)
+include_directories(../blas)
+
+set(EigenLapack_SRCS
+single.cpp double.cpp complex_single.cpp complex_double.cpp ../blas/xerbla.cpp
+)
+
+if(EIGEN_Fortran_COMPILER_WORKS)
+
+set(EigenLapack_SRCS  ${EigenLapack_SRCS}
+  slarft.f  dlarft.f  clarft.f  zlarft.f
+  slarfb.f  dlarfb.f  clarfb.f  zlarfb.f
+  slarfg.f  dlarfg.f  clarfg.f  zlarfg.f
+  slarf.f   dlarf.f   clarf.f   zlarf.f
+  sladiv.f  dladiv.f  cladiv.f  zladiv.f
+  ilaslr.f  iladlr.f  ilaclr.f  ilazlr.f
+  ilaslc.f  iladlc.f  ilaclc.f  ilazlc.f
+  dlapy2.f  dlapy3.f  slapy2.f  slapy3.f
+  clacgv.f  zlacgv.f
+  slamch.f  dlamch.f
+  second_NONE.f dsecnd_NONE.f
+)
+
+option(EIGEN_ENABLE_LAPACK_TESTS OFF "Enable the Lapack unit tests")
+
+if(EIGEN_ENABLE_LAPACK_TESTS)
+
+  get_filename_component(eigen_full_path_to_reference_lapack "./reference/" ABSOLUTE)
+  if(NOT EXISTS ${eigen_full_path_to_reference_lapack})
+    # Download lapack and install sources and testing at the right place
+    message(STATUS "Download lapack_addons_3.4.1.tgz...")
+    
+    file(DOWNLOAD "http://downloads.tuxfamily.org/eigen/lapack_addons_3.4.1.tgz"
+                  "${CMAKE_CURRENT_SOURCE_DIR}/lapack_addons_3.4.1.tgz"
+                  INACTIVITY_TIMEOUT 15
+                  TIMEOUT 240
+                  STATUS download_status
+                  EXPECTED_MD5 ab5742640617e3221a873aba44bbdc93
+                  SHOW_PROGRESS)
+                  
+    message(STATUS ${download_status})
+    list(GET download_status 0 download_status_num)
+    set(download_status_num 0)
+    if(download_status_num EQUAL 0)
+      message(STATUS "Setup lapack reference and lapack unit tests")
+      execute_process(COMMAND tar xzf  "lapack_addons_3.4.1.tgz" WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+    else()
+      message(STATUS "Download of lapack_addons_3.4.1.tgz failed, LAPACK unit tests won't be enabled")
+      set(EIGEN_ENABLE_LAPACK_TESTS false)
+    endif()
+                  
+  endif()
+  
+  get_filename_component(eigen_full_path_to_reference_lapack "./reference/" ABSOLUTE)
+  if(EXISTS ${eigen_full_path_to_reference_lapack})
+    set(EigenLapack_funcfilenames
+        ssyev.f   dsyev.f   csyev.f   zsyev.f
+        spotrf.f  dpotrf.f  cpotrf.f  zpotrf.f
+        spotrs.f  dpotrs.f  cpotrs.f  zpotrs.f
+        sgetrf.f  dgetrf.f  cgetrf.f  zgetrf.f
+        sgetrs.f  dgetrs.f  cgetrs.f  zgetrs.f)
+    
+    file(GLOB ReferenceLapack_SRCS0 RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "reference/*.f")
+    foreach(filename1 IN LISTS ReferenceLapack_SRCS0)
+      string(REPLACE "reference/" "" filename ${filename1})
+      list(FIND EigenLapack_SRCS ${filename} id1)
+      list(FIND EigenLapack_funcfilenames ${filename} id2)
+      if((id1 EQUAL -1) AND (id2 EQUAL -1))
+        set(ReferenceLapack_SRCS ${ReferenceLapack_SRCS} reference/${filename})
+      endif()
+    endforeach()
+  endif()
+  
+  
+endif()
+
+endif()
+
+set(EIGEN_LAPACK_TARGETS "")
+
+add_library(eigen_lapack_static ${EigenLapack_SRCS} ${ReferenceLapack_SRCS})
+list(APPEND EIGEN_LAPACK_TARGETS eigen_lapack_static)
+
+if (EIGEN_BUILD_SHARED_LIBS)
+  add_library(eigen_lapack SHARED ${EigenLapack_SRCS})
+  list(APPEND EIGEN_LAPACK_TARGETS eigen_lapack)
+  target_link_libraries(eigen_lapack  eigen_blas)
+endif()
+
+foreach(target IN LISTS EIGEN_LAPACK_TARGETS)
+  if(EIGEN_STANDARD_LIBRARIES_TO_LINK_TO)
+    target_link_libraries(${target} ${EIGEN_STANDARD_LIBRARIES_TO_LINK_TO})
+  endif()
+  add_dependencies(lapack ${target})
+  install(TARGETS ${target}
+          RUNTIME DESTINATION bin
+          LIBRARY DESTINATION lib
+          ARCHIVE DESTINATION lib)
+endforeach()
+
+
+get_filename_component(eigen_full_path_to_testing_lapack "./testing/" ABSOLUTE)
+if(EXISTS ${eigen_full_path_to_testing_lapack})
+  
+  # The following comes from lapack/TESTING/CMakeLists.txt
+  # Get Python
+  find_package(PythonInterp)
+  message(STATUS "Looking for Python found - ${PYTHONINTERP_FOUND}")
+  if (PYTHONINTERP_FOUND)
+    message(STATUS "Using Python version ${PYTHON_VERSION_STRING}")
+  endif()
+
+  set(LAPACK_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+  set(LAPACK_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
+  set(BUILD_SINGLE      true)
+  set(BUILD_DOUBLE      true)
+  set(BUILD_COMPLEX     true)
+  set(BUILD_COMPLEX16E  true)
+  
+  if(MSVC_VERSION)
+#  string(REPLACE "/STACK:10000000" "/STACK:900000000000000000"
+#    CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}")
+  string(REGEX REPLACE "(.*)/STACK:(.*) (.*)" "\\1/STACK:900000000000000000 \\3"
+    CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}")
+  endif()
+  file(MAKE_DIRECTORY "${LAPACK_BINARY_DIR}/TESTING")
+  add_subdirectory(testing/MATGEN)
+  add_subdirectory(testing/LIN)
+  add_subdirectory(testing/EIG)
+  macro(add_lapack_test output input target)
+    set(TEST_INPUT "${LAPACK_SOURCE_DIR}/testing/${input}")
+    set(TEST_OUTPUT "${LAPACK_BINARY_DIR}/TESTING/${output}")
+    string(REPLACE "." "_" input_name ${input})
+    set(testName "${target}_${input_name}")
+    if(EXISTS "${TEST_INPUT}")
+      add_dependencies(buildtests ${target})
+      add_test(NAME LAPACK-${testName}
+        COMMAND "${CMAKE_COMMAND}"
+        -DTEST=$<TARGET_FILE:${target}>
+        -DINPUT=${TEST_INPUT} 
+        -DOUTPUT=${TEST_OUTPUT} 
+        -DINTDIR=${CMAKE_CFG_INTDIR}
+        -P "${LAPACK_SOURCE_DIR}/testing/runtest.cmake")
+    endif()
+  endmacro()
+
+  if (BUILD_SINGLE)
+  add_lapack_test(stest.out stest.in xlintsts)
+  #
+  # ======== SINGLE RFP LIN TESTS ========================
+  add_lapack_test(stest_rfp.out stest_rfp.in xlintstrfs)
+  #
+  #
+  # ======== SINGLE EIG TESTS ===========================
+  #
+
+  add_lapack_test(snep.out nep.in xeigtsts)
+
+
+  add_lapack_test(ssep.out sep.in xeigtsts)
+
+
+  add_lapack_test(ssvd.out svd.in xeigtsts)
+
+
+  add_lapack_test(sec.out sec.in xeigtsts)
+
+
+  add_lapack_test(sed.out sed.in xeigtsts)
+
+
+  add_lapack_test(sgg.out sgg.in xeigtsts)
+
+
+  add_lapack_test(sgd.out sgd.in xeigtsts)
+
+
+  add_lapack_test(ssb.out ssb.in xeigtsts)
+
+
+  add_lapack_test(ssg.out ssg.in xeigtsts)
+
+
+  add_lapack_test(sbal.out sbal.in xeigtsts)
+
+
+  add_lapack_test(sbak.out sbak.in xeigtsts)
+
+
+  add_lapack_test(sgbal.out sgbal.in xeigtsts)
+
+
+  add_lapack_test(sgbak.out sgbak.in xeigtsts)
+
+
+  add_lapack_test(sbb.out sbb.in xeigtsts)
+
+
+  add_lapack_test(sglm.out glm.in xeigtsts)
+
+
+  add_lapack_test(sgqr.out gqr.in xeigtsts)
+
+
+  add_lapack_test(sgsv.out gsv.in xeigtsts)
+
+
+  add_lapack_test(scsd.out csd.in xeigtsts)
+
+
+  add_lapack_test(slse.out lse.in xeigtsts)
+  endif()
+
+  if (BUILD_DOUBLE)
+  #
+  # ======== DOUBLE LIN TESTS ===========================
+  add_lapack_test(dtest.out dtest.in xlintstd)
+  #
+  # ======== DOUBLE RFP LIN TESTS ========================
+  add_lapack_test(dtest_rfp.out dtest_rfp.in xlintstrfd)
+  #
+  # ======== DOUBLE EIG TESTS ===========================
+
+  add_lapack_test(dnep.out nep.in xeigtstd)
+
+
+  add_lapack_test(dsep.out sep.in xeigtstd)
+
+
+  add_lapack_test(dsvd.out svd.in xeigtstd)
+
+
+  add_lapack_test(dec.out dec.in xeigtstd)
+
+
+  add_lapack_test(ded.out ded.in xeigtstd)
+
+
+  add_lapack_test(dgg.out dgg.in xeigtstd)
+
+
+  add_lapack_test(dgd.out dgd.in xeigtstd)
+
+
+  add_lapack_test(dsb.out dsb.in xeigtstd)
+
+
+  add_lapack_test(dsg.out dsg.in xeigtstd)
+
+
+  add_lapack_test(dbal.out dbal.in xeigtstd)
+
+
+  add_lapack_test(dbak.out dbak.in xeigtstd)
+
+
+  add_lapack_test(dgbal.out dgbal.in xeigtstd)
+
+
+  add_lapack_test(dgbak.out dgbak.in xeigtstd)
+
+
+  add_lapack_test(dbb.out dbb.in xeigtstd)
+
+
+  add_lapack_test(dglm.out glm.in xeigtstd)
+
+
+  add_lapack_test(dgqr.out gqr.in xeigtstd)
+
+
+  add_lapack_test(dgsv.out gsv.in xeigtstd)
+
+
+  add_lapack_test(dcsd.out csd.in xeigtstd)
+
+
+  add_lapack_test(dlse.out lse.in xeigtstd)
+  endif()
+
+  if (BUILD_COMPLEX)
+  add_lapack_test(ctest.out ctest.in xlintstc)
+  #
+  # ======== COMPLEX RFP LIN TESTS ========================
+  add_lapack_test(ctest_rfp.out ctest_rfp.in xlintstrfc)
+  #
+  # ======== COMPLEX EIG TESTS ===========================
+
+  add_lapack_test(cnep.out nep.in xeigtstc)
+
+
+  add_lapack_test(csep.out sep.in xeigtstc)
+
+
+  add_lapack_test(csvd.out svd.in xeigtstc)
+
+
+  add_lapack_test(cec.out cec.in xeigtstc)
+
+
+  add_lapack_test(ced.out ced.in xeigtstc)
+
+
+  add_lapack_test(cgg.out cgg.in xeigtstc)
+
+
+  add_lapack_test(cgd.out cgd.in xeigtstc)
+
+
+  add_lapack_test(csb.out csb.in xeigtstc)
+
+
+  add_lapack_test(csg.out csg.in xeigtstc)
+
+
+  add_lapack_test(cbal.out cbal.in xeigtstc)
+
+
+  add_lapack_test(cbak.out cbak.in xeigtstc)
+
+
+  add_lapack_test(cgbal.out cgbal.in xeigtstc)
+
+
+  add_lapack_test(cgbak.out cgbak.in xeigtstc)
+
+
+  add_lapack_test(cbb.out cbb.in xeigtstc)
+
+
+  add_lapack_test(cglm.out glm.in xeigtstc)
+
+
+  add_lapack_test(cgqr.out gqr.in xeigtstc)
+
+
+  add_lapack_test(cgsv.out gsv.in xeigtstc)
+
+
+  add_lapack_test(ccsd.out csd.in xeigtstc)
+
+
+  add_lapack_test(clse.out lse.in xeigtstc)
+  endif()
+
+  if (BUILD_COMPLEX16)
+  #
+  # ======== COMPLEX16 LIN TESTS ========================
+  add_lapack_test(ztest.out ztest.in xlintstz)
+  #
+  # ======== COMPLEX16 RFP LIN TESTS ========================
+  add_lapack_test(ztest_rfp.out ztest_rfp.in xlintstrfz)
+  #
+  # ======== COMPLEX16 EIG TESTS ===========================
+
+  add_lapack_test(znep.out nep.in xeigtstz)
+
+
+  add_lapack_test(zsep.out sep.in xeigtstz)
+
+
+  add_lapack_test(zsvd.out svd.in xeigtstz)
+
+
+  add_lapack_test(zec.out zec.in xeigtstz)
+
+
+  add_lapack_test(zed.out zed.in xeigtstz)
+
+
+  add_lapack_test(zgg.out zgg.in xeigtstz)
+
+
+  add_lapack_test(zgd.out zgd.in xeigtstz)
+
+
+  add_lapack_test(zsb.out zsb.in xeigtstz)
+
+
+  add_lapack_test(zsg.out zsg.in xeigtstz)
+
+
+  add_lapack_test(zbal.out zbal.in xeigtstz)
+
+
+  add_lapack_test(zbak.out zbak.in xeigtstz)
+
+
+  add_lapack_test(zgbal.out zgbal.in xeigtstz)
+
+
+  add_lapack_test(zgbak.out zgbak.in xeigtstz)
+
+
+  add_lapack_test(zbb.out zbb.in xeigtstz)
+
+
+  add_lapack_test(zglm.out glm.in xeigtstz)
+
+
+  add_lapack_test(zgqr.out gqr.in xeigtstz)
+
+
+  add_lapack_test(zgsv.out gsv.in xeigtstz)
+
+
+  add_lapack_test(zcsd.out csd.in xeigtstz)
+
+
+  add_lapack_test(zlse.out lse.in xeigtstz)
+  endif()
+
+
+  if (BUILD_SIMPLE)
+      if (BUILD_DOUBLE)
+  #
+  # ======== SINGLE-DOUBLE PROTO LIN TESTS ==============
+          add_lapack_test(dstest.out dstest.in xlintstds)
+      endif()
+  endif()
+
+
+  if (BUILD_COMPLEX)
+      if (BUILD_COMPLEX16)
+  #
+  # ======== COMPLEX-COMPLEX16 LIN TESTS ========================
+          add_lapack_test(zctest.out zctest.in xlintstzc)
+      endif()
+  endif()
+
+  # ==============================================================================
+
+  execute_process(COMMAND ${CMAKE_COMMAND} -E copy ${LAPACK_SOURCE_DIR}/testing/lapack_testing.py ${LAPACK_BINARY_DIR})
+  add_test(
+    NAME LAPACK_Test_Summary
+    WORKING_DIRECTORY ${LAPACK_BINARY_DIR}
+    COMMAND ${PYTHON_EXECUTABLE} "lapack_testing.py"
+  )
+
+endif()
+

third_party/Dyn-HaMR/third-party/DROID-SLAM/thirdparty/eigen/lapack/cholesky.cpp

@@ -0,0 +1,72 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#include "lapack_common.h"
+#include <Eigen/Cholesky>
+
+// POTRF computes the Cholesky factorization of a real symmetric positive definite matrix A.
+EIGEN_LAPACK_FUNC(potrf,(char* uplo, int *n, RealScalar *pa, int *lda, int *info))
+{
+  *info = 0;
+        if(UPLO(*uplo)==INVALID) *info = -1;
+  else  if(*n<0)                 *info = -2;
+  else  if(*lda<std::max(1,*n))  *info = -4;
+  if(*info!=0)
+  {
+    int e = -*info;
+    return xerbla_(SCALAR_SUFFIX_UP"POTRF", &e, 6);
+  }
+
+  Scalar* a = reinterpret_cast<Scalar*>(pa);
+  MatrixType A(a,*n,*n,*lda);
+  int ret;
+  if(UPLO(*uplo)==UP) ret = int(internal::llt_inplace<Scalar, Upper>::blocked(A));
+  else                ret = int(internal::llt_inplace<Scalar, Lower>::blocked(A));
+
+  if(ret>=0)
+    *info = ret+1;
+  
+  return 0;
+}
+
+// POTRS solves a system of linear equations A*X = B with a symmetric
+// positive definite matrix A using the Cholesky factorization
+// A = U**T*U or A = L*L**T computed by DPOTRF.
+EIGEN_LAPACK_FUNC(potrs,(char* uplo, int *n, int *nrhs, RealScalar *pa, int *lda, RealScalar *pb, int *ldb, int *info))
+{
+  *info = 0;
+        if(UPLO(*uplo)==INVALID) *info = -1;
+  else  if(*n<0)                 *info = -2;
+  else  if(*nrhs<0)              *info = -3;
+  else  if(*lda<std::max(1,*n))  *info = -5;
+  else  if(*ldb<std::max(1,*n))  *info = -7;
+  if(*info!=0)
+  {
+    int e = -*info;
+    return xerbla_(SCALAR_SUFFIX_UP"POTRS", &e, 6);
+  }
+
+  Scalar* a = reinterpret_cast<Scalar*>(pa);
+  Scalar* b = reinterpret_cast<Scalar*>(pb);
+  MatrixType A(a,*n,*n,*lda);
+  MatrixType B(b,*n,*nrhs,*ldb);
+
+  if(UPLO(*uplo)==UP)
+  {
+    A.triangularView<Upper>().adjoint().solveInPlace(B);
+    A.triangularView<Upper>().solveInPlace(B);
+  }
+  else
+  {
+    A.triangularView<Lower>().solveInPlace(B);
+    A.triangularView<Lower>().adjoint().solveInPlace(B);
+  }
+
+  return 0;
+}

third_party/Dyn-HaMR/third-party/DROID-SLAM/thirdparty/eigen/lapack/complex_double.cpp

@@ -0,0 +1,18 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#define SCALAR        std::complex<double>
+#define SCALAR_SUFFIX z
+#define SCALAR_SUFFIX_UP "Z"
+#define REAL_SCALAR_SUFFIX d
+#define ISCOMPLEX     1
+
+#include "cholesky.cpp"
+#include "lu.cpp"
+#include "svd.cpp"

third_party/Dyn-HaMR/third-party/DROID-SLAM/thirdparty/eigen/lapack/complex_single.cpp

@@ -0,0 +1,18 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#define SCALAR        std::complex<float>
+#define SCALAR_SUFFIX c
+#define SCALAR_SUFFIX_UP "C"
+#define REAL_SCALAR_SUFFIX s
+#define ISCOMPLEX     1
+
+#include "cholesky.cpp"
+#include "lu.cpp"
+#include "svd.cpp"

third_party/Dyn-HaMR/third-party/DROID-SLAM/thirdparty/eigen/lapack/double.cpp

@@ -0,0 +1,18 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#define SCALAR        double
+#define SCALAR_SUFFIX d
+#define SCALAR_SUFFIX_UP "D"
+#define ISCOMPLEX     0
+
+#include "cholesky.cpp"
+#include "lu.cpp"
+#include "eigenvalues.cpp"
+#include "svd.cpp"

third_party/Dyn-HaMR/third-party/DROID-SLAM/thirdparty/eigen/lapack/eigenvalues.cpp

@@ -0,0 +1,62 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#include "lapack_common.h"
+#include <Eigen/Eigenvalues>
+
+// computes eigen values and vectors of a general N-by-N matrix A
+EIGEN_LAPACK_FUNC(syev,(char *jobz, char *uplo, int* n, Scalar* a, int *lda, Scalar* w, Scalar* /*work*/, int* lwork, int *info))
+{
+  // TODO exploit the work buffer
+  bool query_size = *lwork==-1;
+  
+  *info = 0;
+        if(*jobz!='N' && *jobz!='V')                    *info = -1;
+  else  if(UPLO(*uplo)==INVALID)                        *info = -2;
+  else  if(*n<0)                                        *info = -3;
+  else  if(*lda<std::max(1,*n))                         *info = -5;
+  else  if((!query_size) && *lwork<std::max(1,3**n-1))  *info = -8;
+    
+  if(*info!=0)
+  {
+    int e = -*info;
+    return xerbla_(SCALAR_SUFFIX_UP"SYEV ", &e, 6);
+  }
+  
+  if(query_size)
+  {
+    *lwork = 0;
+    return 0;
+  }
+  
+  if(*n==0)
+    return 0;
+  
+  PlainMatrixType mat(*n,*n);
+  if(UPLO(*uplo)==UP) mat = matrix(a,*n,*n,*lda).adjoint();
+  else                mat = matrix(a,*n,*n,*lda);
+  
+  bool computeVectors = *jobz=='V' || *jobz=='v';
+  SelfAdjointEigenSolver<PlainMatrixType> eig(mat,computeVectors?ComputeEigenvectors:EigenvaluesOnly);
+  
+  if(eig.info()==NoConvergence)
+  {
+    make_vector(w,*n).setZero();
+    if(computeVectors)
+      matrix(a,*n,*n,*lda).setIdentity();
+    //*info = 1;
+    return 0;
+  }
+  
+  make_vector(w,*n) = eig.eigenvalues();
+  if(computeVectors)
+    matrix(a,*n,*n,*lda) = eig.eigenvectors();
+  
+  return 0;
+}

third_party/Dyn-HaMR/third-party/DROID-SLAM/thirdparty/eigen/lapack/lapack_common.h

@@ -0,0 +1,29 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_LAPACK_COMMON_H
+#define EIGEN_LAPACK_COMMON_H
+
+#include "../blas/common.h"
+#include "../Eigen/src/misc/lapack.h"
+
+#define EIGEN_LAPACK_FUNC(FUNC,ARGLIST)               \
+  extern "C" { int EIGEN_BLAS_FUNC(FUNC) ARGLIST; }   \
+  int EIGEN_BLAS_FUNC(FUNC) ARGLIST
+
+typedef Eigen::Map<Eigen::Transpositions<Eigen::Dynamic,Eigen::Dynamic,int> > PivotsType;
+
+#if ISCOMPLEX
+#define EIGEN_LAPACK_ARG_IF_COMPLEX(X) X,
+#else
+#define EIGEN_LAPACK_ARG_IF_COMPLEX(X)
+#endif
+
+
+#endif // EIGEN_LAPACK_COMMON_H

third_party/Dyn-HaMR/third-party/DROID-SLAM/thirdparty/eigen/lapack/lu.cpp

@@ -0,0 +1,89 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#include "common.h"
+#include <Eigen/LU>
+
+// computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges
+EIGEN_LAPACK_FUNC(getrf,(int *m, int *n, RealScalar *pa, int *lda, int *ipiv, int *info))
+{
+  *info = 0;
+        if(*m<0)                  *info = -1;
+  else  if(*n<0)                  *info = -2;
+  else  if(*lda<std::max(1,*m))   *info = -4;
+  if(*info!=0)
+  {
+    int e = -*info;
+    return xerbla_(SCALAR_SUFFIX_UP"GETRF", &e, 6);
+  }
+
+  if(*m==0 || *n==0)
+    return 0;
+
+  Scalar* a = reinterpret_cast<Scalar*>(pa);
+  int nb_transpositions;
+  int ret = int(Eigen::internal::partial_lu_impl<Scalar,ColMajor,int>
+                     ::blocked_lu(*m, *n, a, *lda, ipiv, nb_transpositions));
+
+  for(int i=0; i<std::min(*m,*n); ++i)
+    ipiv[i]++;
+
+  if(ret>=0)
+    *info = ret+1;
+
+  return 0;
+}
+
+//GETRS solves a system of linear equations
+//    A * X = B  or  A' * X = B
+//  with a general N-by-N matrix A using the LU factorization computed  by GETRF
+EIGEN_LAPACK_FUNC(getrs,(char *trans, int *n, int *nrhs, RealScalar *pa, int *lda, int *ipiv, RealScalar *pb, int *ldb, int *info))
+{
+  *info = 0;
+        if(OP(*trans)==INVALID)  *info = -1;
+  else  if(*n<0)                 *info = -2;
+  else  if(*nrhs<0)              *info = -3;
+  else  if(*lda<std::max(1,*n))  *info = -5;
+  else  if(*ldb<std::max(1,*n))  *info = -8;
+  if(*info!=0)
+  {
+    int e = -*info;
+    return xerbla_(SCALAR_SUFFIX_UP"GETRS", &e, 6);
+  }
+
+  Scalar* a = reinterpret_cast<Scalar*>(pa);
+  Scalar* b = reinterpret_cast<Scalar*>(pb);
+  MatrixType lu(a,*n,*n,*lda);
+  MatrixType B(b,*n,*nrhs,*ldb);
+
+  for(int i=0; i<*n; ++i)
+    ipiv[i]--;
+  if(OP(*trans)==NOTR)
+  {
+    B = PivotsType(ipiv,*n) * B;
+    lu.triangularView<UnitLower>().solveInPlace(B);
+    lu.triangularView<Upper>().solveInPlace(B);
+  }
+  else if(OP(*trans)==TR)
+  {
+    lu.triangularView<Upper>().transpose().solveInPlace(B);
+    lu.triangularView<UnitLower>().transpose().solveInPlace(B);
+    B = PivotsType(ipiv,*n).transpose() * B;
+  }
+  else if(OP(*trans)==ADJ)
+  {
+    lu.triangularView<Upper>().adjoint().solveInPlace(B);
+    lu.triangularView<UnitLower>().adjoint().solveInPlace(B);
+    B = PivotsType(ipiv,*n).transpose() * B;
+  }
+  for(int i=0; i<*n; ++i)
+    ipiv[i]++;
+
+  return 0;
+}

third_party/Dyn-HaMR/third-party/DROID-SLAM/thirdparty/eigen/lapack/single.cpp

@@ -0,0 +1,18 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#define SCALAR        float
+#define SCALAR_SUFFIX s
+#define SCALAR_SUFFIX_UP "S"
+#define ISCOMPLEX     0
+
+#include "cholesky.cpp"
+#include "lu.cpp"
+#include "eigenvalues.cpp"
+#include "svd.cpp"

third_party/Dyn-HaMR/third-party/DROID-SLAM/thirdparty/eigen/lapack/svd.cpp

@@ -0,0 +1,138 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#include "lapack_common.h"
+#include <Eigen/SVD>
+
+// computes the singular values/vectors a general M-by-N matrix A using divide-and-conquer
+EIGEN_LAPACK_FUNC(gesdd,(char *jobz, int *m, int* n, Scalar* a, int *lda, RealScalar *s, Scalar *u, int *ldu, Scalar *vt, int *ldvt, Scalar* /*work*/, int* lwork,
+                         EIGEN_LAPACK_ARG_IF_COMPLEX(RealScalar */*rwork*/) int * /*iwork*/, int *info))
+{
+  // TODO exploit the work buffer
+  bool query_size = *lwork==-1;
+  int diag_size = (std::min)(*m,*n);
+  
+  *info = 0;
+        if(*jobz!='A' && *jobz!='S' && *jobz!='O' && *jobz!='N')  *info = -1;
+  else  if(*m<0)                                                  *info = -2;
+  else  if(*n<0)                                                  *info = -3;
+  else  if(*lda<std::max(1,*m))                                   *info = -5;
+  else  if(*lda<std::max(1,*m))                                   *info = -8;
+  else  if(*ldu <1 || (*jobz=='A' && *ldu <*m)
+                   || (*jobz=='O' && *m<*n && *ldu<*m))           *info = -8;
+  else  if(*ldvt<1 || (*jobz=='A' && *ldvt<*n)
+                   || (*jobz=='S' && *ldvt<diag_size)
+                   || (*jobz=='O' && *m>=*n && *ldvt<*n))         *info = -10;
+  
+  if(*info!=0)
+  {
+    int e = -*info;
+    return xerbla_(SCALAR_SUFFIX_UP"GESDD ", &e, 6);
+  }
+  
+  if(query_size)
+  {
+    *lwork = 0;
+    return 0;
+  }
+  
+  if(*n==0 || *m==0)
+    return 0;
+  
+  PlainMatrixType mat(*m,*n);
+  mat = matrix(a,*m,*n,*lda);
+  
+  int option = *jobz=='A' ? ComputeFullU|ComputeFullV
+             : *jobz=='S' ? ComputeThinU|ComputeThinV
+             : *jobz=='O' ? ComputeThinU|ComputeThinV
+             : 0;
+
+  BDCSVD<PlainMatrixType> svd(mat,option);
+  
+  make_vector(s,diag_size) = svd.singularValues().head(diag_size);
+
+  if(*jobz=='A')
+  {
+    matrix(u,*m,*m,*ldu)   = svd.matrixU();
+    matrix(vt,*n,*n,*ldvt) = svd.matrixV().adjoint();
+  }
+  else if(*jobz=='S')
+  {
+    matrix(u,*m,diag_size,*ldu)   = svd.matrixU();
+    matrix(vt,diag_size,*n,*ldvt) = svd.matrixV().adjoint();
+  }
+  else if(*jobz=='O' && *m>=*n)
+  {
+    matrix(a,*m,*n,*lda)   = svd.matrixU();
+    matrix(vt,*n,*n,*ldvt) = svd.matrixV().adjoint();
+  }
+  else if(*jobz=='O')
+  {
+    matrix(u,*m,*m,*ldu)        = svd.matrixU();
+    matrix(a,diag_size,*n,*lda) = svd.matrixV().adjoint();
+  }
+    
+  return 0;
+}
+
+// computes the singular values/vectors a general M-by-N matrix A using two sided jacobi algorithm
+EIGEN_LAPACK_FUNC(gesvd,(char *jobu, char *jobv, int *m, int* n, Scalar* a, int *lda, RealScalar *s, Scalar *u, int *ldu, Scalar *vt, int *ldvt, Scalar* /*work*/, int* lwork,
+                         EIGEN_LAPACK_ARG_IF_COMPLEX(RealScalar */*rwork*/) int *info))
+{
+  // TODO exploit the work buffer
+  bool query_size = *lwork==-1;
+  int diag_size = (std::min)(*m,*n);
+  
+  *info = 0;
+        if( *jobu!='A' && *jobu!='S' && *jobu!='O' && *jobu!='N') *info = -1;
+  else  if((*jobv!='A' && *jobv!='S' && *jobv!='O' && *jobv!='N')
+           || (*jobu=='O' && *jobv=='O'))                         *info = -2;
+  else  if(*m<0)                                                  *info = -3;
+  else  if(*n<0)                                                  *info = -4;
+  else  if(*lda<std::max(1,*m))                                   *info = -6;
+  else  if(*ldu <1 || ((*jobu=='A' || *jobu=='S') && *ldu<*m))    *info = -9;
+  else  if(*ldvt<1 || (*jobv=='A' && *ldvt<*n)
+                   || (*jobv=='S' && *ldvt<diag_size))            *info = -11;
+  
+  if(*info!=0)
+  {
+    int e = -*info;
+    return xerbla_(SCALAR_SUFFIX_UP"GESVD ", &e, 6);
+  }
+  
+  if(query_size)
+  {
+    *lwork = 0;
+    return 0;
+  }
+  
+  if(*n==0 || *m==0)
+    return 0;
+  
+  PlainMatrixType mat(*m,*n);
+  mat = matrix(a,*m,*n,*lda);
+  
+  int option = (*jobu=='A' ? ComputeFullU : *jobu=='S' || *jobu=='O' ? ComputeThinU : 0)
+             | (*jobv=='A' ? ComputeFullV : *jobv=='S' || *jobv=='O' ? ComputeThinV : 0);
+  
+  JacobiSVD<PlainMatrixType> svd(mat,option);
+  
+  make_vector(s,diag_size) = svd.singularValues().head(diag_size);
+  {
+        if(*jobu=='A') matrix(u,*m,*m,*ldu)           = svd.matrixU();
+  else  if(*jobu=='S') matrix(u,*m,diag_size,*ldu)    = svd.matrixU();
+  else  if(*jobu=='O') matrix(a,*m,diag_size,*lda)    = svd.matrixU();
+  }
+  {
+        if(*jobv=='A') matrix(vt,*n,*n,*ldvt)         = svd.matrixV().adjoint();
+  else  if(*jobv=='S') matrix(vt,diag_size,*n,*ldvt)  = svd.matrixV().adjoint();
+  else  if(*jobv=='O') matrix(a,diag_size,*n,*lda)    = svd.matrixV().adjoint();
+  }
+  return 0;
+}