Image<Bgr, Byte> imageSource = new Image<Bgr, byte>(sourceImageFileName);       //獲取源圖像
Image<Gray, Byte> imageGray = imageSource.Convert<Gray, Byte>();                //將源圖像轉換成灰度圖像
int thresholdValue = tbThreshold.Value;                                         //用于二值化的閥值
Image<Gray, Byte> imageThreshold = imageGray.ThresholdBinary(new Gray(thresholdValue), new Gray(255d)); //對灰度圖像二值化
Contour<Point> contour=imageThreshold.FindContours();

//查找用Freeman鏈碼表示的輪廓
Image<Gray,Byte> imageTemp=imageThreshold.Copy();
IntPtr storage = CvInvoke.cvCreateMemStorage(0);
IntPtr ptrFirstChain = IntPtr.Zero;
int total = CvInvoke.cvFindContours(imageTemp.Ptr, storage, ref ptrFirstChain, sizeof(MCvChain), mode, CHAIN_APPROX_METHOD.CV_CHAIN_CODE, new Point(0, 0));

//初始化Freeman鏈碼讀取
[DllImport("cv200.dll")]
public static extern void cvStartReadChainPoints(IntPtr ptrChain,IntPtr ptrReader);
//讀取Freeman鏈碼的點
[DllImport("cv200.dll")]
public static extern Point cvReadChainPoint(IntPtr ptrReader);
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, CharSet = System.Runtime.InteropServices.CharSet.Ansi)]
//定義鏈碼讀取結構
public struct MCvChainPtReader
{
    //seqReader
    public MCvSeqReader seqReader;
    /// char
    public byte code;
    /// POINT->tagPOINT
    public Point pt;
    /// char[16]
    [System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.ByValTStr, SizeConst = 16)]
    public string deltas;
}

//將鏈碼指針轉換成結構
MCvChain chain=(MCvChain)Marshal.PtrToStructure(ptrChain,typeof(MCvChain));
//定義存放鏈碼上點的列表
List<Point> pointList = new List<Point>(chain.total);
//鏈碼讀取結構
MCvChainPtReader chainReader = new MCvChainPtReader();
IntPtr ptrReader = Marshal.AllocHGlobal(sizeof(MCvSeqReader) + sizeof(byte) + sizeof(Point) + 16 * sizeof(byte));
Marshal.StructureToPtr(chainReader, ptrReader, false);
//開始讀取鏈碼
cvStartReadChainPoints(ptrChain, ptrReader);
int i = 0;
while (ptrReader != IntPtr.Zero && i < chain.total)
{
    //依次讀取鏈碼上的每個點
    Point p = cvReadChainPoint(ptrReader);
    if (ptrReader == IntPtr.Zero)
         break;
    else
    {
         pointList.Add(p);
         sbChain.AppendFormat("{0},", p);
         i++;
    }
}
imageResult.DrawPolyline(pointList.ToArray(), true, new Bgr(lblExternalColor.BackColor), 2);

        //遍歷輪廓，并生成遍歷結果
        private void TravelContour(Contour<Point> contour,ref int total,ref StringBuilder sbContour)
        {
            if (contour != null)
            {
                sbContour.Append("------------------------\r\n");
                sbContour.AppendFormat("輪廓{0}，右節點：{1}，下級節點：{2}，外接矩形：（{3}）\r\n", total, contour.HNext != null, contour.VNext != null, contour.BoundingRectangle);
                sbContour.AppendFormat("包含{0}個點（面積：{1}，周長：{2}）：\r\n", contour.Total, contour.Area, contour.Perimeter);
                for (int i = 0; i < contour.Total; i++)
                    sbContour.AppendFormat("{0},", contour[i]);
                sbContour.Append("\r\n");
                total++;
                if (contour.HNext != null)
                    TravelContour(contour.HNext, ref total, ref sbContour);
                if (contour.VNext != null)
                    TravelContour(contour.VNext, ref total, ref sbContour);
            }
        }

