#include <stdlib.h>
#include <vector>
#include <iostream>
#include <utility>
#include <algorithm>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <cmath>
#include <math.h>
#include <time.h>
#include <float.h>
#include "pba.h"
#include "SparseBundleCPU.h"
#include <pthread.h>
#include <sched.h>
#include <unistd.h>

Include dependency graph for SparseBundleCPU.cpp:

Classes
struct	pba::ProgramCPU::ComputeSAXPY_STRUCT< Float >

struct	pba::ProgramCPU::ComputeSAXPY_FUNCTOR< Float >

struct	pba::ProgramCPU::ComputeVectorNorm_STRUCT< Float >

struct	pba::ProgramCPU::ComputeVectorNorm_FUNCTOR< Float >

struct	pba::ProgramCPU::ComputeProjection_STRUCT< Float >

struct	pba::ProgramCPU::ComputeProjection_FUNCTOR< Float >

struct	pba::ProgramCPU::ComputeProjectionX_STRUCT< Float >

struct	pba::ProgramCPU::ComputeProjectionX_FUNCTOR< Float >

struct	pba::ProgramCPU::ComputeJacobian_STRUCT< Float >

struct	pba::ProgramCPU::ComputeJacobian_FUNCTOR< Float >

struct	pba::ProgramCPU::ComputeDiagonalBlockC_STRUCT< Float >

struct	pba::ProgramCPU::ComputeDiagonalBlockC_FUNCTOR< Float >

struct	pba::ProgramCPU::ComputeDiagonalBlockP_STRUCT< Float >

struct	pba::ProgramCPU::ComputeDiagonalBlockP_FUNCTOR< Float >

struct	pba::ProgramCPU::MultiplyBlockConditionerC_STRUCT< Float >

struct	pba::ProgramCPU::MultiplyBlockConditionerC_FUNCTOR< Float >

struct	pba::ProgramCPU::MultiplyBlockConditionerP_STRUCT< Float >

struct	pba::ProgramCPU::MultiplyBlockConditionerP_FUNCTOR< Float >

struct	pba::ProgramCPU::ComputeJX_STRUCT< Float >

struct	pba::ProgramCPU::ComputeJX_FUNCTOR< Float >

struct	pba::ProgramCPU::ComputeJX__STRUCT< Float >

struct	pba::ProgramCPU::ComputeJX__FUNCTOR< Float >

struct	pba::ProgramCPU::ComputeJtEC_STRUCT< Float >

struct	pba::ProgramCPU::ComputeJtEC_FUNCTOR< Float >

struct	pba::ProgramCPU::ComputeJtEP_STRUCT< Float >

struct	pba::ProgramCPU::ComputeJtEP_FUNCTOR< Float >

struct	pba::ProgramCPU::ComputeJtEC__STRUCT< Float >

struct	pba::ProgramCPU::ComputeJtEC__FUNCTOR< Float >

Namespaces
	pba

	pba::ProgramCPU

Macros
#define	POINT_ALIGN 3

#define	POINT_ALIGN2 (POINT_ALIGN * 2)

#define	THREAD_NUM_MAX 64

#define	AUTO_MT_NUM(sz) int((log((double)sz) / log(2.0) - 18.5) * __num_cpu_cores / 16.0)

#define	DEFINE_THREAD_DATA(X)

#define	DECLEAR_THREAD_DATA(X, ...)

#define	BEGIN_THREAD_PROC(X)

#define	END_THREAD_RPOC(X)

#define	MYTHREAD pthread_t

#define	RUN_THREAD(X, t, ...)

#define	WAIT_THREAD(tv, n)

#define	ALLOCATE_REQUIRED_DATA(NAME, num, channels)

#define	ALLOCATE_OPTIONAL_DATA(NAME, num, channels, option)

#define	PROFILE_REPORT2(A, T) std::cout << std::setw(24) << A << ": " << (T) << "\n";

