/* *@param descriptors: The descriptors of a block */ ImageImPro* HOGDetectorGPU::drawBlockHOG(vector<float> descriptors, cv::HOGDescriptor hog){ int numHistograms = descriptors.size() / hog.nbins; cout << "Num histograms: " << numHistograms << endl; vector<float> normalized = normalize(descriptors); ImageImPro* ptrImage = NULL; int cellsPerRow = hog.blockSize.height / hog.cellSize.height; int cellsPerCol = hog.blockSize.width / hog.cellSize.width; int pixPerCellX = 32; int pixPerCellY = 32; ImSize size(cellsPerCol * pixPerCellY, cellsPerRow * pixPerCellX); ImageImPro* ptrTemp = new ImageImPro_OpenCvImpl( size, ImageImPro_OpenCvImpl::BIT_8_U, 1); Mat* ptrHistImage = ptrTemp->getMat(); delete ptrTemp; int currHist = 0; for(int row = 0; row < cellsPerRow; ++row){ for(int col = 0; col < cellsPerCol; ++col){ vector <float> cellHistogram = getHistogramFromBlockDescriptor(normalized, currHist++, numHistograms, hog.nbins); cout << "Current histogram: " << currHist << endl; cv::Mat* ptrMat = getHistogramImage(cellHistogram); copyMat(*ptrHistImage, *ptrMat, row * pixPerCellX, col * pixPerCellY); delete ptrMat; } } ptrImage = new ImageImPro_OpenCvImpl(ptrHistImage); return ptrImage; }
void aPow(int p, double a[SIZE][SIZE], double x[SIZE][SIZE], int n) { double b[SIZE][SIZE]; if (p < 0) { printf("aPow: Error!\n"); } else if (p == 0) { unitMat(x, n); } else { copyMat(a, x, n); /* x <- a */ while (p > 1) { prod(a, x, b, n); copyMat(b, x, n); p--; } } }
void mulMat(unsigned long long int A[3][3], unsigned long long int B[3][3],int n) { int x, y, k; unsigned long long int tmp[3][3] = {0}; for (y = 0; y < n; y++) { for (k = 0; k < n; k++) { for (x = 0; x < n; x++) { tmp[y][k] = (tmp[y][k] + (A[y][x] * B[x][k]) % MOD) % MOD; } } } copyMat(tmp,A,n); }
static PyObject* convert(const MatType& mat) { typedef typename MatType::Scalar T; PyArrayObject* python_array; if( MatType::ColsAtCompileTime==1 || MatType::RowsAtCompileTime==1 ) { npy_intp shape[1] = { mat.rows()*mat.cols() }; python_array = PyArrayObject_New(1, shape, NumpyEquivalentType<T>::type_code); } else { npy_intp shape[2] = { mat.rows(), mat.cols() }; python_array = PyArrayObject_New(2, shape, NumpyEquivalentType<T>::type_code); } copyMat( (T*)PyArray_DATA(python_array), mat.data(), mat.rows(), mat.cols(), !(MatType::Flags & RowMajor) ); return (PyObject*)python_array; }
// Use as a subfilter for Smooth void ac::ImageRandomValues(cv::Mat &frame) { if(blend_set == false) return; cv::Mat reimage; int r_x = rand()%(frame.cols-1); int r_y = rand()%(frame.rows-1); if(r_x < 10) r_x = 10; if(r_y < 10) r_y = 10; cv::Size size_val(r_x, r_y); cv::resize(blend_image, reimage, size_val); copyMat(frame, reimage); AddInvert(frame); }
/* Algorithm taken from Matrix Algorithms Vol. II by G.W. Stewart. This function takes a vector A of order n and reduces it to Hessenberg form by Householder transformations. In the future it may be possible to remove H entirely and do the transformation in place. A is an n*n matrix that I am transforming H is an n*n matrix where I will put the result Q is an n*n matrix where I will accumulate the transformations u is a vector of length n for scratch work. vH is another vector of length n for scratch work */ void hessreduce(Complex *A, Complex *H, Complex *Q, Complex *u, Complex *vH, int n) { int k, i, j, l; Complex tmp; if(n < 2) return; //Reduce A //H = A copyMat(A,H,n,n); //3. for k = 1 to n-2 for(k = 0; k < n-2; k++) { //Generate the Transformation //housegen(H[k+1:n,k],u,H[k+1,k]) housegen(&INDEX(H,n,(k+1),k),u+k+1,&INDEX(H,n,(k+1),k),n-k-1); //5. Q[k+1:n,k] = u copyVect(u+k+1, &INDEX(Q, n, (k+1), k), n-k-1); //Premultiply the transformation //6. vH = uH*H[k+1:n,k+1:n] for(i = k+1; i < n; i++) { vH[i].real = 0.0; vH[i].imag = 0.0; for(j = k+1; j < n; j++) { tmp = INDEX(H,n,j,i); vH[i].real += u[j].real * tmp.real; vH[i].real += u[j].imag * tmp.imag;//minus minus for hermitian vH[i].imag += u[j].real * tmp.imag; vH[i].imag -= u[j].imag * tmp.real;//minus sign is for hermitian } } //7. H[k+1:n,k+1:n] = H[k+1:n, k+1:n] - u*vH for(i = k+1; i < n; i++) { for(j = k+1; j < n; j++) { INDEX(H,n,i,j).real -= u[i].real *vH[j].real; INDEX(H,n,i,j).real += u[i].imag *vH[j].imag; INDEX(H,n,i,j).imag -= u[i].real *vH[j].imag; INDEX(H,n,i,j).imag -= u[i].imag *vH[j].real; } } //H[k+2:n,k] = 0 for(i = k+2; i < n; i++) { INDEX(H,n,i,k).real = 0.0; INDEX(H,n,i,k).imag = 0.0; } //Postmultiply the transformation //9. v = H[1:n, k+1:n]*u //I will use the variable vH for v (for space). for(i = 0; i < n; i++) { vH[i].real = 0.0; vH[i].imag = 0.0; for(j = k+1; j < n; j++) { tmp = INDEX(H,n,i,j); vH[i].real += tmp.real * u[j].real; vH[i].real -= tmp.imag * u[j].imag; vH[i].imag += tmp.real * u[j].imag; vH[i].imag += tmp.imag * u[j].real; } } //10. H[1:n, k+1:n] = H[1:n,k+1:n] - v*uH for(i = 0; i < n; i++) { for(j = k+1; j < n; j++) { INDEX(H,n,i,j).real -= vH[i].real * u[j].real; INDEX(H,n,i,j).real -= vH[i].imag * u[j].imag; INDEX(H,n,i,j).imag += vH[i].real * u[j].imag; INDEX(H,n,i,j).imag -= vH[i].imag * u[j].real; } } }//end k //Accumulate the Transformations //12. Q[:,n] = e_n; Q[:,n-1] = e_(n-1) for(i = 0; i < n; i++) { INDEX(Q,n,i,(n-1)).real = 0.0; INDEX(Q,n,i,(n-1)).imag = 0.0; INDEX(Q,n,i,(n-2)).real = 0.0; INDEX(Q,n,i,(n-2)).imag = 0.0; } INDEX(Q,n,(n-1),(n-1)).real = 1.0; INDEX(Q,n,(n-2),(n-2)).real = 1.0; //13. for k = n-2 to 1 by -1 for(k = n-3; k >= 0; k--) { //14. u = Q[k+1:n,k] copyVect(&INDEX(Q,n,(k+1),k), u+k+1, n-(k+1)); //15. vH = uH*Q[k+1:n,k+1:n]//Q[k+1:n,k] = u for(i = k+1; i < n; i++) { vH[i].real = 0.0; vH[i].imag = 0.0; for(j = k+1; j < n; j++) { tmp.real = u[j].real; tmp.imag = -u[j].imag; tmp = complexMult(tmp, INDEX(Q, n, j, i)); vH[i].real += tmp.real; vH[i].imag += tmp.imag; } } //16. Q[k+1:n, k+1:n] = Q[k+1:n, k+1:n] -u*vH for(i = k+1; i < n; i++) { for(j = k+1; j < n; j++) { tmp = complexMult(u[i],vH[j]); INDEX(Q,n,i,j).real -= tmp.real; INDEX(Q,n,i,j).imag -= tmp.imag; } } //17. Q[:,k] = e_k for(i = 0; i < n; i++) { INDEX(Q,n,i,k).real = 0.0; INDEX(Q,n,i,k).imag = 0.0; } INDEX(Q,n,k,k).real = 1.0; }// 18. end for k }//end hessreduce