/*===========================================================================*/
int main( void )
{
/* The maximum number of interations and the tolerance can be set for the
* eigen value decompostion (QR method or Power method) by using the
* following static functions. The folowing set values are default.
*
* kvs::EigenDecomposer<double>::SetMaxIterations( 1000 );
* kvs::EigenDecomposer<double>::SetMaxTolerance( 1.0e-10 );
*/
// Case 1: Symmetric matrix
{
/* For symmetric matrix, the QR method is used for the calculation
* of the eigen values and vectors. The matrix M has three
* eigenvalues (Li) and three eigenvectors (Ei for Li).
*
* L0 = 1.944, E0 = (0.519, 0.637, 0.570)
* L1 = 0.707, E1 = (0.787, -0.096, -0.609)
* L2 = 0.349, E2 = (0.333, -0.765, 0.551)
*/
kvs::Matrix<double> M( 3, 3 );
M[0][0] = 1.0; M[0][1] = 0.5; M[0][2] = 0.3;
M[1][0] = 0.5; M[1][1] = 1.0; M[1][2] = 0.6;
M[2][0] = 0.3; M[2][1] = 0.6; M[2][2] = 1.0;
kvs::EigenDecomposer<double> eigen( M );
Print( M, eigen );
}
// Case 2: Asymmetric matrix
{
/* For asymmetric matrix, the Power method is used for the calculation
* of the eigen values and vectors. The matrix M has three
* eigenvalues (Li) and three eigenvectors (Ei for Li).
*
* L0 = 11.464, E0 = (0.146, -0.509, 0.848)
* L1 = 4.536, E1 = (0.658, -0.681, -0.322)
* L2 = -4.000, E2 = (0.577, -0.577, -0.577)
*/
kvs::Matrix<double> M( 3, 3 );
M[0][0] = 1.0; M[0][1] = 2.0; M[0][2] = 3.0;
M[1][0] = 3.0; M[1][1] = 4.0; M[1][2] = -5.0;
M[2][0] = 5.0; M[2][1] = -6.0; M[2][2] = 7.0;
kvs::EigenDecomposer<double> eigen( M );
Print( M, eigen );
}
}
OBBRSS BVFitter<OBBRSS>::fit(unsigned int* primitive_indices, int num_primitives)
{
OBBRSS bv;
Matrix3f M;
Vec3f E[3];
Matrix3f::U s[3];
getCovariance(vertices, prev_vertices, tri_indices, primitive_indices, num_primitives, M);
eigen(M, s, E);
axisFromEigen(E, s, bv.obb.axis);
bv.rss.axis[0] = bv.obb.axis[0];
bv.rss.axis[1] = bv.obb.axis[1];
bv.rss.axis[2] = bv.obb.axis[2];
getExtentAndCenter(vertices, prev_vertices, tri_indices, primitive_indices, num_primitives, bv.obb.axis, bv.obb.To, bv.obb.extent);
Vec3f origin;
FCL_REAL l[2];
FCL_REAL r;
getRadiusAndOriginAndRectangleSize(vertices, prev_vertices, tri_indices, primitive_indices, num_primitives, bv.rss.axis, origin, l, r);
bv.rss.Tr = origin;
bv.rss.l[0] = l[0];
bv.rss.l[1] = l[1];
bv.rss.r = r;
return bv;
}
float ImgPatch::cornerValue()
{
cv::Mat dx, dy;
cv::Sobel(cleanedPatch, dx, CV_32F, 1, 0, 1);
cv::Sobel(cleanedPatch, dy, CV_32F, 0, 1, 1);
cv::Mat removeBorderDx = dx(cv::Rect(1, 1, dx.cols-2, dx.rows-2)).clone();
cv::Mat removeBorderDy = dy(cv::Rect(1, 1, dy.cols-2, dy.rows-2)).clone();
cv::Mat IX2 = removeBorderDx.mul(removeBorderDx);
cv::Mat IY2 = removeBorderDy.mul(removeBorderDy);
cv::Mat IXY = removeBorderDx.mul(removeBorderDy);
cv::Mat_<float> A = cv::Mat::zeros(2,2,CV_32F);
A[0][0] = sum(IX2).val[0];
A[0][1] = sum(IXY).val[0];
A[1][0] = sum(IXY).val[0];
A[1][1] = sum(IY2).val[0];
cv::Mat eigenA;
eigen(A, eigenA);
//For half_patch_size = 4, we get the number "6"
if ((eigenA.at<float>(1,0) >= 6)&&(eigenA.at<float>(1,0)/eigenA.at<float>(0,0)>0.5))
{
return eigenA.at<float>(1,0);
}
else
{
return 0.0f;
}
}
void silent_fixpt(double *x,double eps,double err,double big,int maxit,int n,
double *er,double *em,int *ierr)
{
int kmem,i,j;
double *work,*eval,*b,*bp,*oldwork,*ework;
double temp,old_x[MAXODE];
kmem=n*(2*n+5)+50;
*ierr=0;
if((work=(double *)malloc(sizeof(double)*kmem))==NULL)
{
err_msg("Insufficient core ");
*ierr=1;
return;
}
for(i=0;i<n;i++)old_x[i]=x[i];
oldwork=work+n*n;
eval=oldwork+n*n;
b=eval+2*n;
bp=b+n;
ework=bp+n;
rooter(x,err,eps,big,work,ierr,maxit,n);
if(*ierr!=0)
{
free(work);
for(i=0;i<n;i++)x[i]=old_x[i];
return;
}
for(i=0;i<n*n;i++){
oldwork[i]=work[i];
}
/* Transpose for Eigen */
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
temp=work[i+j*n];
work[i+j*n]=work[i*n+j];
work[i*n+j]=temp;
}
}
eigen(n,work,eval,ework,ierr);
if(*ierr!=0)
{
free(work);
return;
}
for(i=0;i<n;i++)
{
er[i]=eval[2*i];
em[i]=eval[2*i+1];
}
} /* end silent fixed point */
RSS BVFitter<RSS>::fit(unsigned int* primitive_indices, int num_primitives)
{
RSS bv;
Matrix3f M; // row first matrix
Vec3f E[3]; // row first eigen-vectors
Matrix3f::U s[3]; // three eigen values
getCovariance(vertices, prev_vertices, tri_indices, primitive_indices, num_primitives, M);
eigen(M, s, E);
axisFromEigen(E, s, bv.axis);
// set rss origin, rectangle size and radius
Vec3f origin;
FCL_REAL l[2];
FCL_REAL r;
getRadiusAndOriginAndRectangleSize(vertices, prev_vertices, tri_indices, primitive_indices, num_primitives, bv.axis, origin, l, r);
bv.Tr = origin;
bv.l[0] = l[0];
bv.l[1] = l[1];
bv.r = r;
return bv;
}
void Component::fitEllipse() {
// find mean or center
ctr=Point2f(0,0);
for(auto pt: members) {
ctr.x+=pt.x;
ctr.y+=pt.y;
}
if (size()<=5) return;
ctr.x/=size(); ctr.y/=size();
// find covariance
cov=Mat::zeros(2,2,CV_32FC1);
for(auto pt: members) {
cov.at<float>(0,0)+=(pt.x-ctr.x)*(pt.x-ctr.x);
cov.at<float>(0,1)+=(pt.x-ctr.x)*(pt.y-ctr.y);
cov.at<float>(1,1)+=(pt.y-ctr.y)*(pt.y-ctr.y);
}
cov.at<float>(1,0)=cov.at<float>(0,1);
cov/=(size()-1);
// compute eigen-values,-vectors
Mat eigen_values,eigen_vectors;
eigen(cov,eigen_values,eigen_vectors);
a=2.4477*sqrt(eigen_values.at<float>(0));
b=2.4477*sqrt(eigen_values.at<float>(1));
phi=atan2(eigen_vectors.at<float>(1,0),eigen_vectors.at<float>(0,0));
if (cov.at<float>(0,0)>cov.at<float>(1,1)) phi*=-1;
phi=fmod(phi+2*M_PI,M_PI);
}
Matrix &Matrix::eigenSystem()
{
Matrix *values;
assertDefined("eigenSystem");
assertSquare("eigenSystem");
values = new Matrix(1, maxc); // allocates space for eigen values
{
double *d, *e;
tridiagonalize(d, e); // allocates space for 2 double arrays
eigen(d, e, maxc, m); // returns eigen values in d
delete values->m[0]; // save the eigen values from above routines
values->m[0] = d;
delete e;
}
transposeSelf(); // result was returned in columns so put it in rows
isort(values->m[0], m, maxc); // sort rows so vector with max eigenvalue is first
values->defined = true; // mark eigen value matrix as defined
return *values;
}
void main()
{
double sum,s,c,r;
int i,j,k,n;
scanf("%d",&n);
double w[MAX], v[MAX], q[MAX];
double tridiagonal[MAX][MAX];
tridiagonal[0][0]=1.0;
for (i = 1;i<=n;i++)
for (j=1;j<=n;j++)
scanf("%lf",&tridiagonal[i][j]);
for (k=1;k<=n-2;k++)
{
sum = 0;
for (j = k+1; j <= n; j++)
sum += tridiagonal[j][k] * tridiagonal[j][k];
s=sqrt(sum);
if ( tridiagonal[k+1][k] < 0 )
s=-s;
r = sqrt( 2.0 * tridiagonal[k+1][k] * s + 2.0 * s * s );
for (j = 1; j <= k; j++)
w[j] = 0.0;
w[k+1] = ( tridiagonal[k+1][k] + s ) / r;
for (j=k+2;j<=n;j++)
w[j] = tridiagonal[j][k] / r;
for (i=1;i<=k;i++)
v[i] = 0.0;
for (i = k+1; i <= n; i++)
{
sum = 0.0;
for (j = k+1; j <= n; j++)
sum += tridiagonal[i][j] * w[j];
v[i] = sum;
}
c = 0;
for (j = k+1; j <= n; j++)
c += w[j] * v[j];
for (j = 1; j <= k; j++)
q[j] = 0.0;
for (j = k+1; j <= n; j++)
q[j] = v[j] - c * w[j];
for (j=k+2;j<=n;j++)
tridiagonal[j][k] = tridiagonal[k][j] = 0.0;
tridiagonal[k+1][k] = tridiagonal[k][k+1] = -s;
for (j = k; j <= n; j++)
tridiagonal[j][j] -= 4.0 * q[j] * w[j];
for (i = k+1; i <= n; i++)
{
for (j = i+1; j <= n; j++)
{
tridiagonal[i][j] = tridiagonal[i][j] - 2.0 * w[i] * q[j] - 2.0 * q[i] * w[j];
tridiagonal[j][i] = tridiagonal[i][j];
}
}
}
print(tridiagonal, n);
householder(tridiagonal,n);
eigen(tridiagonal,n);
}
PView *GMSH_Lambda2Plugin::execute(PView *v)
{
int ev = (int)Lambda2Options_Number[0].def;
int iView = (int)Lambda2Options_Number[1].def;
PView *v1 = getView(iView, v);
if(!v1) return v;
PViewDataList *data1 = getDataList(v1);
if(!data1) return v;
PView *v2 = new PView();
PViewDataList *data2 = getDataList(v2);
if(!data2) return v;
// assume that the tensors contain the velocity gradient tensor
int nts = data1->getNumTimeSteps();
eigen(data1->TP, data1->NbTP, data2->SP, &data2->NbSP, nts, 1, 9, ev);
eigen(data1->TL, data1->NbTL, data2->SL, &data2->NbSL, nts, 2, 9, ev);
eigen(data1->TT, data1->NbTT, data2->ST, &data2->NbST, nts, 3, 9, ev);
eigen(data1->TQ, data1->NbTQ, data2->SQ, &data2->NbSQ, nts, 4, 9, ev);
eigen(data1->TS, data1->NbTS, data2->SS, &data2->NbSS, nts, 4, 9, ev);
eigen(data1->TH, data1->NbTH, data2->SH, &data2->NbSH, nts, 8, 9, ev);
eigen(data1->TI, data1->NbTI, data2->SI, &data2->NbSI, nts, 6, 9, ev);
eigen(data1->TY, data1->NbTY, data2->SY, &data2->NbSY, nts, 5, 9, ev);
// assume that the vectors contain the velocities
// FIXME: only implemented for tri/tet at the moment
// eigen(data1->VP, data1->NbVP, data2->SP, &data2->NbSP, nts, 1, 3, ev);
// eigen(data1->VL, data1->NbVL, data2->SL, &data2->NbSL, nts, 2, 3, ev);
eigen(data1->VT, data1->NbVT, data2->ST, &data2->NbST, nts, 3, 3, ev);
// eigen(data1->VQ, data1->NbVQ, data2->SQ, &data2->NbSQ, nts, 4, 3, ev);
eigen(data1->VS, data1->NbVS, data2->SS, &data2->NbSS, nts, 4, 3, ev);
// eigen(data1->VH, data1->NbVH, data2->SH, &data2->NbSH, nts, 8, 3, ev);
// eigen(data1->VI, data1->NbVI, data2->SI, &data2->NbSI, nts, 6, 3, ev);
// eigen(data1->VY, data1->NbVY, data2->SY, &data2->NbSY, nts, 5, 3, ev);
data2->Time = data1->Time;
data2->setName(data1->getName() + "_Lambda2");
data2->setFileName(data1->getName() + "_Lambda2.pos");
data2->finalize();
return v2;
}
cv::Mat PCA_FilterBank(vector<cv::Mat>& InImg, int PatchSize, int NumFilters){
int channels = InImg[0].channels();
int InImg_Size = InImg.size();
int* randIdx = getRandom(InImg_Size);
int size = channels * PatchSize * PatchSize;
int img_depth = InImg[0].depth();
cv::Mat Rx = cv::Mat::zeros(size, size, img_depth);
vector<int> blockSize;
vector<int> stepSize;
for(int i=0; i<2; i++){
blockSize.push_back(PatchSize);
stepSize.push_back(1);
}
cv::Mat temp;
cv::Mat mean;
cv::Mat temp2;
cv::Mat temp3;
int coreNum = omp_get_num_procs();//»ñµÃŽŠÀíÆ÷žöÊý
int cols = 0;
# pragma omp parallel for default(none) num_threads(coreNum) private(temp, temp2, temp3, mean) shared(cols, Rx, InImg_Size, InImg, randIdx, blockSize, stepSize)
for(int j=0; j<InImg_Size; j++){
temp = im2col_general(InImg[randIdx[j]], blockSize, stepSize);
cv::reduce(temp, mean, 0, CV_REDUCE_AVG);
temp3.create(0, temp.cols, temp.type());
cols = temp.cols;
for(int i=0;i<temp.rows;i++){
temp2 = (temp.row(i) - mean.row(0));
temp3.push_back(temp2.row(0));
}
temp = temp3 * temp3.t();
# pragma omp critical
Rx = Rx + temp;
}
Rx = Rx / (double)(InImg_Size * cols);
cv::Mat eValuesMat;
cv::Mat eVectorsMat;
eigen(Rx, eValuesMat, eVectorsMat);
cv::Mat Filters(0, Rx.cols, Rx.depth());
for(int i=0; i<NumFilters; i++)
Filters.push_back(eVectorsMat.row(i));
return Filters;
}
// Split the raw image into channels and store in Eigen Matrices.
std::vector<Eigen::MatrixXf> imread(const string& path) {
cv::Mat mat = cv::imread(path);
std::vector<cv::Mat> rgb;
cv::split(mat, rgb);
std::vector<Eigen::MatrixXf> eigen(rgb.size());
for (int i = 0; i < mat.channels(); ++i) {
cv2eigen(rgb[i], eigen[i]);
}
return eigen;
}
void extract_init(struct SigSet *S)
{
int m;
int i;
int b1, b2;
int nbands;
double *lambda;
struct ClassSig *C;
struct SubSig *SubS;
nbands = S->nbands;
/* allocate scratch memory */
lambda = (double *)G_malloc(nbands * sizeof(double));
/* invert matrix and compute constant for each subclass */
/* for each class */
for (m = 0; m < S->nclasses; m++) {
C = &(S->ClassSig[m]);
/* for each subclass */
for (i = 0; i < C->nsubclasses; i++) {
SubS = &(C->SubSig[i]);
/* Test for symetric matrix */
for (b1 = 0; b1 < nbands; b1++)
for (b2 = 0; b2 < nbands; b2++) {
if (SubS->R[b1][b2] != SubS->R[b2][b1])
G_warning(_("Nonsymetric covariance for class %d subclass %d"),
m + 1, i + 1);
SubS->Rinv[b1][b2] = SubS->R[b1][b2];
}
/* Test for positive definite matrix */
eigen(SubS->Rinv, NULL, lambda, nbands);
for (b1 = 0; b1 < nbands; b1++) {
if (lambda[b1] <= 0.0)
G_warning(_("Nonpositive eigenvalues for class %d subclass %d"),
m + 1, i + 1);
}
/* Precomputes the cnst */
SubS->cnst = (-nbands / 2.0) * log(2 * PI);
for (b1 = 0; b1 < nbands; b1++) {
SubS->cnst += -0.5 * log(lambda[b1]);
}
/* Precomputes the inverse of tex->R */
invert(SubS->Rinv, nbands);
}
}
G_free((char *)lambda);
}
static void EigsOfSymMat(
MAT& eigvecs, // out: one row per eigvec
MAT& eigvals, // out: sorted
const MAT& mat, // in: not modified
bool fix_signs=true) // in: see FixEigSigns
{
CV_DbgAssert(IsSymmetric(mat, cv::trace(mat)[0] / double(1e16)));
eigen(mat, eigvals, eigvecs);
if (fix_signs)
FixEigSigns(eigvecs);
}
void fitn(Vec3f* ps, int n, OBB& bv)
{
Matrix3f M;
Vec3f E[3];
Matrix3f::U s[3] = {0, 0, 0}; // three eigen values
getCovariance(ps, NULL, NULL, NULL, n, M);
eigen(M, s, E);
axisFromEigen(E, s, bv.axis);
// set obb centers and extensions
getExtentAndCenter(ps, NULL, NULL, NULL, n, bv.axis, bv.To, bv.extent);
}
void fitn(Vec3f* ps, int n, RSS& bv)
{
Matrix3f M; // row first matrix
Vec3f E[3]; // row first eigen-vectors
Matrix3f::U s[3] = {0, 0, 0};
getCovariance(ps, NULL, NULL, NULL, n, M);
eigen(M, s, E);
axisFromEigen(E, s, bv.axis);
// set rss origin, rectangle size and radius
getRadiusAndOriginAndRectangleSize(ps, NULL, NULL, NULL, n, bv.axis, bv.Tr, bv.l, bv.r);
}
///
/// Check if a matrix is positive definite.
///
bool Utils::isPosDef(TMatrixDSym* c)
{
TMatrixDSymEigen eigen(*c);
TVectorD eigenvalues = eigen.GetEigenValues();
Double_t minEigenVal = eigenvalues[0];
for ( int k=0; k<c->GetNcols(); k++ ) minEigenVal = TMath::Min(minEigenVal, eigenvalues[k]);
if ( minEigenVal<0 )
{
cout << "isPosDef() : ERROR : Matrix not pos. def." << endl;
return 0;
}
return 1;
}
Vector rmvn_robust_mt(RNG &rng, const Vector &mu, const SpdMatrix &V) {
uint n = V.nrow();
Matrix eigenvectors(n, n);
Vector eigenvalues = eigen(V, eigenvectors);
for (uint i = 0; i < n; ++i) {
// We're guaranteed that eigenvalues[i] is real and non-negative. We
// can take the absolute value of eigenvalues[i] to guard against
// spurious negative numbers close to zero.
eigenvalues[i] = sqrt(fabs(eigenvalues[i])) * rnorm_mt(rng, 0, 1);
}
Vector ans(eigenvectors * eigenvalues);
ans += mu;
return ans;
}
int jacobi(double a[MX][MX], long n, double d[MX], double v[MX][MX])
{
double *aa[MX], *vv[MX], *dd;
int i;
for (i = 0; i < n; i++) {
aa[i] = &a[i + 1][1];
vv[i] = &v[i + 1][1];
}
dd = &d[1];
eigen(aa, vv, dd, n);
return 0;
}
// Fit a gussian and extract the parameters from it
void FeatureGaborBlob::computeParams(){
int nsamples = _blob.rows * _blob.cols ;
Mat samples(nsamples, 3, CV_64F);
Mat cov(3,3,CV_64F);
Mat mean(3,3,CV_64F);
Mat value(3,3, CV_64F);
Mat vects(3,3, CV_64F);
setSamples(samples);
calcCovarMatrix(samples, cov, mean, CV_COVAR_NORMAL|CV_COVAR_ROWS);
eigen(cov, value, vects);
_majorDirection = Point2f((float)vects.at<double>(0,0), (float)vects.at<double>(0,1)) ;
_minorDirection = Point2f((float)vects.at<double>(1,0), (float)vects.at<double>(1,1)) ;
setVolume() ;
}
void Contour::setOrientation(){
// Copy points to mat ;
Mat pts = getMat(_points);
Mat cov(2, 2, CV_64F);
Mat mean(2, 2, CV_64F);
Mat value(2, 2, CV_64F);
Mat vects(2, 2, CV_64F);
calcCovarMatrix(pts, cov, mean, CV_COVAR_NORMAL | CV_COVAR_ROWS);
eigen(cov, value, vects);
_orientation.first = Point2f(vects.at<float>(0, 0), vects.at<float>(0, 1));
_orientation.second = Point2f(vects.at<float>(1, 0), vects.at<float>(1, 1));
//_orientation.first = Point2d(vects.at<double>(0,0), vects.at<double>(0,1)) * sqrt(value.at<double>(0,0));
//_orientation.second = Point2d(vects.at<double>(1,0), vects.at<double>(1,1)) * sqrt(value.at<double>(1,0));
//cout << "First: "<< _orientation.first << " Second: " << _orientation.second << endl ;
}
void getKPCs(double *Ktild, double *Kscaled, double *E, double *KPC, int *Nrow, int *Nred ) //Ktild is scaled kernel
{
int i,j;
eigen(Ktild, E, *Nrow); //Ktild is now a matrix of eigenvectors
for(i=0;i<*Nred;i++)for(j=0;j<*Nrow;j++)Ktild[i* *Nrow+j]=Ktild[i* *Nrow+j]/sqrt(E[i]/ *Nrow);
j=0; // creates KPC
for(i=0;i<*Nred;i++){
matrix_by_vectorM(Kscaled, &Ktild[i* *Nrow], &KPC[j], *Nrow, *Nrow, *Nred);
++j;
}
}
void SetupAAMatrix()
{
int i,j,k;
double mr;
double sum;
double U[SQNUM_AA], V[SQNUM_AA], T1[SQNUM_AA], T2[SQNUM_AA];
k=0;
for (i=0; i<NUM_AA-1; i++) {
for (j=i+1; j<NUM_AA; j++) {
Qij[i*NUM_AA+j] = Qij[j*NUM_AA+i] = aaRelativeRate[k++];
}
}
for (i=0; i<NUM_AA; i++) {
for (j=0; j<NUM_AA; j++) {
Qij[i*NUM_AA+j] *= aaFreq[j];
}
}
mr=0;
for (i=0; i<NUM_AA; i++) {
sum = 0;
Qij[i*NUM_AA+i]=0;
for (j=0; j<NUM_AA; j++) {
sum += Qij[i*NUM_AA+j];
}
Qij[i*NUM_AA+i] = -sum;
mr += aaFreq[i] * sum;
}
abyx(1.0/mr, Qij, SQNUM_AA);
if ((k=eigen(1, Qij, NUM_AA, Root, T1, U, V, T2))!=0) {
fprintf(stderr, "\ncomplex roots in SetupAAMatrix");
exit(EXIT_FAILURE);
}
xtoy (U, V, SQNUM_AA);
matinv (V, NUM_AA, NUM_AA, T1);
for (i=0; i<NUM_AA; i++) {
for (j=0; j<NUM_AA; j++) {
for (k=0; k<NUM_AA; k++) {
Cijk[i*SQNUM_AA+j*NUM_AA+k] = U[i*NUM_AA+k]*V[k*NUM_AA+j];
}
}
}
}
void Machine::train() {
// Get data from json.
CvSize sz = cvGetSize(cvLoadImage(_imgPatterns.begin()->second[0].c_str()));
_imgSize = sz.width * sz.height;
_nbImgs = 0;
for (auto const &pattern : _imgPatterns)
_nbImgs += pattern.second.size();
// Initialize cv materials.
cv::Mat sum = cv::Mat::zeros(_imgSize, 1, CV_32FC1);
cv::Mat matrix(_imgSize, _nbImgs, CV_32FC1);
std::size_t offset = 0;
// Compute sum and matrix from images data.
for (auto const &pattern : _imgPatterns) {
for (std::string const &path : pattern.second) {
LOG_INFO << "[" << offset << "] [" << pattern.first << "] "
<< path << LOG_ENDL;
cv::Mat m = cvLoadImageM(path.c_str(), CV_LOAD_IMAGE_GRAYSCALE);
m = m.t();
m = m.reshape(1, _imgSize);
m.convertTo(m, CV_32FC1);
m.copyTo(matrix.col(offset));
sum = sum + m;
++offset;
}
}
// Compute eigen vectors from the images sum.
cv::Mat mean = sum / float(_nbImgs);
cv::Mat crossMatrix = cv::Mat(_imgSize, _nbImgs, CV_32FC1);
for (std::size_t i = 0; i < _nbImgs; ++i)
crossMatrix.col(i) = matrix.col(i) - mean;
cv::Mat cMatrix = crossMatrix.t() * crossMatrix;
cv::Mat vMatrix, lMatrix;
eigen(cMatrix, lMatrix, vMatrix);
// Compute projection matrix.
cv::Mat uMatrix = crossMatrix * vMatrix;
_projectionMatrix = uMatrix.t();
// project the training set to the faces space
_trainSet = _projectionMatrix * crossMatrix;
}
/// @brief OBB merge method when the centers of two smaller OBB are far away
inline OBB merge_largedist(const OBB& b1, const OBB& b2)
{
OBB b;
Vec3f vertex[16];
computeVertices(b1, vertex);
computeVertices(b2, vertex + 8);
Matrix3f M;
Vec3f E[3];
Matrix3f::U s[3] = {0, 0, 0};
// obb axes
Vec3f& R0 = b.axis[0];
Vec3f& R1 = b.axis[1];
Vec3f& R2 = b.axis[2];
R0 = b1.To - b2.To;
R0.normalize();
Vec3f vertex_proj[16];
for(int i = 0; i < 16; ++i)
vertex_proj[i] = vertex[i] - R0 * vertex[i].dot(R0);
getCovariance(vertex_proj, NULL, NULL, NULL, 16, M);
eigen(M, s, E);
int min, mid, max;
if (s[0] > s[1]) { max = 0; min = 1; }
else { min = 0; max = 1; }
if (s[2] < s[min]) { mid = min; min = 2; }
else if (s[2] > s[max]) { mid = max; max = 2; }
else { mid = 2; }
R1.setValue(E[0][max], E[1][max], E[2][max]);
R2.setValue(E[0][mid], E[1][mid], E[2][mid]);
// set obb centers and extensions
Vec3f center, extent;
getExtentAndCenter(vertex, NULL, NULL, NULL, 16, b.axis, center, extent);
b.To = center;
b.extent = extent;
return b;
}
OBB BVFitter<OBB>::fit(unsigned int* primitive_indices, int num_primitives)
{
OBB bv;
Matrix3f M; // row first matrix
Vec3f E[3]; // row first eigen-vectors
Matrix3f::U s[3]; // three eigen values
getCovariance(vertices, prev_vertices, tri_indices, primitive_indices, num_primitives, M);
eigen(M, s, E);
axisFromEigen(E, s, bv.axis);
// set obb centers and extensions
getExtentAndCenter(vertices, prev_vertices, tri_indices, primitive_indices, num_primitives, bv.axis, bv.To, bv.extent);
return bv;
}
void MatrixMxN<Scalar>::eigenDecomposition(VectorND<Scalar> &eigen_values_real, VectorND<Scalar> &eigen_values_imag,
MatrixMxN<Scalar> &eigen_vectors_real, MatrixMxN<Scalar> &eigen_vectors_imag)
{
unsigned int rows = this->rows(), cols = this->cols();
if(rows != cols)
{
std::cerr<<"Eigen decomposition is only valid for square matrix!\n";
std::exit(EXIT_FAILURE);
}
#ifdef PHYSIKA_USE_EIGEN_MATRIX
//hack: Eigen::EigenSolver does not support integer types, hence we cast Scalar to long double for decomposition
Eigen::Matrix<long double,Eigen::Dynamic,Eigen::Dynamic> temp_matrix(rows,cols);
for(unsigned int i = 0; i < rows; ++i)
for(unsigned int j = 0; j < cols; ++j)
temp_matrix(i,j) = static_cast<long double>((*ptr_eigen_matrix_MxN_)(i,j));
Eigen::EigenSolver<Eigen::Matrix<long double,Eigen::Dynamic,Eigen::Dynamic> > eigen(temp_matrix);
Eigen::Matrix<std::complex<long double>,Eigen::Dynamic,Eigen::Dynamic> vectors = eigen.eigenvectors();
const Eigen::Matrix<std::complex<long double>,Eigen::Dynamic,1> &values = eigen.eigenvalues();
//resize if have to
if(eigen_vectors_real.rows() != vectors.rows() || eigen_vectors_real.cols() != vectors.cols())
eigen_vectors_real.resize(vectors.rows(),vectors.cols());
if(eigen_vectors_imag.rows() != vectors.rows() || eigen_vectors_imag.cols() != vectors.cols())
eigen_vectors_imag.resize(vectors.rows(),vectors.cols());
if(eigen_values_real.dims() != values.rows())
eigen_values_real.resize(values.rows());
if(eigen_values_imag.dims() != values.rows())
eigen_values_imag.resize(values.rows());
//copy the result
for(unsigned int i = 0; i < vectors.rows(); ++i)
for(unsigned int j = 0; j < vectors.cols(); ++j)
{
eigen_vectors_real(i,j) = static_cast<Scalar>(vectors(i,j).real());
eigen_vectors_imag(i,j) = static_cast<Scalar>(vectors(i,j).imag());
}
for(unsigned int i = 0; i < values.rows(); ++i)
{
eigen_values_real[i] = static_cast<Scalar>(values(i,0).real());
eigen_values_imag[i] = static_cast<Scalar>(values(i,0).imag());
}
#elif defined(PHYSIKA_USE_BUILT_IN_MATRIX)
std::cerr<<"Eigen decomposition not implemeted for built in matrix!\n";
std::exit(EXIT_FAILURE);
#endif
}
void LocalGeometryRef::SVD(int num_eigen)
{
vnl_symmetric_eigensystem<double> eigen(this->probability_matrix);
vnl_matrix<double> eig_vec = eigen.V;
vnl_diag_matrix<double> eig_val = eigen.D;
vnl_vector<double> temp_vec(this->num_row);
for(int row = 0; row<eig_val.rows(); row++)
{
temp_vec(row) = eig_val(row,row);
}
this->eigVals.set_size(num_eigen);
this->eigVecs.set_size(this->num_row, num_eigen);
for(int i=0; i<num_eigen; i++)
{
this->eigVals(i) = temp_vec.max_value();
int pos = temp_vec.arg_max();
temp_vec(pos) = temp_vec.min_value() - 1;
this->eigVecs.set_column(i, eig_vec.get_column(pos) * this->eigVals(i) );
}
//output files for debugging
FILE *fp1 = fopen("eigenvecters.txt","w");
for(int i=0; i<this->num_row; i++)
{
for(int j=0; j<num_eigen; j++)
{
fprintf(fp1,"%f\t",this->eigVecs(i, j));
}
fprintf(fp1,"\n");
}
fclose(fp1);
FILE *fp2 = fopen("eigenvalues.txt","w");
for(int i=0; i<num_eigen; i++)
{
fprintf(fp2,"%f\t",this->eigVals(i));
std::cout<<this->eigVals(i)<<std::endl;
fprintf(fp2,"\n");
}
fclose(fp2);
}
int main() {
int testCount = 1;
int p = 1;
int low = -10;
int high = 10;
int fails = 0;
double eps = 1e-8;
for (int n = 2; n <= pow(2, p); n *= 2) {
for (int i = 0; i < testCount; i++) {
Mat_DP A(n, n);
Vec_CPLX_DP eigens(n);
ranmat2(A, low, high);
eigen(A, eigens);
if(testSum(&A, &eigens, eps)){
fails++;
cout << "FAIL! n = " << n << endl;
}
}
}
}
void makeEigenfaces(vector<Mat> meanIms, Mat meanOfAll)
{
// since it is a gray image, just need to consider one channel (since R = G = B for gray)
// 1. Do PCA (principle component analysis) by computing eigenfaces:
// - get difference of warped-to-mean individual images from mean image
// - put into one long vector, getting M number of long vectors (M is number of images)
// - Let A = (R*C)xM-matrix, where R*C is row * col size of the image
// - compute covariance matrix C by A' * A (getting MxM-matrix), and calculate the eigenvectors and eigenvalues
// - reverse eigenvectors from one long vector back to RxC-matrix, giving eigenface
int numMeanIms = static_cast<int>(meanIms.size());
cout << "numMeanIms: " << numMeanIms << endl;
int R = meanIms[0].rows, C = meanIms[0].cols;
int RC = R*C;
Mat A(RC, numMeanIms, CV_32F, Scalar(0));
// Cov = Covariance matrix
// Cov = A'*A, where A is made up of the long vectors (not A*A' since that matrix will be too big)
Mat Cov;
int i = 0, j = 0, d = 0;
for (int k = 0; k < numMeanIms; k++)
{
Mat cur = meanIms[k];
Mat diff = meanOfAll - cur;
stringstream ss;
ss << k;
string ns = ss.str();
string name(ns+"_diff.jpg");
imshow(name, diff);
imwrite(name, diff);
for (int r = 0; r < RC; r++)
{
i = r/C;
j = r - i*C;
d = diff.at<Vec3b>(i,j)[0];
A.at<float>(r, k) = d;
}
}
Mat At = A.t();
cout << "A:r,c: " << A.rows << ", " << A.cols << endl;
cout << "At:r,c: " << At.rows << ", " << At.cols << endl;
Cov = At * A;
//cout << Cov << endl;
//waitKey();
Mat eigenvalues, eigenvectors;
eigen(Cov, eigenvalues, eigenvectors);
// eigen() gives back the eigenvectors in this order: from largest eigenvalue to smallest eigenvalue
// eigenvectors should be normalized, and in range -1 to 1
cout << "EIGENVECTORS\n" << eigenvectors << "\nEIGENVALUES:\n" << eigenvalues << endl;
//waitKey();
// we have the eigenvectors of A'*A.
// to get the eigenvectors of A*A', which are the eigenfaces,
// A * eigenVector
Mat allEigenfaces = A * eigenvectors.t(); // eigenvectors.t() for opencv's sake (eigenvectors in rows)
Mat eigenBoss = allEigenfaces;
// recover eigenfaces
vector<Mat> eigenfaces;
Mat blank = meanIms[0].clone();
for (int i = 0; i < blank.rows; i++)
for (int j = 0; j < blank.cols; j++)
blank.at<Vec3b>(i,j) = Vec3b(0,0,0);
for (int k = 0; k < numMeanIms; k++)
{
Mat cur = blank.clone();
for (int r = 0; r < RC; r++)
{
i = r/C;
j = r - i*C;
int c = 0;
float t = eigenBoss.at<float>(r,k);
if (t != 0.)
c = (t+1.)*255./2.;
if (c > 255) c = 255; // clamp values
if (c < 0) c = 0;
cur.at<Vec3b>(i, j) = Vec3b(c,c,c);
}
eigenfaces.push_back(cur);
}
// show and write all eigenfaces
for (int k = 0; k < eigenfaces.size(); k++)
{
stringstream ss;
ss << k;
string ns = ss.str();
string name(ns+"_ef.jpg");
imshow(name, eigenfaces[k]);
imwrite(name, eigenfaces[k]);
}
cout << "Finished making eigenfaces. Press ANY key to continue... " << endl;
waitKey();
}
CV_EXPORTS int computeNormalsPC3d(const Mat& PC, Mat& PCNormals, const int NumNeighbors, const bool FlipViewpoint, const Vec3d& viewpoint)
{
int i;
if (PC.cols!=3 && PC.cols!=6) // 3d data is expected
{
//return -1;
CV_Error(cv::Error::BadImageSize, "PC should have 3 or 6 elements in its columns");
}
int sizes[2] = {PC.rows, 3};
int sizesResult[2] = {PC.rows, NumNeighbors};
float* dataset = new float[PC.rows*3];
float* distances = new float[PC.rows*NumNeighbors];
int* indices = new int[PC.rows*NumNeighbors];
for (i=0; i<PC.rows; i++)
{
const float* src = PC.ptr<float>(i);
float* dst = (float*)(&dataset[i*3]);
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
}
Mat PCInput(2, sizes, CV_32F, dataset, 0);
void* flannIndex = indexPCFlann(PCInput);
Mat Indices(2, sizesResult, CV_32S, indices, 0);
Mat Distances(2, sizesResult, CV_32F, distances, 0);
queryPCFlann(flannIndex, PCInput, Indices, Distances, NumNeighbors);
destroyFlann(flannIndex);
flannIndex = 0;
PCNormals = Mat(PC.rows, 6, CV_32F);
for (i=0; i<PC.rows; i++)
{
double C[3][3], mu[4];
const float* pci = &dataset[i*3];
float* pcr = PCNormals.ptr<float>(i);
double nr[3];
int* indLocal = &indices[i*NumNeighbors];
// compute covariance matrix
meanCovLocalPCInd(dataset, indLocal, 3, NumNeighbors, C, mu);
// eigenvectors of covariance matrix
Mat cov(3, 3, CV_64F), eigVect, eigVal;
double* covData = (double*)cov.data;
covData[0] = C[0][0];
covData[1] = C[0][1];
covData[2] = C[0][2];
covData[3] = C[1][0];
covData[4] = C[1][1];
covData[5] = C[1][2];
covData[6] = C[2][0];
covData[7] = C[2][1];
covData[8] = C[2][2];
eigen(cov, eigVal, eigVect);
Mat lowestEigVec;
//the eigenvector for the lowest eigenvalue is in the last row
eigVect.row(eigVect.rows - 1).copyTo(lowestEigVec);
double* eigData = (double*)lowestEigVec.data;
nr[0] = eigData[0];
nr[1] = eigData[1];
nr[2] = eigData[2];
pcr[0] = pci[0];
pcr[1] = pci[1];
pcr[2] = pci[2];
if (FlipViewpoint)
{
flipNormalViewpoint(pci, viewpoint[0], viewpoint[1], viewpoint[2], &nr[0], &nr[1], &nr[2]);
}
pcr[3] = (float)nr[0];
pcr[4] = (float)nr[1];
pcr[5] = (float)nr[2];
}
delete[] indices;
delete[] distances;
delete[] dataset;
return 1;
}
