/*===========================================================================*/ 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; }