#define	PROFILE_REPORT(A)

#define	PROFILE_(B)

#define	PROFILE(A, B) PROFILE_(A B) PROFILE_REPORT(#A)

#define	PROXILE(A, B) PROFILE_(B) PROFILE_REPORT(A)

#define	PROTILE(FID, A, B)

#define	PROTILE2(FID1, FID2, A, B)

Functions
template<class Float >
double	pba::ProgramCPU::ComputeVectorNorm (const avec< Float > &vec, int mt=0)

template<class Float >
void	pba::ProgramCPU::ComputeSQRT (avec< Float > &vec)

template<class Float >
void	pba::ProgramCPU::ComputeRSQRT (avec< Float > &vec)

template<class Float >
void	pba::ProgramCPU::SetVectorZero (Float p, Float pe)

template<class Float >
void	pba::ProgramCPU::SetVectorZero (avec< Float > &vec)

template<class Float >
void	pba::ProgramCPU::MemoryCopyA (const Float p, const Float pe, Float *d)

template<class Float >
double	pba::ProgramCPU::ComputeVectorNormW (const avec< Float > &vec, const avec< Float > &weight)

template<class Float >
double	pba::ProgramCPU::ComputeVectorDot (const avec< Float > &vec1, const avec< Float > &vec2)

template<class Float >
void	pba::ProgramCPU::ComputeVectorNorm (const Float p, const Float pe, double *psum)

template<class Float >
void	pba::ProgramCPU::ComputeVXY (const avec< Float > &vec1, const avec< Float > &vec2, avec< Float > &result, size_t part=0, size_t skip=0)

template<class Float >
void	pba::ProgramCPU::ScaleJ8 (Float jcx, Float jcy, const Float *sj)

template<class Float >
void	pba::ProgramCPU::AddScaledVec8 (Float a, const Float x, Float v)

template<class Float >
void	pba::ProgramCPU::ComputeSAX (Float a, const avec< Float > &vec1, avec< Float > &result)

template<class Float >
void	pba::ProgramCPU::ComputeSXYPZ (Float a, const Float p1, const Float p2, const Float p3, Float p4, Float *pe)

template<class Float >
void	pba::ProgramCPU::ComputeSAXPY (Float a, const Float it1, const Float it2, Float it3, Float ite)

template<class Float >
void	pba::ProgramCPU::AddBlockJtJ (const Float jc, Float block, int vn)

template<class Float >
void	pba::ProgramCPU::MemoryCopyB (const Float p, const Float pe, Float *d)

template<class Float >
Float	pba::ProgramCPU::DotProduct8 (const Float v1, const Float v2)

template<class Float >
void	pba::ProgramCPU::ComputeTwoJX (const Float jc, const Float jp, const Float xc, const Float xp, Float *jx)

template<class Float >
Float	pba::ProgramCPU::ComputeVectorMax (const avec< Float > &vec)

template<class Float >
void	pba::ProgramCPU::ComputeSXYPZ (Float a, const avec< Float > &vec1, const avec< Float > &vec2, const avec< Float > &vec3, avec< Float > &result)

template<class Float >
void *	pba::ProgramCPU::ComputeSAXPY_PROC (ComputeSAXPY_STRUCT< Float > *q)

template<class Float >
void	pba::ProgramCPU::ComputeSAXPY (Float a, const avec< Float > &vec1, const avec< Float > &vec2, avec< Float > &result, int mt=0)

template<class Float >
void *	pba::ProgramCPU::ComputeVectorNorm_PROC (ComputeVectorNorm_STRUCT< Float > *q)

template<class Float >
void	pba::ProgramCPU::GetRodriguesRotation (const Float m[3][3], Float r[3])

template<class Float >
void	pba::ProgramCPU::UncompressRodriguesRotation (const Float r[3], Float m[])

template<class Float >
void	pba::ProgramCPU::UpdateCamera (int ncam, const avec< Float > &camera, const avec< Float > &delta, avec< Float > &new_camera)

