void interp_extremum(int octv, int intvl, int r, int c) { double xi = 0, xr = 0, xc = 0; int step = init_sample * COpenSURF.cvRound(COpenSURF.pow(2.0f, octv)); // Get the offsets to the actual location of the extremum bool bok = interp_step(octv, intvl, r, c, out xi, out xr, out xc); if (bok == false) { return; } // If point is sufficiently close to the actual extremum if (COpenSURF.fabs((float)xi) <= 0.5 && COpenSURF.fabs((float)xr) <= 0.5 && COpenSURF.fabs((float)xc) <= 0.5) { // Create Ipoint and push onto Ipoints vector Ipoint ipt = new Ipoint(); ipt.x = (float)(c + step * xc); ipt.y = (float)(r + step * xr); ipt.scale = (float)((1.2f / 9.0f) * (3 * (COpenSURF.pow(2.0f, octv + 1) * (intvl + xi + 1) + 1))); ipt.laplacian = (int)getLaplacian(octv, intvl, c, r); ipts.Add(ipt); } }
public Match(Ipoint _ipt1, Ipoint _ipt2, double _fDistance1, double _fDistance2) { m_ipt1 = _ipt1; m_ipt2 = _ipt2; m_fDistance1 = _fDistance1; m_fDistance2 = _fDistance2; }
void getUprightDescriptor() { int y, x, count = 0; int scale; float dx, dy, mdx, mdy; float gauss, rx, ry, len = 0.0f; float[] desc; Ipoint ipt = ipts[index]; scale = (int)ipt.scale; y = COpenSURF.cvRound(ipt.y); x = COpenSURF.cvRound(ipt.x); desc = ipt.descriptor; // Calculate descriptor for this interest point for (int i = -10; i < 10; i += 5) { for (int j = -10; j < 10; j += 5) { dx = dy = mdx = mdy = 0; for (int k = i; k < i + 5; ++k) { for (int l = j; l < j + 5; ++l) { // get Gaussian weighted x and y responses gauss = COpenSURF.gaussian(k * scale, l * scale, 3.3f * scale); rx = gauss * haarX(k * scale + y, l * scale + x, 2 * scale); ry = gauss * haarY(k * scale + y, l * scale + x, 2 * scale); dx += rx; dy += ry; mdx += COpenSURF.fabs(rx); mdy += COpenSURF.fabs(ry); } } // add the values to the descriptor vector desc[count++] = dx; desc[count++] = dy; desc[count++] = mdx; desc[count++] = mdy; // store the current length^2 of the vector len += dx * dx + dy * dy + mdx * mdx + mdy * mdy; } } // convert to unit vector len = (float)Math.Sqrt(len); for (int i = 0; i < 64; i++) { desc[i] /= len; } }
public Ipoint(Ipoint pIPoint) { x = pIPoint.x; y = pIPoint.y; scale = pIPoint.scale; orientation = pIPoint.orientation; laplacian = pIPoint.laplacian; descriptor = pIPoint.descriptor.Clone() as float[]; dx = pIPoint.x; dy = pIPoint.x; }
public static void MatchPoint(Ipoint ipt, List <Ipoint> ipts, out Match m) { // Find the nearest neighbour of ipt point, in ipts set. // K-D tree implementation from Sebastian Nowozin's Autopano-sift. ArrayList aTreePoints = new ArrayList(ipts); KDTree kdt2 = KDTree.CreateKDTree(aTreePoints); int searchDepth = (int)Math.Max(130.0, (Math.Log(aTreePoints.Count) / Math.Log(1000.0)) * 130.0); Ipoint best = (Ipoint)kdt2.NearestNeighbourListBBF(ipt, searchDepth); m = new Match(ipt, best); }
void getIpoint(int o, int i, int c, int r) { //! Interpolate feature to sub pixel accuracy bool converged = false; float[] x = new float[3]; for (int steps = 0; steps <= interp_steps; ++steps) { // perform a step of the interpolation stepInterp(o, i, c, r, x); // check stopping conditions if (COpenSURF.fabs(x[0]) < 0.5 && COpenSURF.fabs(x[1]) < 0.5 && COpenSURF.fabs(x[2]) < 0.5) { converged = true; break; } // find coords of different sample point c += COpenSURF.cvRound(x[0]); r += COpenSURF.cvRound(x[1]); i += COpenSURF.cvRound(x[2]); // check all param are within bounds if (i < 1 || i >= intervals - 1 || c < 1 || r < 1 || c > i_width - 1 || r > i_height - 1) { return; } } // if interpolation has not converged on a result if (!converged) { return; } // create Ipoint and push onto Ipoints vector Ipoint ipt = new Ipoint(); ipt.x = (float)(c + x[0]); ipt.y = (float)(r + x[1]); ipt.scale = (1.2f / 9.0f) * (3 * (COpenSURF.pow(2.0f, o + 1) * (i + x[2] + 1) + 1)); ipt.laplacian = (int)getLaplacian(o, i, c, r); if (ipts == null) { ipts = new List <Ipoint>(); } ipts.Add(ipt); }
public static void MatchPoints(List <Ipoint> ipts1, List <Ipoint> ipts2, out List <Match> matches) { // Find the nearest neighbour of each ipts1 point, in ipts2 set. // K-D tree implementation taken from Sebastian Nowozin's Autopano-sift. matches = new List <Match>(); // K-D tree of candidate points. ArrayList aTreePoints = new ArrayList(ipts2); KDTree kdt2 = KDTree.CreateKDTree(aTreePoints); // Loop through all input points. int searchDepth = (int)Math.Max(130.0, (Math.Log(aTreePoints.Count) / Math.Log(1000.0)) * 130.0); foreach (Ipoint p in ipts1) { // Find which point in ipts2 is the nearest from p. Ipoint best = (Ipoint)kdt2.NearestNeighbourListBBF(p, searchDepth); Match m = new Match(p, best); matches.Add(m); } }
void getOrientation() { Ipoint ipt = ipts[index]; float gauss = 0; float scale = ipt.scale; int s = COpenSURF.cvRound(scale); int r = COpenSURF.cvRound(ipt.y); int c = COpenSURF.cvRound(ipt.x); List <float> resX = new List <float>(); List <float> resY = new List <float>(); List <float> Ang = new List <float>(); // calculate haar responses for points within radius of 6*scale for (int i = -6 * s; i <= 6 * s; i += s) { for (int j = -6 * s; j <= 6 * s; j += s) { if (i * i + j * j < 36 * s * s) { gauss = COpenSURF.gaussian(i, j, 2.5f * s); float _resx = gauss * haarX(r + j, c + i, 4 * s); float _resy = gauss * haarY(r + j, c + i, 4 * s); resX.Add(_resx); resY.Add(_resy); Ang.Add(COpenSURF.getAngle(_resx, _resy)); } } } // calculate the dominant direction float sumX, sumY; float max = 0, old_max = 0, orientation = 0, old_orientation = 0; float ang1, ang2, ang; // loop slides pi/3 window around feature point for (ang1 = 0; ang1 < 2 * pi; ang1 += 0.2f) { ang2 = (ang1 + pi / 3.0f > 2 * pi ? ang1 - 5.0f * pi / 3.0f : ang1 + pi / 3.0f); sumX = sumY = 0; for (int k = 0; k < Ang.Count; k++) { // get angle from the x-axis of the sample point ang = Ang[k]; // determine whether the point is within the window if (ang1 < ang2 && ang1 < ang && ang < ang2) { sumX += resX[k]; sumY += resY[k]; } else if (ang2 < ang1 && ((ang > 0 && ang < ang2) || (ang > ang1 && ang < 2 * pi))) { sumX += resX[k]; sumY += resY[k]; } } // if the vector produced from this window is longer than all // previous vectors then this forms the new dominant direction if (sumX * sumX + sumY * sumY > max) { // store second largest orientation old_max = max; old_orientation = orientation; // store largest orientation max = sumX * sumX + sumY * sumY; orientation = COpenSURF.getAngle(sumX, sumY); } } // for(ang1 = 0; ang1 < 2*pi; ang1+=0.2f) // check whether there are two dominant orientations based on 0.8 threshold if (old_max >= 0.8 * max) { // assign second largest orientation and push copy onto vector ipt.orientation = old_orientation; ipts.Add(ipt); // Reset ipt to point to correct Ipoint in the vector ipt = ipts[index]; } // assign orientation of the dominant response vector ipt.orientation = orientation; }
void getDescriptor() { int y, x, count = 0; float dx, dy, mdx, mdy, co, si; float[] desc; int scale; int sample_x; int sample_y; float gauss, rx, ry, rrx, rry, len = 0; Ipoint ipt = ipts[index]; scale = (int)ipt.scale; x = COpenSURF.cvRound(ipt.x); y = COpenSURF.cvRound(ipt.y); co = (float)Math.Cos(ipt.orientation); si = (float)Math.Sin(ipt.orientation); desc = ipt.descriptor; // Calculate descriptor for this interest point for (int i = -10; i < 10; i += 5) { for (int j = -10; j < 10; j += 5) { dx = dy = mdx = mdy = 0; for (int k = i; k < i + 5; ++k) { for (int l = j; l < j + 5; ++l) { // Get coords of sample point on the rotated axis sample_x = COpenSURF.cvRound(x + (-l * scale * si + k * scale * co)); sample_y = COpenSURF.cvRound(y + (l * scale * co + k * scale * si)); // Get the gaussian weighted x and y responses gauss = COpenSURF.gaussian(k * scale, l * scale, 3.3f * scale); rx = gauss * haarX(sample_y, sample_x, 2 * scale); ry = gauss * haarY(sample_y, sample_x, 2 * scale); // Get the gaussian weighted x and y responses on rotated axis rrx = -rx * si + ry * co; rry = rx * co + ry * si; dx += rrx; dy += rry; mdx += COpenSURF.fabs(rrx); mdy += COpenSURF.fabs(rry); } } // add the values to the descriptor vector desc[count++] = dx; desc[count++] = dy; desc[count++] = mdx; desc[count++] = mdy; // store the current length^2 of the vector len += dx * dx + dy * dy + mdx * mdx + mdy * mdy; } // for (int j = -10; j < 10; j+=5) } // for (int i = -10; i < 10; i+=5) // convert to unit vector len = (float)Math.Sqrt(len); for (int i = 0; i < 64; i++) { desc[i] /= len; } }
public Match(Ipoint _ipt1, Ipoint _ipt2) { m_ipt1 = _ipt1; m_ipt2 = _ipt2; }