void QuickHarrisDetector::writeHarrisImagesAsPPM(image::ConvexRoi & roi) { FILE *pFile_x = fopen("/home/jsola/im_x.ppm", "w"); FILE *pFile_y = fopen("/home/jsola/im_y.ppm", "w"); FILE *pFile_xx = fopen("/home/jsola/im_xx.ppm", "w"); FILE *pFile_xy = fopen("/home/jsola/im_xy.ppm", "w"); FILE *pFile_yy = fopen("/home/jsola/im_yy.ppm", "w"); FILE *pFile_min = fopen("/home/jsola/im_min.ppm", "w"); FILE *pFile_max = fopen("/home/jsola/im_max.ppm", "w"); HQuickData * ptr = m_quickData; if (pFile_x != NULL) { fprintf(pFile_x, "P2\n%d %d\n255\n", roi.w(), roi.h()); fprintf(pFile_y, "P2\n%d %d\n255\n", roi.w(), roi.h()); fprintf(pFile_xx, "P2\n%d %d\n255\n", roi.w(), roi.h()); fprintf(pFile_xy, "P2\n%d %d\n255\n", roi.w(), roi.h()); fprintf(pFile_yy, "P2\n%d %d\n255\n", roi.w(), roi.h()); fprintf(pFile_min, "P2\n%d %d\n255\n", roi.w(), roi.h()); fprintf(pFile_max, "P2\n%d %d\n255\n", roi.w(), roi.h()); for (int i = 0; i < (roi.h() * roi.w()); i++) { fprintf(pFile_x, "%d ", 128 + (ptr->im_x) / 2); fprintf(pFile_y, "%d ", 128 + (ptr->im_y) / 2); fprintf(pFile_xx, "%d ", 128 + (ptr->im_conv_xx) / 2048); fprintf(pFile_xy, "%d ", 128 + (ptr->im_conv_xy) / 2048); fprintf(pFile_yy, "%d ", 128 + (ptr->im_conv_yy) / 2048); fprintf(pFile_min, "%d ", (unsigned char) (ptr->im_low_curv / 1024)); fprintf(pFile_max, "%d ", (unsigned char) (ptr->im_high_curv / 2048)); ptr++; } fclose(pFile_x); fclose(pFile_y); fclose(pFile_xx); fclose(pFile_xy); fclose(pFile_yy); } }
void ActiveSearchGrid::cell2roi(const veci2 & cell, image::ConvexRoi & roi) { veci2 ul = cellOrigin(cell); ul(0) += separation; ul(1) += separation; veci2 s = cellSize; s(0) -= 2 * separation; s(1) -= 2 * separation; roi.init(cv::Rect(ul(0),ul(1),s(0),s(1))); }
void ActiveSearchGrid::setFailed(const image::ConvexRoi & roi) { vec2 p; p(0) = roi.x()+roi.w()/2; p(1) = roi.y()+roi.h()/2; veci2 cell = pix2cell(p); projectionsCount(cell(0), cell(1)) = -1; }
bool QuickHarrisDetector::quickConvolutionWithBestPoint( const image::ConvexRoi & roi, int pixMax[2], float & scoreMax) { int shift_derv = 1; int shift_derv_conv = shift_derv + shift_conv; // bounds int riMin = shift_derv_conv; int riMax = roi.h() - shift_derv_conv; int rjMin = shift_derv_conv; int rjMax = roi.w() - shift_derv_conv; // data structure pointers HQuickData* int_center; #if GAUSSIAN_MASK_APPROX #else HQuickData* int_upLeft; HQuickData* int_upRight; HQuickData* int_downLeft; HQuickData* int_downRight; #endif float im_low_curv_max = 0.; // maximum smallest eigenvalue float im_high_curv_max = 0.; int sm, df; // sum and difference float sr, corner_ratio; int ri, rj; // roi coordinates for (ri = riMin; ri < riMax; ri++) { int_center = m_quickData + (ri * roi.w()) + rjMin; #if GAUSSIAN_MASK_APPROX for(int i = 0; i < nConvCoeffs; ++i) { int_upLeft[i] = int_center - (shift_convs[i] * (roi.w()+1)); int_upRight[i] = int_center - (shift_convs[i] * (roi.w()-1)); int_downLeft[i] = int_center + (shift_convs[i] * (roi.w()-1)); int_downRight[i] = int_center + (shift_convs[i] * (roi.w()+1)); } #else int_upLeft = int_center - (shift_conv * roi.w()) - shift_conv; int_upRight = int_center - (shift_conv * roi.w()) + shift_conv; int_downLeft = int_center + (shift_conv * roi.w()) - shift_conv; int_downRight = int_center + (shift_conv * roi.w()) + shift_conv; #endif for (rj = rjMin; rj < rjMax; rj++) { #if GAUSSIAN_MASK_APPROX int_center->im_conv_xx = int_center->im_conv_xy = int_center->im_conv_yy = 0.; for(int i = 0; i < nConvCoeffs; ++i) { int_center->im_conv_xx += convCoeffs[i]*( int_downRight[i]->int_xx - int_upRight[i]->int_xx - int_downLeft[i]->int_xx + int_upLeft[i]->int_xx); int_center->im_conv_xy += convCoeffs[i]*( int_downRight[i]->int_xy - int_upRight[i]->int_xy - int_downLeft[i]->int_xy + int_upLeft[i]->int_xy); int_center->im_conv_yy += convCoeffs[i]*( int_downRight[i]->int_yy - int_upRight[i]->int_yy - int_downLeft[i]->int_yy + int_upLeft[i]->int_yy); } if (nConvCoeffsCenter) { int_center->im_conv_xx += convCoeffs[nConvCoeffs]*int_center->im_xx; int_center->im_conv_xy += convCoeffs[nConvCoeffs]*int_center->im_xy; int_center->im_conv_yy += convCoeffs[nConvCoeffs]*int_center->im_yy; } #else int_center->im_conv_xx = int_downRight->int_xx - int_upRight->int_xx - int_downLeft->int_xx + int_upLeft->int_xx; int_center->im_conv_xy = int_downRight->int_xy - int_upRight->int_xy - int_downLeft->int_xy + int_upLeft->int_xy; int_center->im_conv_yy = int_downRight->int_yy - int_upRight->int_yy - int_downLeft->int_yy + int_upLeft->int_yy; #endif // get eigenvalues: EIG/eig = I_xx + I_yy +/- sqrt((Ixx - I_yy)^2 + 4*I_xy^2) sm = int_center->im_conv_xx + int_center->im_conv_yy; df = int_center->im_conv_xx - int_center->im_conv_yy; sr = sqrt((double) ((double) df * (double) df + 4 * ((double) int_center->im_conv_xy) * ((double) int_center->im_conv_xy))); int_center->im_high_curv = (double) sm + sr; // Smallest eigenvalue. int_center->im_low_curv = (double) sm - sr; // Largest eigenvalue. // detect and write pixel corresponding to strongest corner, with score. #ifndef JFR_NDEBUG if (int_center->im_low_curv == 0.0) corner_ratio = 1e10; else #endif corner_ratio = int_center->im_high_curv / int_center->im_low_curv; // CAUTION should be high/low if (corner_ratio < m_edge) { if (int_center->im_low_curv > im_low_curv_max) { im_low_curv_max = int_center->im_low_curv; im_high_curv_max = int_center->im_high_curv; pixMax[0] = roi.x() + rj; pixMax[1] = roi.y() + ri; } } int_center++; #if GAUSSIAN_MASK_APPROX for(int i = 0; i < nConvCoeffs; ++i) { int_upLeft[i]++; int_upRight[i]++; int_downLeft[i]++; int_downRight[i]++; } #else int_upLeft++; int_upRight++; int_downLeft++; int_downRight++; #endif } } // normalized score: over the size of the derivative and convolution windows scoreMax = sqrt(im_low_curv_max / normCoeff); //std::cout << "- at " << pixMax[0] << "," << pixMax[1] << " : high " << im_high_curv_max << " low " << im_low_curv_max << " ; ratio " << im_high_curv_max/im_low_curv_max << " score " << scoreMax << std::endl; #if FILTER_VIRTUAL_POINTS /* accept: _|_ (4) |_ _/ _ (2) _ _ _ (1 or 2) | \ \ / reject: |_ (3) . (0) | */ int_center = m_quickData + ((pixMax[1]-roi.y()) * roi.w()) + (pixMax[0]-roi.x()); int indexes[8][2] = {{-1,-1},{-1,0},{-1,1},{0,1},{1,1},{1,0},{1,-1},{0,-1}}; int radius = m_convolutionSize/2; for(int i = 0; i < 8; ++i) for(int j = 0; j < 2; ++j) indexes[i][j] *= radius; double thres = im_low_curv_max * 0.75; int npeaks = 0; bool lastpeaked = false; bool firstpeaked = false; for(int i = 0; i < 8; ++i) { int_upLeft = int_center + indexes[i][1] * roi.w() + indexes[i][0]; if (int_upLeft->im_high_curv > thres) { if (i == 0) firstpeaked = true; else if (i == 7) lastpeaked = lastpeaked || firstpeaked; if (!lastpeaked) npeaks++; lastpeaked = true; } else lastpeaked = false; std::cout << " high " << int_upLeft->im_high_curv << " " << " low " << int_upLeft->im_low_curv << std::endl; } bool ok = (npeaks == 1 || npeaks == 2 || npeaks == 4); std::cout << " high " << int_center->im_high_curv << " low " << int_center->im_low_curv << " npeaks " << npeaks << " ok " << ok << std::endl; #endif return (scoreMax > m_threshold); }
void QuickHarrisDetector::quickDerivatives( const jafar::image::Image & image, image::ConvexRoi & roi) { const uchar* pix_center; const uchar* pix_right; const uchar* pix_left; const uchar* pix_down; const uchar* pix_up; HQuickData* int_center; HQuickData* int_up; HQuickData* int_upLeft; HQuickData* int_left; // dead zone due to derivative mask [-1 0 1] int shift_derv = 1; // = (3-1)/2 // i: vert; j: horz image coordinates int iMin = roi.y() + shift_derv; int iMax = roi.y() + roi.h() - shift_derv; // FIXME take into account possible convex part of roi x(i) and w(i) by moving this into the loop int jMin = roi.x() + shift_derv; int jMax = roi.x() + roi.w() - shift_derv; int i, j; // i, j: image coordinates int ri; // ri: vertical roi coordinate for (i = iMin; i < iMax; i++) { ri = i - roi.y(); pix_center = image.data() + (i * image.step()) + jMin; pix_right = pix_center + 1; pix_left = pix_center - 1; pix_down = pix_center + image.step(); pix_up = pix_center - image.step(); int_center = m_quickData + (ri * roi.w()) + shift_derv; int_up = int_center - roi.w(); int_upLeft = int_up - 1; int_left = int_center - 1; for (j = jMin; j < jMax; j++) { // Build x and y derivatives, and their products: xx, xy and yy. int_center->im_x = *pix_right - *pix_left; int_center->im_y = *pix_down - *pix_up; int_center->im_xx = int_center->im_x * int_center->im_x; int_center->im_xy = int_center->im_x * int_center->im_y; int_center->im_yy = int_center->im_y * int_center->im_y; // build integral images of the 3 derivative products, xx, xy and yy: if (i == iMin && j == jMin) { int_center->int_xx = int_center->im_xx; int_center->int_xy = int_center->im_xy; int_center->int_yy = int_center->im_yy; } else if (i == iMin) { int_center->int_xx = int_center->im_xx + int_left->int_xx; int_center->int_xy = int_center->im_xy + int_left->int_xy; int_center->int_yy = int_center->im_yy + int_left->int_yy; } else if (j == jMin) { int_center->int_xx = int_center->im_xx + int_up->int_xx; int_center->int_xy = int_center->im_xy + int_up->int_xy; int_center->int_yy = int_center->im_yy + int_up->int_yy; } else { int_center->int_xx = int_center->im_xx + int_up->int_xx + int_left->int_xx - int_upLeft->int_xx; int_center->int_xy = int_center->im_xy + int_up->int_xy + int_left->int_xy - int_upLeft->int_xy; int_center->int_yy = int_center->im_yy + int_up->int_yy + int_left->int_yy - int_upLeft->int_yy; } // Advance all pointers pix_center++; pix_right++; pix_left++; pix_up++; pix_down++; int_center++; int_up++; int_left++; int_upLeft++; } } }