template<class Float >
void	pba::ProgramCPU::UpdateCameraPoint (int ncam, const avec< Float > &camera, const avec< Float > &point, avec< Float > &delta, avec< Float > &new_camera, avec< Float > &new_point, int mode, int mt)

template<class Float >
void	pba::ProgramCPU::ComputeProjection (size_t nproj, const Float camera, const Float point, const Float ms, const int jmap, Float *pj, int radial, int mt)

template<class Float >
void *	pba::ProgramCPU::ComputeProjection_PROC (ComputeProjection_STRUCT< Float > *q)

template<class Float >
void	pba::ProgramCPU::ComputeProjectionX (size_t nproj, const Float camera, const Float point, const Float ms, const int jmap, Float *pj, int radial, int mt)

template<class Float >
void *	pba::ProgramCPU::ComputeProjectionX_PROC (ComputeProjectionX_STRUCT< Float > *q)

template<class Float >
void	pba::ProgramCPU::ComputeProjectionQ (size_t nq, const Float camera, const int qmap, const Float wq, Float pj)

template<class Float >
void	pba::ProgramCPU::ComputeJQX (size_t nq, const Float x, const int qmap, const Float wq, const Float sj, Float *jx)

template<class Float >
void	pba::ProgramCPU::ComputeJQtEC (size_t ncam, const Float pe, const int qlist, const Float wq, const Float sj, Float *v)

template<class Float >
void	pba::ProgramCPU::JacobianOne (const Float c, const Float pt, const Float ms, Float jxc, Float jyc, Float jxp, Float *jyp, bool intrinsic_fixed, int radial_distortion)

template<class Float >
void	pba::ProgramCPU::ComputeJacobian (size_t nproj, size_t ncam, const Float camera, const Float point, Float jc, Float jp, const int jmap, const Float sj, const Float ms, const int cmlist, bool intrinsic_fixed, int radial_distortion, bool shuffle, Float *jct, int mt=2, int i0=0)

template<class Float >
void *	pba::ProgramCPU::ComputeJacobian_PROC (ComputeJacobian_STRUCT< Float > *q)

template<class Float >
void	pba::ProgramCPU::ComputeDiagonalAddQ (size_t ncam, const Float qw, Float d, const Float *sj=NULL)

template<class Float >
void	pba::ProgramCPU::ComputeDiagonal (const avec< Float > &jcv, const vector< int > &cmapv, const avec< Float > &jpv, const vector< int > &pmapv, const vector< int > &cmlistv, const Float *qw0, avec< Float > &jtjdi, bool jc_transpose, int radial)

template<class T , int n, int m>
void	pba::ProgramCPU::InvertSymmetricMatrix (T a[n][m], T ai[n][m])

template<class T , int n, int m>
void	pba::ProgramCPU::InvertSymmetricMatrix (T a, T ai)

template<class Float >
void	pba::ProgramCPU::ComputeDiagonalBlockC (size_t ncam, float lambda1, float lambda2, const Float jc, const int cmap, const int cmlist, Float di, Float *bi, int vn, bool jc_transpose, bool use_jq, int mt)

template<class Float >
void *	pba::ProgramCPU::ComputeDiagonalBlockC_PROC (ComputeDiagonalBlockC_STRUCT< Float > *q)

template<class Float >
void	pba::ProgramCPU::ComputeDiagonalBlockP (size_t npt, float lambda1, float lambda2, const Float jp, const int pmap, Float di, Float bi, int mt)

template<class Float >
void *	pba::ProgramCPU::ComputeDiagonalBlockP_PROC (ComputeDiagonalBlockP_STRUCT< Float > *q)

template<class Float >
void	pba::ProgramCPU::ComputeDiagonalBlock (size_t ncam, size_t npts, float lambda, bool dampd, const Float jc, const int cmap, const Float jp, const int pmap, const int cmlist, const Float sj, const Float wq, Float diag, Float *blocks, int radial_distortion, bool jc_transpose, int mt1=2, int mt2=2, int mode=0)

