11:39 2022/10/27昨天搞定了笨方法匹配，观测中，比较稳定，80w的图像，匹配一百毫秒，打包一个版本。
下一步，旋转后再匹配，以及尺度变化后，匹配。
8:02 2022/10/28旋转粗版本搞定，打包一个，考虑某方向上用可行性判断，否则会很耗时。
14:47 2022/10/28笨办法第二种匹配成功，打包一个。时间要1.0268秒，太慢。
19:30 2022/10/28按早晨的思路，详细看笔记，改进后，效率极高0.0068，怎么样？打包一个。
12:09 2022/10/29更新到一个按钮匹配，结果最好131ms，和visionpro对比，20ms，相差6倍。
发现0度耗费时间长，还可以再优化。自己达到这个水平，其实是值得肯定的，打包一个
8:18 2022/11/4 megauging中已经增加了形状匹配，保留一个版本。
9:44 2022/11/7 精细匹配500ms，80w可以接受，2千万估计会很慢，不可接受。先打包一个
14:29 2022/11/8 精细匹配有重大突破，先打包一个。
以上是我突破那几日的笔记，可以浏览一下。
基于形状匹配，两件事最重要，一是学习，二是匹配
首先讲学习，我们边看代码边说：
第一是对80万像素图像高斯化，那么高斯化达到什么程度，也就是用什么样的高斯核？为什么要这样做？这个窍门就在，如果你在小图像中匹配是不是速度很快？1024*768的图像变成256*192的小图像，是同一图像，但特征没有消失。
能保证这一步的，要用到这个理论，高斯核是实现尺度空间变换的唯一变换核（在我的csdn中，我花了很多时间研究这个理论，成果是自己满意的）。这一结论基于高斯核的性质和它在图像处理中的应用。
如果你研究过sift算法，你应该明白这个意思。
所以我们80万（1024*768）图像，如果在256*192中学习和匹配，就会变得很快。
这是我想到的基于形状匹配的基本原理。我们这里80万图像使用4sigma尺度的高斯核平滑，然后每四个像素取一个像素达成图像256*192，sigma=1.25.
一维的高斯平滑以及二维的高斯平滑，我也有深入研究，我的csdn中有算法。
我们二维的高斯平滑太慢，会导致学习和匹配速度下降，百度后有一个算法很快iir高斯法，B站也有讲解，好我们把80万像素图像iir高斯化，然后取256*192像素，在学习和实时匹配都有这个动作，关键代码如下：
public struct gauss3_coefs
{
public double[] b //= new double[4]
;
public double B //= 0.0
;
public float sigma// = 0
;
public int N //= 0
;
};
public void compute_coefs3(ref gauss3_coefs c, float sigma)
{
/*
* Papers: "Recursive Implementation of the gaussian filter.",
* Ian T. Young , Lucas J. Van Vliet, Signal Processing 44, Elsevier 1995.
* formula: 11b computation of q
* 8c computation of b0..b1
* 10 alpha is normalization constant B
*/
double q, q2, q3;
q = 0;
if (sigma >= 2.5)
{
q = 0.98711 * sigma - 0.96330;
}
else if ((sigma >= 0.5) && (sigma < 2.5))
{
q = 3.97156 - 4.14554 * (float)Math.Sqrt((double)1 - 0.26891 * sigma);
}
else
{
q = 0.1147705018520355224609375;
}
q2 = q * q;
q3 = q * q2;
c.b[0] = (1.57825 + (2.44413 * q) + (1.4281 * q2) + (0.422205 * q3));
c.b[1] = ((2.44413 * q) + (2.85619 * q2) + (1.26661 * q3));
c.b[2] = (-((1.4281 * q2) + (1.26661 * q3)));
c.b[3] = ((0.422205 * q3));
c.B = 1.0 - ((c.b[1] + c.b[2] + c.b[3]) / c.b[0]);
c.sigma = sigma;
c.N = 3;
}
public void 加速gausssmooth(float[] input, ref float[] output, int size, int rowstride, gauss3_coefs c)
{
/*
* Papers: "Recursive Implementation of the gaussian filter.",
* Ian T. Young , Lucas J. Van Vliet, Signal Processing 44, Elsevier 1995.
* formula: 9a forward filter
* 9b backward filter
* fig7 algorithm
*/
int i = 0, n = 0, bufsize = 0;
float[] w1;
float[] w2;
/* forward pass */
bufsize = size + 3;
size -= 1;
w1 = new float[bufsize];
w2 = new float[bufsize];
w1[0] = input[0];
w1[1] = input[0];
w1[2] = input[0];
for (i = 0, n = 3; i <= size; i++, n++)
{
w1[n] = (float)(c.B * input[i * rowstride] +
((c.b[1] * w1[n - 1] +
c.b[2] * w1[n - 2] +
c.b[3] * w1[n - 3]) / c.b[0]));
}
/* backward pass */
w2[size + 1] = w1[size + 3];
w2[size + 2] = w1[size + 3];
w2[size + 3] = w1[size + 3];
for (i = size, n = i; i >= 0; i--, n--)
{
w2[n] = output[i * rowstride] = (float)(c.B * w1[n] +
((c.b[1] * w2[n + 1] +
c.b[2] * w2[n + 2] +
c.b[3] * w2[n + 3]) / c.b[0]));
}
// g_free (w1);
// g_free (w2);
}
gauss3_coefs 高斯因子 = new gauss3_coefs();
以上红色标出的就是iir高斯算法的创始者，即论文作者。;下面是对上面算法的调用：
byte[] output加速gaos = new byte[1024 * 768];
private void buttonAgaos_Click(object sender, EventArgs e)
{
if (glob_buffer8 == null) return;
int hh = 768;
int ww = 1024;
float[] 原图copy = new float[1024 * 768];
// MeGaugingLibNew.ImageSourceForm secondhello = meGaugingLib1.getImage();
for (int j = 0; j < hh; j++)
for (int i = 0; i < ww; i++)
{
//原图copy[j * ww + i] = secondhello.IS_orgImg[j * ww + i];
原图copy[j * ww + i] = glob_buffer8[j * ww + i];
}
//float[] glob_buffer1024768smooth1dot25 = new float[1024 * 768];
// DateTime hellostart = DateTime.Now;
// gausssmooth(原图copy, ref glob_buffer1024768smooth1dot25, hh, ww, hello);
for (int y = 0; y < hh; y++)
{
float[] temp = new float[ww];
float[] temp1 = new float[ww];
for (int x = 0; x < ww; x++)//在这个地方c的指针是有优势的，c#要迂回一下。202210200907
{
temp[x] = 原图copy[y * ww + x];
}
//gausssmooth(原图copy[y * ww], glob_buffer1024768smooth1dot25[y * ww], ww, 1, hello);
加速gausssmooth(temp, ref temp1, ww, 1, 高斯因子);
for (int x = 0; x < ww; x++)
{
原图copy[y * ww + x] = temp1[x];
}
}
// 原图copy在这里已改变，存储了行一维高斯处理结果
for (int x = 0; x < ww; x++)
{
float[] temp = new float[hh];
float[] temp1 = new float[hh];
for (int y = 0; y < hh; y++)
{
temp[y] = 原图copy[y * ww + x];
}
/* gausssmooth(glob_buffer1024768smooth1dot25[x], glob_buffer1024768smooth1dot25[x], hh, ww, hello);//可以参考fft*/
//gausssmooth(temp, ref temp1, hh, ww, hello);//可以参考fft
加速gausssmooth(temp, ref temp1, hh, 1, 高斯因子);//可以参考fft,我已经处理为1了，忘了
for (int y = 0; y < hh; y++)
{
原图copy[y * ww + x] = temp1[y];
}
}
for (int i = 0; i < ww * hh; i++)
{
output加速gaos[i] = (byte)原图copy[i];
}
ww = 1024; hh = 768;
if (!checkBox4sigma667.Checked)
{
byte[]
temp_buffer12896 = new byte[128 * 96];
int k = 0;
for (int j = 0; j < hh; j += 8)
{
for (int i = 0; i < ww; i += 8)
{
int nn = j * ww + i;
byte b = output加速gaos[nn];
temp_buffer12896[k] = b;
k++;
}
}
// DateTime dt = DateTime.Now;
globgaospydoutimgN = 非极大抑制黑中白202210261519(temp_buffer12896, 128, 96);
// showbuffer2pict(globgaospydoutimgN, 128, 96,pictureBox1);
// TimeSpan ts = DateTime.Now - dt;
// textBox1.Text = ""; textBox1.Text = ts.ToString();
// DateTime dt1 = DateTime.Now;
zhaochunjiangfa(temp_buffer12896, 128, 96);//202211071641尝试赵春江canny法
// showbuffer2pict(zhaochunjiangfa(temp_buffer12896, 128, 96), 128, 96, pictureBox2);
// TimeSpan ts1 = DateTime.Now - dt1;
// textBox2.Text = ""; textBox2.Text = ts1.ToString();
}
else
{
byte[] temp_buffer256192 = new byte[256 * 192];
int k = 0;
for (int j = 0; j < hh; j += 4)
{
for (int i = 0; i < ww; i += 4)
{
int nn = j * ww + i;
byte b = output加速gaos[nn];
temp_buffer256192[k] = b;
k++;
}
}
globgaospydoutimgN精细 = 非极大抑制黑中白202210261519(temp_buffer256192, 256, 192);
}
//TimeSpan end = DateTime.Now - dt;
//textBox快速gaos.Text = "";
//textBox快速gaos.Text = end.ToString();
// showbuffer2pict(output加速gaos, ww, hh, pictureBox加速gaos);
buttonAgaos.Enabled = false;
}
上面需要解释的就是：非极大抑制黑中白202210261519这个函数算法，我的csdn中有，去找找看。
这一节先讲到这里，待续。。。
![二叉搜索树的实现[C++]](https://i-blog.csdnimg.cn/direct/698b703c2b5247cd9324e7cc92b5da8b.gif#pic_center)