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;
}
