基于形状匹配原始版放出来（给有用的人参考）

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中有，去找找看。

这一节先讲到这里，待续。。。