// private boolean ComputeSubpixelHessian(
// float H[9],float b[3],
// const Image& lap0,const Image& lap1,const Image& lap2,
// int x,int y)
private bool updateLocation(DogFeaturePoint kp, LaplacianImage lap0, LaplacianImage lap1, LaplacianImage lap2)
{
double[] tmp = new double[2];
double[] b = new double[3];
// Downsample the feature point to the detection octave
bilinear_downsample_point(tmp, kp.x, kp.y, kp.octave);
double xp = tmp[0];
double yp = tmp[1];
// Compute the discrete pixel location
int x = (int)(xp + 0.5f);
int y = (int)(yp + 0.5f);
double[] H = new double[9];
if (lap0.getWidth() == lap1.getWidth() && lap1.getWidth() == lap2.getWidth())
{
//すべての画像サイズが同じ
//assert lap0.getHeight() == lap1.getHeight() && lap1.getHeight() == lap2.getHeight();// "Width/height are not consistent");
ComputeSubpixelHessianSameOctave(H, b, lap0, lap1, lap2, x, y);
}
else if ((lap0.getWidth() == lap1.getWidth()) && ((lap1.getWidth() >> 1) == lap2.getWidth()))
{
//0,1が同じで2がその半分
//assert (lap0.getHeight() == lap1.getHeight()) && ((lap1.getHeight() >> 1) == lap2.getHeight());// Width/height are not consistent");
ComputeSubpixelHessianFineOctavePair(H, b, lap0, lap1, lap2, x, y);
}
else if (((lap0.getWidth() >> 1) == lap1.getWidth()) && (lap1.getWidth() == lap2.getWidth()))
{
//0の半分が1,2
//assert ((lap0.getWidth() >> 1) == lap1.getWidth()) && (lap1.getWidth() == lap2.getWidth());// Width/height are not consistent");
ComputeSubpixelHessianCoarseOctavePair(H, b, lap0, lap1, lap2, x, y);
}
else
{
// ASSERT(0, "Image sizes are inconsistent");
return(false);
}
// A*u=b // if (!SolveSymmetricLinearSystem3x3(u, H, b)) {
NyARDoubleMatrix33 m = new NyARDoubleMatrix33();
m.m00 = H[0];
m.m01 = H[1];
m.m02 = H[2];
m.m10 = H[3];
m.m11 = H[4];
m.m12 = H[5];
m.m20 = H[6];
m.m21 = H[7];
m.m22 = H[8];
if (!m.inverse(m))
{
return(false);
}
double u0 = (m.m00 * b[0] + m.m01 * b[1] + m.m02 * b[2]);
double u1 = (m.m10 * b[0] + m.m11 * b[1] + m.m12 * b[2]);
double u2 = (m.m20 * b[0] + m.m21 * b[1] + m.m22 * b[2]);
// If points move too much in the sub-pixel update, then the point probably unstable.
if ((u0 * u0) + (u1 * u1) > mMaxSubpixelDistanceSqr)
{
return(false);
}
// Compute the edge score
if (!ComputeEdgeScore(tmp, H))
{
return(false);
}
kp.edge_score = tmp[0];
// Compute a linear estimate of the intensity
// ASSERT(kp.score == lap1.get<float>(y)[x],
// "Score is not consistent with the DoG image");
double[] lap1_buf = (double[])lap1.getBuffer();
kp.score = lap1_buf[lap1.get(y) + x] - (b[0] * u0 + b[1] * u1 + b[2] * u2);
// Update the location:
// Apply the update on the downsampled location and then upsample
// the result.
// bilinear_upsample_point(kp.x, kp.y, xp+u[0], yp+u[1], kp.octave);
bilinear_upsample_point(tmp, xp + u0, yp + u1, kp.octave);
kp.x = tmp[0];
kp.y = tmp[1];
// Update the scale
kp.sp_scale = kp.scale + u2;
kp.sp_scale = ClipScalar(kp.sp_scale, 0, mLaplacianPyramid.numScalePerOctave());
return(true);
}
/**
* Extract the minima/maxima.
*/
private void extractFeatures(GaussianScaleSpacePyramid pyramid, DoGPyramid laplacian, DogFeaturePointStack i_dog_fp)
{
double laplacianSqrThreshold = (this.mLaplacianThreshold * this.mLaplacianThreshold);
for (int i = 1; i < mLaplacianPyramid.size() - 1; i++)
{
LaplacianImage im0 = laplacian.get(i - 1);
LaplacianImage im1 = laplacian.get(i);
LaplacianImage im2 = laplacian.get(i + 1);
double[] im0b = (double[])im0.getBuffer();
double[] im1b = (double[])im1.getBuffer();
double[] im2b = (double[])im2.getBuffer();
int octave = laplacian.octaveFromIndex((int)i);
int scale = laplacian.scaleFromIndex((int)i);
if (im0.getWidth() == im1.getWidth() && im0.getWidth() == im2.getWidth())
{ // All images are the
// same size
// ASSERT(im0.height() == im1.height(), "Height is inconsistent");
// ASSERT(im0.height() == im2.height(), "Height is inconsistent");
int width_minus_1 = im1.getWidth() - 1;
int heigh_minus_1 = im1.getHeight() - 1;
for (int row = 1; row < heigh_minus_1; row++)
{
int im0_ym1 = im0.get(row - 1);
int im0_y = im0.get(row);
int im0_yp1 = im0.get(row + 1);
int im1_ym1 = im1.get(row - 1);
int im1_y = im1.get(row);
int im1_yp1 = im1.get(row + 1);
int im2_ym1 = im2.get(row - 1);
int im2_y = im2.get(row);
int im2_yp1 = im2.get(row + 1);
for (int col = 1; col < width_minus_1; col++)
{
double value = im1b[im1_y + col];
// Check laplacian score
if ((value * value) < laplacianSqrThreshold)
{
continue;
}
bool extrema = false;
if (value > im0b[im0_ym1 + col - 1] && value > im0b[im0_ym1 + col] &&
value > im0b[im0_ym1 + col + 1] && value > im0b[im0_y + col - 1] &&
value > im0b[im0_y + col] && value > im0b[im0_y + col + 1] &&
value > im0b[im0_yp1 + col - 1] && value > im0b[im0_yp1 + col] &&
value > im0b[im0_yp1 + col + 1] &&
/* im1 - 8 evaluations */
value > im1b[im1_ym1 + col - 1] && value > im1b[im1_ym1 + col] &&
value > im1b[im1_ym1 + col + 1] && value > im1b[im1_y + col - 1] &&
value > im1b[im1_y + col + 1] && value > im1b[im1_yp1 + col - 1] &&
value > im1b[im1_yp1 + col] && value > im1b[im1_yp1 + col + 1] &&
/* im2 - 9 evaluations */
value > im2b[im2_ym1 + col - 1] && value > im2b[im2_ym1 + col] &&
value > im2b[im2_ym1 + col + 1] && value > im2b[im2_y + col - 1] &&
value > im2b[im2_y + col] && value > im2b[im2_y + col + 1] &&
value > im2b[im2_yp1 + col - 1] && value > im2b[im2_yp1 + col] &&
value > im2b[im2_yp1 + col + 1])
{
extrema = true;
}
else if (value < im0b[im0_ym1 + col - 1] && value < im0b[im0_ym1 + col] &&
value < im0b[im0_ym1 + col + 1] && value < im0b[im0_y + col - 1] &&
value < im0b[im0_y + col] && value < im0b[im0_y + col + 1] &&
value < im0b[im0_yp1 + col - 1] && value < im0b[im0_yp1 + col] &&
value < im0b[im0_yp1 + col + 1] &&
/* im1 - 8 evaluations */
value < im1b[im1_ym1 + col - 1] && value < im1b[im1_ym1 + col] &&
value < im1b[im1_ym1 + col + 1] && value < im1b[im1_y + col - 1] &&
value < im1b[im1_y + col + 1] && value < im1b[im1_yp1 + col - 1] &&
value < im1b[im1_yp1 + col] && value < im1b[im1_yp1 + col + 1] &&
/* im2 - 9 evaluations */
value < im2b[im2_ym1 + col - 1] && value < im2b[im2_ym1 + col] &&
value < im2b[im2_ym1 + col + 1] && value < im2b[im2_y + col - 1] &&
value < im2b[im2_y + col] && value < im2b[im2_y + col + 1] &&
value < im2b[im2_yp1 + col - 1] && value < im2b[im2_yp1 + col] &&
value < im2b[im2_yp1 + col + 1])
{
extrema = true;
}
if (extrema)
{
DogFeaturePoint fp = i_dog_fp.prePush();
if (fp == null)
{
prepush_warning();
break;
}
fp.octave = octave;
fp.scale = scale;
fp.score = value;
fp.sigma = pyramid.effectiveSigma(octave, scale);
double[] tmp = new double[2];
bilinear_upsample_point(tmp, col, row, octave);
fp.x = tmp[0];
fp.y = tmp[1];
}
}
}
}
else if (im0.getWidth() == im1.getWidth() && (im1.getWidth() >> 1) == im2.getWidth())
{
int end_x = (int)Math.Floor(((im2.getWidth() - 1) - 0.5f) * 2.0f + 0.5f);
int end_y = (int)Math.Floor(((im2.getHeight() - 1) - 0.5f) * 2.0f + 0.5f);
for (int row = 2; row < end_y; row++)
{
int im0_ym1 = im0.get(row - 1);
int im0_y = im0.get(row);
int im0_yp1 = im0.get(row + 1);
int im1_ym1 = im1.get(row - 1);
int im1_y = im1.get(row);
int im1_yp1 = im1.get(row + 1);
for (int col = 2; col < end_x; col++)
{
double value = im1b[im1_y + col];
// Check laplacian score
if ((value * value) < laplacianSqrThreshold)
{
continue;
}
// Compute downsampled point location
double ds_x = col * 0.5f - 0.25f;
double ds_y = row * 0.5f - 0.25f;
bool extrema = false;
if (
/* im0 - 9 evaluations */
value > im0b[im0_ym1 + col - 1] && value > im0b[im0_ym1 + col] &&
value > im0b[im0_ym1 + col + 1] && value > im0b[im0_y + col - 1] &&
value > im0b[im0_y + col] && value > im0b[im0_y + col + 1] &&
value > im0b[im0_yp1 + col - 1] && value > im0b[im0_yp1 + col] &&
value > im0b[im0_yp1 + col + 1] &&
/* im1 - 8 evaluations */
value > im1b[im1_ym1 + col - 1] && value > im1b[im1_ym1 + col] &&
value > im1b[im1_ym1 + col + 1] && value > im1b[im1_y + col - 1] &&
value > im1b[im1_y + col + 1] && value > im1b[im1_yp1 + col - 1] &&
value > im1b[im1_yp1 + col] && value > im1b[im1_yp1 + col + 1] &&
/* im2 - 9 evaluations */
value > im2.bilinearInterpolation(ds_x - 0.5f, ds_y - 0.5f) &&
value > im2.bilinearInterpolation(ds_x, ds_y - 0.5f) &&
value > im2.bilinearInterpolation(ds_x + 0.5f, ds_y - 0.5f) &&
value > im2.bilinearInterpolation(ds_x - 0.5f, ds_y) &&
value > im2.bilinearInterpolation(ds_x, ds_y) &&
value > im2.bilinearInterpolation(ds_x + 0.5f, ds_y) &&
value > im2.bilinearInterpolation(ds_x - 0.5f, ds_y + 0.5f) &&
value > im2.bilinearInterpolation(ds_x, ds_y + 0.5f) &&
value > im2.bilinearInterpolation(ds_x + 0.5f, ds_y + 0.5f))
{
extrema = true;
}
else if (
/* im0 - 9 evaluations */
value < im0b[im0_ym1 + col - 1] && value < im0b[im0_ym1 + col] &&
value < im0b[im0_ym1 + col + 1] && value < im0b[im0_y + col - 1] &&
value < im0b[im0_y + col] && value < im0b[im0_y + col + 1] &&
value < im0b[im0_yp1 + col - 1] && value < im0b[im0_yp1 + col] &&
value < im0b[im0_yp1 + col + 1] &&
/* im1 - 8 evaluations */
value < im1b[im1_ym1 + col - 1] && value < im1b[im1_ym1 + col] &&
value < im1b[im1_ym1 + col + 1] && value < im1b[im1_y + col - 1] &&
value < im1b[im1_y + col + 1] && value < im1b[im1_yp1 + col - 1] &&
value < im1b[im1_yp1 + col] && value < im1b[im1_yp1 + col + 1] &&
/* im2 - 9 evaluations */
value < im2.bilinearInterpolation(ds_x - 0.5f, ds_y - 0.5f) &&
value < im2.bilinearInterpolation(ds_x, ds_y - 0.5f) &&
value < im2.bilinearInterpolation(ds_x + 0.5f, ds_y - 0.5f) &&
value < im2.bilinearInterpolation(ds_x - 0.5f, ds_y) &&
value < im2.bilinearInterpolation(ds_x, ds_y) &&
value < im2.bilinearInterpolation(ds_x + 0.5f, ds_y) &&
value < im2.bilinearInterpolation(ds_x - 0.5f, ds_y + 0.5f) &&
value < im2.bilinearInterpolation(ds_x, ds_y + 0.5f) &&
value < im2.bilinearInterpolation(ds_x + 0.5f, ds_y + 0.5f))
{
extrema = true;
}
if (extrema)
{
DogFeaturePoint fp = i_dog_fp.prePush();
if (fp == null)
{
prepush_warning();
break;
}
fp.octave = octave;
fp.scale = scale;
fp.score = value;
fp.sigma = pyramid.effectiveSigma(octave, scale);
double[] tmp = new double[2];
bilinear_upsample_point(tmp, col, row, octave);
fp.x = tmp[0];
fp.y = tmp[1];
}
}
}
}
else if ((im0.getWidth() >> 1) == im1.getWidth() && (im0.getWidth() >> 1) == im2.getWidth())
{
int width_minus_1 = im1.getWidth() - 1;
int height_minus_1 = im1.getHeight() - 1;
for (int row = 1; row < height_minus_1; row++)
{
int im1_ym1 = im1.get(row - 1);
int im1_y = im1.get(row);
int im1_yp1 = im1.get(row + 1);
int im2_ym1 = im2.get(row - 1);
int im2_y = im2.get(row);
int im2_yp1 = im2.get(row + 1);
for (int col = 1; col < width_minus_1; col++)
{
double value = im1b[im1_y + col];
// Check laplacian score
if ((value * value) < laplacianSqrThreshold)
{
continue;
}
double us_x = (col << 1) + 0.5f;
double us_y = (row << 1) + 0.5f;
bool extrema = false;
if (value > im1b[im1_ym1 + col - 1] && value > im1b[im1_ym1 + col] &&
value > im1b[im1_ym1 + col + 1] && value > im1b[im1_y + col - 1] &&
value > im1b[im1_y + col + 1] && value > im1b[im1_yp1 + col - 1] &&
value > im1b[im1_yp1 + col] && value > im1b[im1_yp1 + col + 1] &&
/* im2 - 9 evaluations */
value > im2b[im2_ym1 + col - 1] && value > im2b[im2_ym1 + col] &&
value > im2b[im2_ym1 + col + 1] && value > im2b[im2_y + col - 1] &&
value > im2b[im2_y + col] && value > im2b[im2_y + col + 1] &&
value > im2b[im2_yp1 + col - 1] && value > im2b[im2_yp1 + col] &&
value > im2b[im2_yp1 + col + 1] &&
/* im2 - 9 evaluations */
value > im0.bilinearInterpolation(us_x - 2.0f, us_y - 2.0f) &&
value > im0.bilinearInterpolation(us_x, us_y - 2.0f) &&
value > im0.bilinearInterpolation(us_x + 2.0f, us_y - 2.0f) &&
value > im0.bilinearInterpolation(us_x - 2.0f, us_y) &&
value > im0.bilinearInterpolation(us_x, us_y) &&
value > im0.bilinearInterpolation(us_x + 2.0f, us_y) &&
value > im0.bilinearInterpolation(us_x - 2.0f, us_y + 2.0f) &&
value > im0.bilinearInterpolation(us_x, us_y + 2.0f) &&
value > im0.bilinearInterpolation(us_x + 2.0f, us_y + 2.0f))
{
extrema = true;
}
else if (value < im1b[im1_ym1 + col - 1] && value < im1b[im1_ym1 + col] &&
value < im1b[im1_ym1 + col + 1] && value < im1b[im1_y + col - 1] &&
value < im1b[im1_y + col + 1] && value < im1b[im1_yp1 + col - 1] &&
value < im1b[im1_yp1 + col] && value < im1b[im1_yp1 + col + 1] &&
/* im2 - 9 evaluations */
value < im2b[im2_ym1 + col - 1] && value < im2b[im2_ym1 + col] &&
value < im2b[im2_ym1 + col + 1] && value < im2b[im2_y + col - 1] &&
value < im2b[im2_y + col] && value < im2b[im2_y + col + 1] &&
value < im2b[im2_yp1 + col - 1] && value < im2b[im2_yp1 + col] &&
value < im2b[im2_yp1 + col + 1] &&
/* im2 - 9 evaluations */
value < im0.bilinearInterpolation(us_x - 2.0f, us_y - 2.0f) &&
value < im0.bilinearInterpolation(us_x, us_y - 2.0f) &&
value < im0.bilinearInterpolation(us_x + 2.0f, us_y - 2.0f) &&
value < im0.bilinearInterpolation(us_x - 2.0f, us_y) &&
value < im0.bilinearInterpolation(us_x, us_y) &&
value < im0.bilinearInterpolation(us_x + 2.0f, us_y) &&
value < im0.bilinearInterpolation(us_x - 2.0f, us_y + 2.0f) &&
value < im0.bilinearInterpolation(us_x, us_y + 2.0f) &&
value < im0.bilinearInterpolation(us_x + 2.0f, us_y + 2.0f))
{
extrema = true;
}
if (extrema)
{
DogFeaturePoint fp = i_dog_fp.prePush();
if (fp == null)
{
prepush_warning();
break;
}
fp.octave = octave;
fp.scale = scale;
fp.score = value;
fp.sigma = pyramid.effectiveSigma(octave, scale);
double[] tmp = new double[2];
bilinear_upsample_point(tmp, col, row, octave);
fp.x = tmp[0];
fp.y = tmp[1];
}
}
}
}
}
return;
}