Image<Bgr, Byte> imageResult = imageThreshold.Convert<Bgr, Byte>();         //結果圖像
int maxLevel = 0;                                                           //繪制的輪廓深度
int.TryParse(txtMaxLevel.Text, out maxLevel);
imageResult.Draw(contour, new Bgr(lblExternalColor.BackColor), new Bgr(lblHoleColor.BackColor), maxLevel, 2);

        //得到關鍵點信息
        private void GetDominantPointsInfo(Contour<Point> contour, ref StringBuilder sbContour, ref Image<Bgr, Byte> imageResult, double parameter1, double parameter2, double parameter3, double parameter4, Bgr dominantPointColor)
        {
            if (contour.Total > 2)
            {
                MemStorage storage = new MemStorage();
                try
                {
                    IntPtr ptrSeq = cvFindDominantPoints(contour.Ptr, storage.Ptr, (int)CV_DOMINANT.CV_DOMINANT_IPAN, parameter1, parameter2, parameter3, parameter4);
                    Seq<int> seq = new Seq<int>(ptrSeq, storage);
                    sbContour.AppendFormat("{0}個關鍵點：\r\n", seq.Total);
                    for (int i = 0; i < seq.Total; i++)
                    {
                        int idx = seq[i];           //關鍵點序列中存儲的數據 是 關鍵點在輪廓中所處位置的索引
                        Point p = contour[idx];     //得到關鍵點的坐標
                        sbContour.AppendFormat("{0}({1},{2}),", idx, p.X, p.Y);
                        imageResult.Draw(new CircleF(new PointF(p.X, p.Y), 3), dominantPointColor, -1);
                    }
                    sbContour.Append("\r\n");
                }
                catch (CvException ex)
                {
                    sbContour.AppendFormat("在獲取關鍵點時發生異常，錯誤描述：{0}，錯誤源：{1}，錯誤堆棧：{2}\r\n錯誤文件：{3}，函數名：{4}，行：{5}，錯誤內部描述：{6}\r\n", ex.Message, ex.Source, ex.StackTrace, ex.FileName, ex.FunctionName, ex.Line, ex.ErrorStr);
                }
                catch (Exception e)
                {
                    sbContour.AppendFormat("在獲取關鍵點時發生異常，錯誤描述：{0}，錯誤源：{1}，錯誤堆棧：{2}\r\n", e.Message, e.Source, e.StackTrace);
                }
                finally
                {
                    storage.Dispose();
                }
            }
        }

        //得到邊界框信息
        private void GetEdgeInfo(Contour<Point> contour, string edge, ref StringBuilder sbContour, ref Image<Bgr, Byte> imageResult, Bgr edgeColor)
        {
            if (edge == "Rect")
                //矩形
                imageResult.Draw(contour.BoundingRectangle, edgeColor, 2);
            else if (edge == "MinAreaRect")
            {
                //最小矩形
                MCvBox2D box = CvInvoke.cvMinAreaRect2(contour.Ptr, IntPtr.Zero);
                PointF[] points = box.GetVertices();
                Point[] ps = new Point[points.Length];
                for (int i = 0; i < points.Length; i++)
                    ps[i] = new Point((int)points[i].X, (int)points[i].Y);
                imageResult.DrawPolyline(ps, true, edgeColor, 2);
            }
            else if (edge == "Circle")
            {
                //圓形
                PointF center;
                float radius;
                CvInvoke.cvMinEnclosingCircle(contour.Ptr, out center, out radius);
                imageResult.Draw(new CircleF(center, radius), edgeColor, 2);
            }
            else
            {
                //橢圓
                if (contour.Total >= 6)
                {
                    MCvBox2D box = CvInvoke.cvFitEllipse2(contour.Ptr);
                    imageResult.Draw(new Ellipse(box), edgeColor, 2);
                }
                else
                    sbContour.Append("輪廓點數小于6，不能創建外圍橢圓。\r\n");
            }
        }

        //得到各種矩的信息
        private void GetMomentsInfo(Contour<Point> contour, ref StringBuilder sbContour)
        {
            //矩
            MCvMoments moments = contour.GetMoments();
            //遍歷各種情況下的矩、中心矩及歸一化矩，必須滿足條件：xOrder>=0; yOrder>=0; xOrder+yOrder<=3;
            for (int xOrder = 0; xOrder <= 3; xOrder++)
            {
                for (int yOrder = 0; yOrder <= 3; yOrder++)
                {
                    if (xOrder + yOrder <= 3)
                    {
                        double spatialMoment = moments.GetSpatialMoment(xOrder, yOrder);
                        double centralMoment = moments.GetCentralMoment(xOrder, yOrder);
                        double normalizedCentralMoment = moments.GetNormalizedCentralMoment(xOrder, yOrder);
                        sbContour.AppendFormat("矩（xOrder：{0}，yOrder：{1}），矩：{2:F09}，中心矩：{3:F09}，歸一化矩：{4:F09}\r\n", xOrder, yOrder, spatialMoment, centralMoment, normalizedCentralMoment);
                    }
                }
            }
            //Hu矩
            MCvHuMoments huMonents = moments.GetHuMoment();
            sbContour.AppendFormat("Hu矩 h1：{0:F09}，h2：{1:F09}，h3：{2:F09}，h4：{3:F09}，h5：{4:F09}，h6：{5:F09}，h7：{6:F09}\r\n", huMonents.hu1, huMonents.hu2, huMonents.hu3, huMonents.hu4, huMonents.hu5, huMonents.hu6, huMonents.hu7);
        }

        //得到凸包及缺陷信息
        private void GetConvexInfo(Contour<Point> contour,ref StringBuilder sbContour,ref Image<Bgr,Byte> imageResult)
        {
            if (!contour.Convex)    //判斷輪廓是否為凸
            {
                //凸包
                Seq<Point> convexHull = contour.GetConvexHull(ORIENTATION.CV_CLOCKWISE);
                //缺陷
                Seq<MCvConvexityDefect> defects = contour.GetConvexityDefacts(new MemStorage(), ORIENTATION.CV_CLOCKWISE);
                //顯示信息
                sbContour.AppendFormat("輪廓的凸包有{0}個點，依次為：", convexHull.Total);
                Point[] points = new Point[convexHull.Total];
                for (int i = 0; i < convexHull.Total; i++)
                {
                    Point p = convexHull[i];
                    points[i] = p;
                    sbContour.AppendFormat("{0},", p);
                }
                sbContour.Append("\r\n");
                imageResult.DrawPolyline(points, true, new Bgr(lblConvexColor.BackColor), 2);
                MCvConvexityDefect defect;
                sbContour.AppendFormat("輪廓有{0}個缺陷，依次為：\r\n", defects.Total);
                for (int i = 0; i < defects.Total; i++)
                {
                    defect = defects[i];
                    sbContour.AppendFormat("缺陷：{0}，起點：{1}，終點：{2}，最深的點：{3}，深度：{4}\r\n", i, defect.StartPoint, defect.EndPoint, defect.DepthPoint, defect.Depth);
                }
            }
            else
                sbContour.Append("輪廓是凸的，凸包和輪廓一樣。\r\n");
        }

            //生成成對幾何直方圖
            Rectangle rect1 = contour1.BoundingRectangle;
            float maxDist1 = (float)Math.Sqrt(rect1.Width * rect1.Width + rect1.Height * rect1.Height); //輪廓的最大距離：這里使用輪廓矩形邊界框的對角線長度
            int[] bins1 = new int[] { 60, 20 };
            RangeF[] ranges1 = new RangeF[] { new RangeF(0f, 180f), new RangeF(0f, maxDist1) };     //直方圖第0維為角度，范圍在(0,180)，第2維為輪廓兩條邊緣線段的距離
            DenseHistogram hist1 = new DenseHistogram(bins1, ranges1);
            CvInvoke.cvCalcPGH(contour1.Ptr, hist1.Ptr);

        //開始匹配
        private void btnStartMatch_Click(object sender, EventArgs e)
        {
            //準備輪廓（這里只比較最外圍的輪廓）
            Image<Bgr, Byte> image1 = new Image<Bgr, byte>((Bitmap)pbImage1.Image);
            Image<Bgr, Byte> image2 = new Image<Bgr, byte>((Bitmap)pbImage2.Image);
            Image<Gray, Byte> imageGray1 = image1.Convert<Gray, Byte>();
            Image<Gray, Byte> imageGray2 = image2.Convert<Gray, Byte>();
            Image<Gray, Byte> imageThreshold1 = imageGray1.ThresholdBinaryInv(new Gray(128d), new Gray(255d));
            Image<Gray, Byte> imageThreshold2 = imageGray2.ThresholdBinaryInv(new Gray(128d), new Gray(255d));
            Contour<Point> contour1 = imageThreshold1.FindContours(CHAIN_APPROX_METHOD.CV_CHAIN_APPROX_SIMPLE, RETR_TYPE.CV_RETR_EXTERNAL);
            Contour<Point> contour2 = imageThreshold2.FindContours(CHAIN_APPROX_METHOD.CV_CHAIN_APPROX_SIMPLE, RETR_TYPE.CV_RETR_EXTERNAL);
            /*if (contour1.Perimeter / 50 > 2 && contour2.Perimeter / 50 > 2)
            {
                contour1 = contour1.ApproxPoly(contour1.Perimeter / 50, 2, new MemStorage());    //對輪廓進行多邊形逼近（參數設為輪廓周長的1/50）
                contour2 = contour2.ApproxPoly(contour2.Perimeter / 50, 2, new MemStorage());
            }*/
            //進行匹配
            string result = "";
            if (rbHuMoments.Checked)
                result = MatchShapes(contour1, contour2);       //Hu矩匹配
            else if (rbContourTree.Checked)
                result = MatchContourTrees(contour1, contour2); //輪廓樹匹配
            else if (rbPGH.Checked)
                result = MatchPghHist(contour1, contour2);      //成對幾何直方圖匹配
            txtResult.Text += result;
        }

        //Hu矩匹配
        private string MatchShapes(Contour<Point> contour1, Contour<Point> contour2)
        {
            //匹配方法
            CONTOURS_MATCH_TYPE matchType = rbHuI1.Checked ? CONTOURS_MATCH_TYPE.CV_CONTOUR_MATCH_I1 : (rbHuI2.Checked ? CONTOURS_MATCH_TYPE.CV_CONTOURS_MATCH_I2 : CONTOURS_MATCH_TYPE.CV_CONTOURS_MATCH_I3);
            Stopwatch sw = new Stopwatch();
            sw.Start();
            //匹配
            double matchValue = contour1.MatchShapes(contour2, matchType);
            sw.Stop();
            double time = sw.Elapsed.TotalMilliseconds;
            return string.Format("Hu矩匹配（{0:G}），結果：{1:F05}，用時：{2:F05}毫秒\r\n", matchType, matchValue, time);
        }

        //輪廓樹匹配
        private string MatchContourTrees(Contour<Point> contour1, Contour<Point> contour2)
        {
            //生成輪廓樹
            double thresholdOfCreate = double.Parse(txtThresholdOfCreateContourTrees.Text); //生成輪廓樹的閥值
            IntPtr ptrTree1 = CvInvoke.cvCreateContourTree(contour1.Ptr, new MemStorage().Ptr, thresholdOfCreate);
            IntPtr ptrTree2 = CvInvoke.cvCreateContourTree(contour2.Ptr, new MemStorage().Ptr, thresholdOfCreate);
            //匹配
            double thresholdOfMatch = double.Parse(txtThresholdOfMatchContourTrees.Text);   //比較輪廓樹的閥值
            Stopwatch sw = new Stopwatch();
            sw.Start();
            double matchValue = CvInvoke.cvMatchContourTrees(ptrTree1, ptrTree2, MATCH_CONTOUR_TREE_METHOD.CONTOUR_TREES_MATCH_I1, thresholdOfMatch);
            sw.Stop();
            double time = sw.Elapsed.TotalMilliseconds;
            return string.Format("輪廓樹匹配（生成輪廓樹的閥值：{0}，比較輪廓樹的閥值：{1}），結果：{2:F05}，用時：{3:F05}毫秒\r\n", thresholdOfCreate, thresholdOfMatch, matchValue, time);
        }

        //成對幾何直方圖匹配
        private string MatchPghHist(Contour<Point> contour1, Contour<Point> contour2)
        {
            //生成成對幾何直方圖
            Rectangle rect1 = contour1.BoundingRectangle;
            float maxDist1 = (float)Math.Sqrt(rect1.Width * rect1.Width + rect1.Height * rect1.Height); //輪廓的最大距離：這里使用輪廓矩形邊界框的對角線長度
            int[] bins1 = new int[] { 60, 20 };
            RangeF[] ranges1 = new RangeF[] { new RangeF(0f, 180f), new RangeF(0f, maxDist1) };     //直方圖第0維為角度，范圍在(0,180)，第2維為輪廓兩條邊緣線段的距離
            DenseHistogram hist1 = new DenseHistogram(bins1, ranges1);
            CvInvoke.cvCalcPGH(contour1.Ptr, hist1.Ptr);
            Rectangle rect2 = contour2.BoundingRectangle;
            float maxDist2 = (float)Math.Sqrt(rect2.Width * rect2.Width + rect2.Height * rect2.Height);
            int[] bins2 = new int[] { 60, 20 };
            RangeF[] ranges2 = new RangeF[] { new RangeF(0f, 180f), new RangeF(0f, maxDist2) };
            DenseHistogram hist2 = new DenseHistogram(bins2, ranges2);
            CvInvoke.cvCalcPGH(contour2.Ptr, hist2.Ptr);
            //匹配
            Stopwatch sw = new Stopwatch();
            sw.Start();
            double compareResult;
            HISTOGRAM_COMP_METHOD compareMethod = rbHistCorrel.Checked ? HISTOGRAM_COMP_METHOD.CV_COMP_CORREL : (rbHistChisqr.Checked ? HISTOGRAM_COMP_METHOD.CV_COMP_CHISQR : (rbHistIntersect.Checked ? HISTOGRAM_COMP_METHOD.CV_COMP_INTERSECT : HISTOGRAM_COMP_METHOD.CV_COMP_BHATTACHARYYA));
            if (rbHistEmd.Checked)
            {
                //EMD
                //將直方圖轉換成矩陣
                Matrix<Single> matrix1 = FormProcessHist.ConvertDenseHistogramToMatrix(hist1);
                Matrix<Single> matrix2 = FormProcessHist.ConvertDenseHistogramToMatrix(hist2);
                compareResult = CvInvoke.cvCalcEMD2(matrix1.Ptr, matrix2.Ptr, DIST_TYPE.CV_DIST_L2, null, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
                matrix1.Dispose();
                matrix2.Dispose();
            }
            else
            {
                //直方圖對比方式
                hist1.Normalize(1d);
                hist2.Normalize(1d);
                compareResult = CvInvoke.cvCompareHist(hist1.Ptr, hist2.Ptr, compareMethod);
            }
            sw.Stop();
            double time = sw.Elapsed.TotalMilliseconds;
            return string.Format("成對幾何直方圖匹配（匹配方式：{0}），結果：{1:F05}，用時：{2:F05}毫秒\r\n", rbHistEmd.Checked ? "EMD" : compareMethod.ToString("G"), compareResult, time);
        }