public static Rectangle GetPatternRectangeBoundary
    (Bitmap original,int colorIndex, int hStep, int vStep, bool bTopStart) 

public static List<Rectangle> PatternRectangeBoundaryList
    (Bitmap original, int colorIndex, int hStep, int vStep, 
    bool bTopStart,int widthMin,int heightMin)

public void PatternRecognitionThread(Bitmap bitmap)
     {
         _originalBitmap = bitmap;
         if (_rowList == null)
         {
             _rowList = AForge.Imaging.Image.PatternRectangeBoundaryList
     (_originalBitmap,255, 30, 1, true, 5, 5);
             _irowIndex = 0;

         }
         foreach(Rectangle rowRect in _rowList)
         {
             _currentRow = AForge.Imaging.ImageResize.ImageCrop
     (_originalBitmap, rowRect);
             if (_iwordIndex == 0)
             {
                 _currentWordsList = AForge.Imaging.Image.PatternRectangeBoundaryList
         (_currentRow, 255, 20, 10, false, 5, 5);
             }

             foreach (Rectangle wordRect in _currentWordsList)
             {
                 _currentWord = AForge.Imaging.ImageResize.ImageCrop
         (_currentRow, wordRect);
                _iwordIndex++;
                 if (_icharIndex == 0)
                 {
                     _currentCharsList =
         AForge.Imaging.Image.PatternRectangeBoundaryList
         (_currentWord, 255, 1, 1, false, 5, 5);
                 }

                 foreach (Rectangle charRect in _currentCharsList)
                 {
                     _currentChar = AForge.Imaging.ImageResize.ImageCrop
         (_currentWord, charRect);
                    _icharIndex++;
                     Bitmap bmptemp = AForge.Imaging.ImageResize.FixedSize
         (_currentChar, 21, 21);
                     bmptemp = AForge.Imaging.Image.CreateColorPad
         (bmptemp,Color.White, 4, 4);
                     bmptemp = AForge.Imaging.Image.CreateIndexedGrayScaleBitmap
             (bmptemp);
                     byte[] graybytes = AForge.Imaging.Image.GrayscaletoBytes(bmptemp);
                     PatternRecognitionThread(graybytes);
                     m_bitmaps.Add(bmptemp);
                 }
                 string s = " \n";
                 _form.Invoke(_form._DelegateAddObject, new Object[] { 1, s });
                       If(_icharIndex ==_currentCharsList.Count)
                       {
                       _icharIndex =0;
                       }
              }
              If(_iwordIndex==__currentWordsList.Count)
              {
                       _iwordIndex=0;
              }
         }

public void BackpropagateSecondDerivatives(DErrorsList d2Err_wrt_dXn /* in */,
                                                    DErrorsList d2Err_wrt_dXnm1 /* out */)
{
    // 命名（从NeuralNetwork类继承）
    // 注意：尽管我们正在处理二阶导数（而不是一阶），
    // 但是我们使用几乎相同的符号，就好像有一阶导数
    // 一样，否则ASCII的显示会令人误解。 我们添加一
    // 个“2”而不是两个“2”，比如“d2Err_wrt_dXn”，以简
    // 单地强调我们使用二阶导数
    //
    // Err是整个神经网络的输出误差
    // Xn是第n层上的输出向量
    // Xnm1是前一层的输出向量
    // Wn是第n层权重的向量
    // Yn是第n层的激活值，
    // 即，应用挤压功能之前的输入的加权和
    // F是挤压函数：Xn = F（Yn）
    // F‘是挤压函数的导数
    // 简单说，对于F = tanh，则F‘（Yn）= 1-Xn ^ 2，即，
    // 可以从输出中计算出导数，而不需要知道输入
 
    int ii, jj;
    uint kk;
    int nIndex;
    double output;
    double dTemp;
 
    var d2Err_wrt_dYn = new DErrorsList(m_Neurons.Count);
    //
    // std::vector< double > d2Err_wrt_dWn( m_Weights.size(), 0.0 );
    // important to initialize to zero
    //////////////////////////////////////////////////
    //
    ///// 设计 TRADEOFF: REVIEW !!
    //
    // 请注意，此命名的方案与NNLayer :: Backpropagate（）
    // 函数中的推理相同，即从该函数派生的
    // BackpropagateSecondDerivatives（）函数
    //
    // 我们希望对数组“d2Err_wrt_dWn”使用STL向量（为了便于编码）
    // ，这是图层中当前模式的错误权重的二阶微分。 但是，对于
    // 具有许多权重的层（例如完全连接的层），也有许多权重。 分
    // 配大内存块时，STL向量类的分配器非常愚蠢，并导致大量的页
    // 面错误，从而导致应用程序总体执行时间减慢。
 
    // 为了解决这个问题，我尝试使用一个普通的C数组，
    // 并从堆中取出所需的空间，并在函数结尾处删除[]。
    // 但是，这会导致相同数量的页面错误错误，并
    // 且不会提高性能。
 
    // 所以我试着在栈上分配一个普通的C数组（即不是堆）。
    // 当然，我不能写double d2Err_wrt_dWn [m_Weights.size（）];
    // 因为编译器坚持一个编译时间为数组大小的已知恒定值。
    // 为了避免这个需求，我使用_alloca函数来分配堆栈上的内存。
    // 这样做的缺点是堆栈使用过多，可能会出现堆栈溢出问题。
    // 这就是为什么将它命名为“Review”

 
    double[] d2Err_wrt_dWn = new double[m_Weights.Count];
    for (ii = 0; ii < m_Weights.Count; ++ii)
    {
        d2Err_wrt_dWn[ii] = 0.0;
    }
    // 计算 d2Err_wrt_dYn = ( F‘(Yn) )^2 *
    //    dErr_wrt_Xn (其中dErr_wrt_Xn实际上是二阶导数)
 
    for (ii = 0; ii < m_Neurons.Count; ++ii)
    {
        output = m_Neurons[ii].output;
        dTemp = m_sigmoid.DSIGMOID(output);
        d2Err_wrt_dYn.Add(d2Err_wrt_dXn[ii] * dTemp * dTemp);
    }
    // 计算d2Err_wrt_Wn =（Xnm1）^ 2 * d2Err_wrt_Yn
    // （其中dE2rr_wrt_Yn实际上是二阶导数）
    // 对于这个层中的每个神经元，通过先前层的连接
    // 列表，并更新相应权重的差分
 
    ii = 0;
    foreach (NNNeuron nit in m_Neurons)
    {
        foreach (NNConnection cit in nit.m_Connections)
        {
            try
            {
                 kk = (uint)cit.NeuronIndex;
                if (kk == 0xffffffff)
                {
                    output = 1.0;
                    // 这是隐含的联系; 隐含的神经元输出“1”
                }
                else
                {
                    output = m_pPrevLayer.m_Neurons[(int)kk].output;
                }
 
                //  ASSERT( (*cit).WeightIndex < d2Err_wrt_dWn.size() );
                //  因为在将d2Err_wrt_dWn更改为C风格的
                //  数组之后，size（）函数将不起作用

                d2Err_wrt_dWn[cit.WeightIndex] = d2Err_wrt_dYn[ii] * output * output;
            }
            catch (Exception ex)
            {
 
           }
        }
 
        ii++;
    }
    // 计算d2Err_wrt_Xnm1 =（Wn）^ 2 * d2Err_wrt_dYn
    // （其中d2Err_wrt_dYn是不是第一个二阶导数）。
    // 需要d2Err_wrt_Xnm1作为d2Err_wrt_Xn的
    // 二阶导数反向传播的输入值
    // 对于下一个（即先前的空间）层
    // 对于这个层中的每个神经元
 
    ii = 0;
    foreach (NNNeuron nit in m_Neurons)
    {
        foreach (NNConnection cit in nit.m_Connections)
        {
            try
            {
                kk = cit.NeuronIndex;
                if (kk != 0xffffffff)
                {
        // 我们排除了ULONG_MAX，它表示具有恒定输出“1”的
        // 虚偏置神经元，因为我们不能正真训练偏置神经元
 
                    nIndex = (int)kk;
                    dTemp = m_Weights[(int)cit.WeightIndex].value;
                    d2Err_wrt_dXnm1[nIndex] += d2Err_wrt_dYn[ii] * dTemp * dTemp;
                }
            }
            catch (Exception ex)
            {
                return;
            }
        }
 
        ii++;  // ii 跟踪神经元迭代器
    }
    double oldValue, newValue;
 
    // 最后，使用dErr_wrt_dW更新对角线的层
    // 神经元的权重。通过设计，这个函数
    // 以及它对许多（约500个模式）的迭代被
    // 调用，而单个线程已经锁定了神经网络，
    // 所以另一个线程不可能改变Hessian的值。
    // 不过，由于这很容易做到，所以我们使用一
    // 个原子比较交换操作，这意味着另一个线程
    // 可能在二阶导数的反向传播过程中，而且Hessians
    // 可能会稍微移动
 
    for (jj = 0; jj < m_Weights.Count; ++jj)
    {
        oldValue = m_Weights[jj].diagHessian;
        newValue = oldValue + d2Err_wrt_dWn[jj];
        m_Weights[jj].diagHessian = newValue;
    }
}
//////////////////////////////////////////////////////////////////