template<class Float >
void	pba::ProgramCPU::ComputeDiagonalBlock_ (float lambda, bool dampd, const avec< Float > &camerav, const avec< Float > &pointv, const avec< Float > &meas, const vector< int > &jmapv, const avec< Float > &sjv, avec< Float > &qwv, avec< Float > &diag, avec< Float > &blocks, bool intrinsic_fixed, int radial_distortion, int mode=0)

template<class Float >
void	pba::ProgramCPU::MultiplyBlockConditionerC (int ncam, const Float bi, const Float x, Float *vx, int vn, int mt=0)

template<class Float >
void *	pba::ProgramCPU::MultiplyBlockConditionerC_PROC (MultiplyBlockConditionerC_STRUCT< Float > *q)

template<class Float >
void	pba::ProgramCPU::MultiplyBlockConditionerP (int npoint, const Float bi, const Float x, Float *vx, int mt=0)

template<class Float >
void *	pba::ProgramCPU::MultiplyBlockConditionerP_PROC (MultiplyBlockConditionerP_STRUCT< Float > *q)

template<class Float >
void	pba::ProgramCPU::MultiplyBlockConditioner (int ncam, int npoint, const Float blocksv, const Float vec, Float *resultv, int radial, int mode, int mt1, int mt2)

template<class Float >
void	pba::ProgramCPU::ComputeJX (size_t nproj, size_t ncam, const Float x, const Float jc, const Float jp, const int jmap, Float *jx, int mode, int mt=2)

template<class Float >
void *	pba::ProgramCPU::ComputeJX_PROC (ComputeJX_STRUCT< Float > *q)

template<class Float >
void	pba::ProgramCPU::ComputeJX_ (size_t nproj, size_t ncam, const Float x, Float jx, const Float camera, const Float point, const Float ms, const Float sj, const int *jmap, bool intrinsic_fixed, int radial_distortion, int mode, int mt=16)

template<class Float >
void *	pba::ProgramCPU::ComputeJX__PROC (ComputeJX__STRUCT< Float > *q)

template<class Float >
void	pba::ProgramCPU::ComputeJtEC (size_t ncam, const Float pe, const Float jc, const int cmap, const int cmlist, Float *v, bool jc_transpose, int mt)

template<class Float >
void *	pba::ProgramCPU::ComputeJtEC_PROC (ComputeJtEC_STRUCT< Float > *q)

template<class Float >
void	pba::ProgramCPU::ComputeJtEP (size_t npt, const Float pe, const Float jp, const int pmap, Float v, int mt)

template<class Float >
void *	pba::ProgramCPU::ComputeJtEP_PROC (ComputeJtEP_STRUCT< Float > *q)

template<class Float >
void	pba::ProgramCPU::ComputeJtE (size_t ncam, size_t npt, const Float pe, const Float jc, const int cmap, const int cmlist, const Float jp, const int pmap, Float *v, bool jc_transpose, int mode, int mt1, int mt2)

template<class Float >
void	pba::ProgramCPU::ComputeJtEC_ (size_t ncam, const Float ee, Float jte, const Float c, const Float point, const Float ms, const int jmap, const int cmap, const int cmlist, bool intrinsic_fixed, int radial_distortion, int mt)

template<class Float >
void *	pba::ProgramCPU::ComputeJtEC__PROC (ComputeJtEC__STRUCT< Float > *q)

template<class Float >
void	pba::ProgramCPU::ComputeJtE_ (size_t nproj, size_t ncam, size_t npt, const Float ee, Float jte, const Float camera, const Float point, const Float ms, const int jmap, const int cmap, const int cmlist, const int pmap, const Float jp, bool intrinsic_fixed, int radial_distortion, int mode, int mt)

template<class Float >
void	pba::ProgramCPU::ComputeJtE_ (size_t nproj, size_t ncam, size_t npt, const Float ee, Float jte, const Float camera, const Float point, const Float ms, const int jmap, bool intrinsic_fixed, int radial_distortion, int mode)

ParallelBA *	pba::NewSparseBundleCPU (bool dp, const int num_threads)

Variables
int	pba::ProgramCPU::__num_cpu_cores = 0

Macro Definition Documentation

◆ ALLOCATE_OPTIONAL_DATA

#define ALLOCATE_OPTIONAL_DATA	(	NAME,
		num,
		channels,
		option
	)

Value:

  if (option) ALLOCATE_REQUIRED_DATA(NAME, num, channels) else { \
      NAME.resize(0);                                            \
    }

Definition at line 2736 of file SparseBundleCPU.cpp.

◆ ALLOCATE_REQUIRED_DATA

#define ALLOCATE_REQUIRED_DATA	(	NAME,
		num,
		channels
	)

Value:

  {                                                 \
    NAME.resize((num) * (channels));                \
    total_sz += NAME.size() * sizeof(Float);        \
  }

Definition at line 2731 of file SparseBundleCPU.cpp.

◆ AUTO_MT_NUM

#define AUTO_MT_NUM ( sz ) int((log((double)sz) / log(2.0) - 18.5) * __num_cpu_cores / 16.0)

Definition at line 92 of file SparseBundleCPU.cpp.

◆ BEGIN_THREAD_PROC

#define BEGIN_THREAD_PROC ( X )

Value:

  }                          \
  ;                          \
  template <class Float>     \
  void* X##_PROC(X##_STRUCT<Float>* q) {

Definition at line 910 of file SparseBundleCPU.cpp.

◆ DECLEAR_THREAD_DATA

#define DECLEAR_THREAD_DATA	(	X,
		...
	)

Value:

X##_STRUCT<Float> tdata = {i, __VA_ARGS__}; \

X##_STRUCT<Float>* newdata = new X##_STRUCT<Float>(tdata)

Definition at line 907 of file SparseBundleCPU.cpp.

◆ DEFINE_THREAD_DATA

#define DEFINE_THREAD_DATA ( X )

Value:

  template <class Float>      \
  struct X##_STRUCT {         \
    int tid;

Definition at line 903 of file SparseBundleCPU.cpp.

◆ END_THREAD_RPOC

#define END_THREAD_RPOC ( X )

Value:

  delete q;                                               \
  return 0;                                               \
  }                                                       \
  template <class Float>                                  \
  struct X##_FUNCTOR {                                    \
    typedef void* (*func_type)(X##_STRUCT<Float>*);       \
    static func_type get() { return &(X##_PROC<Float>); } \
  };

Definition at line 921 of file SparseBundleCPU.cpp.

◆ MYTHREAD

#define MYTHREAD pthread_t

Definition at line 930 of file SparseBundleCPU.cpp.

◆ POINT_ALIGN

#define POINT_ALIGN 3

Definition at line 73 of file SparseBundleCPU.cpp.

◆ POINT_ALIGN2

#define POINT_ALIGN2 (POINT_ALIGN * 2)

Definition at line 76 of file SparseBundleCPU.cpp.

◆ PROFILE

#define PROFILE	(	A,
		B
	)	PROFILE_(A B) PROFILE_REPORT(#A)

Definition at line 4117 of file SparseBundleCPU.cpp.

◆ PROFILE_

#define PROFILE_ ( B )

Value:

  BundleTimerStart(TIMER_PROFILE_STEP); \
  for (int i = 0; i < repeat; ++i) {    \
    B;                                  \
  }                                     \
  BundleTimerSwitch(TIMER_PROFILE_STEP);

Definition at line 4110 of file SparseBundleCPU.cpp.

◆ PROFILE_REPORT

#define PROFILE_REPORT ( A )

Value:

std::cout << std::setw(24) << A << ": " \

<< (BundleTimerGet(TIMER_PROFILE_STEP) / repeat) << "\n";

Definition at line 4106 of file SparseBundleCPU.cpp.

◆ PROFILE_REPORT2

#define PROFILE_REPORT2	(	A,
		T
	)	std::cout << std::setw(24) << A << ": " << (T) << "\n";

Definition at line 4103 of file SparseBundleCPU.cpp.

◆ PROTILE

#define PROTILE	(	FID,
		A,
		B
	)

Value:

  {                                                          \
    float tbest = FLT_MAX;                                   \
    int nbest = 1;                                           \
    int nto = nthread[FID];                                  \
    {                                                        \
      std::ostringstream os1;                                \
      os1 << #A "(" << nto << ")";                           \
      PROXILE(os1.str(), A B);                               \
    }                                                        \
    for (int j = 1; j <= THREAD_NUM_MAX; j *= 2) {           \
      nthread[FID] = j;                                      \
      PROFILE_(A B);                                         \
      float t = BundleTimerGet(TIMER_PROFILE_STEP) / repeat; \
      if (t > tbest) {                                       \
        if (j >= max(nto, 16)) break;                        \
      } else {                                               \
        tbest = t;                                           \
        nbest = j;                                           \
      }                                                      \
    }                                                        \
    if (nto != 0) nthread[FID] = nbest;                      \
    {                                                        \
      std::ostringstream os;                                 \
      os << #A "(" << nbest << ")";                          \
      PROFILE_REPORT2(os.str(), tbest);                      \
    }                                                        \
  }

Definition at line 4119 of file SparseBundleCPU.cpp.

◆ PROTILE2

#define PROTILE2	(	FID1,
		FID2,
		A,
		B
	)

Definition at line 4148 of file SparseBundleCPU.cpp.

◆ PROXILE

#define PROXILE	(	A,
		B
	)	PROFILE_(B) PROFILE_REPORT(A)

Definition at line 4118 of file SparseBundleCPU.cpp.

◆ RUN_THREAD

#define RUN_THREAD	(	X,
		t,
		...
	)

Value:

DECLEAR_THREAD_DATA(X, __VA_ARGS__); \

pthread_create(&t, NULL, (void* (*)(void*))X##_FUNCTOR<Float>::get(), newdata)

DECLEAR_THREAD_DATA

#define DECLEAR_THREAD_DATA(X,...)

Definition: SparseBundleCPU.cpp:907

NULL

#define NULL

Definition: UVUnwrapping.cpp:40

Definition at line 932 of file SparseBundleCPU.cpp.

◆ THREAD_NUM_MAX

#define THREAD_NUM_MAX 64

Definition at line 90 of file SparseBundleCPU.cpp.

◆ WAIT_THREAD

#define WAIT_THREAD	(	tv,
		n
	)

Value:

  {                                                                   \
    for (size_t i = 0; i < size_t(n); ++i) pthread_join(tv[i], NULL); \
  }

Definition at line 935 of file SparseBundleCPU.cpp.

Classes

Namespaces

Macros

Functions

Variables

Macro Definition Documentation

◆ ALLOCATE_OPTIONAL_DATA

◆ ALLOCATE_REQUIRED_DATA

◆ AUTO_MT_NUM

◆ BEGIN_THREAD_PROC

◆ DECLEAR_THREAD_DATA

◆ DEFINE_THREAD_DATA

◆ END_THREAD_RPOC

◆ MYTHREAD

◆ POINT_ALIGN

◆ POINT_ALIGN2

◆ PROFILE

◆ PROFILE_

◆ PROFILE_REPORT

◆ PROFILE_REPORT2

◆ PROTILE

◆ PROTILE2

◆ PROXILE

◆ RUN_THREAD

◆ THREAD_NUM_MAX

◆ WAIT_THREAD