Coding Life

안녕하세요

이번 포스팅에서는 OpenCvSharp 기능을 통해서 이미지속의 피부색을 검출하고 검출된 영역에

윤곽선을 표기하고 표시된 윤곽선 내부에 포함된 오목 부분을 추가 검출하여 손가락의 구분을 

나누어 보도록 하겠습니다

이번 포스팅도 OpenCvSharp 기능 구현 포스팅으로 처음 포스팅 내용과 이어지는 부분이

존재합니다

이해가 잘 되지 않으시다면 앞전 포스팅을 읽어보시고 보신다면 이해가 좀 더 빠를거 같아서

아래 OpenCvSharp의 처음 포스팅을 링크해 드리겠습니다

https://codingman.tistory.com/49

[디자인]

- 메뉴버튼을 생성합니다

-생성한 메뉴에 클릭시 발생할 이벤트를 생성합니다

-생성된 클릭 이벤트 부분에 아래와 같이 코딩해줍니다

[Source Code]

        private void 피부색검출ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            ConvextyDefect Cx = new ConvextyDefect();
            Cx.ConvextyDefectb();
        }

- 그다음 피부색 검출을 위한 기능 구현을 위해 클래스 파일을 생성합니다

   (클래스명칭은 ConvextyDefect.cs로 생성하였습니다.)

[Source Code]

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using OpenCvSharp;
using OpenCvSharp.Blob;
using OpenCvSharp.CPlusPlus;
using OpenCvSharp.UserInterface;

namespace OpenCV_V1
{
    class ConvextyDefect
    {
        public void ConvextyDefectb()
        {
            using (IplImage imgSrc = new IplImage("hand.jpg", LoadMode.Color))
            using (IplImage imgHSV = new IplImage(imgSrc.Size, BitDepth.U8, 3))
            using (IplImage imgH = new IplImage(imgSrc.Size, BitDepth.U8, 1))
            using (IplImage imgS = new IplImage(imgSrc.Size, BitDepth.U8, 1))
            using (IplImage imgV = new IplImage(imgSrc.Size, BitDepth.U8, 1))
            using (IplImage imgBackProjection = new IplImage(imgSrc.Size, BitDepth.U8, 1))
            using (IplImage imgFlesh = new IplImage(imgSrc.Size, BitDepth.U8, 1))
            using (IplImage imgHull = new IplImage(imgSrc.Size, BitDepth.U8, 1))
            using (IplImage imgDefect = new IplImage(imgSrc.Size, BitDepth.U8, 3))
            using (IplImage imgContour = new IplImage(imgSrc.Size, BitDepth.U8, 3))
            using (CvMemStorage storage = new CvMemStorage())
            {
                //RGB -> HSV
                Cv.CvtColor(imgSrc, imgHSV, ColorConversion.BgrToHsv);
                Cv.CvtPixToPlane(imgHSV, imgH, imgS, imgV, null);
                IplImage[] hsvPlanes = { imgH, imgS, imgV };

                //피부색 영역을 구한다
                RetrieveFleshRegion(imgSrc, hsvPlanes, imgBackProjection);
                
                //최대의 면적의 영역을 남긴다
                FilterByMaximalBolb(imgBackProjection, imgFlesh);
                Interpolate(imgFlesh);

                //윤곽을 구한다
                CvSeq<CvPoint> contours = FindContours(imgFlesh, storage);
                if(contours != null)
                {
                    Cv.DrawContours(imgContour, contours, CvColor.Red, CvColor.Green, 0, 3, LineType.AntiAlias);

                    //요철을 구한다
                    int[] hull;
                    Cv.ConvexHull2(contours, out hull, ConvexHullOrientation.Clockwise);
                    Cv.Copy(imgFlesh, imgHull);

                    DrawConvexHull(contours, hull, imgHull);

                    //오목한 상태 결손을 구한다
                    Cv.Copy(imgContour, imgDefect);
                    CvSeq<CvConvexityDefect> defect = Cv.ConvexityDefects(contours, hull);
                    DrawDefects(imgDefect, defect);

                }
                using (new CvWindow("src", imgSrc))
                using (new CvWindow("back projection", imgBackProjection))
                using (new CvWindow("hull", imgHull))
                using (new CvWindow("defect", imgDefect))
                {
                    Cv.WaitKey();
                }
            }
        }

        ///<summary>
        ///백 프로젝션에 의해 피부색 영역을 구한다
        ///</summary>
        ///<param name="imgSrc"></param>
        ///<param name="hsvPlanes"></param>
        ///<param name="imgDst"></param>
        private void RetrieveFleshRegion(IplImage imgSrc, IplImage[] hsvPlanes, IplImage imgDst)
        {
            int[] histSize = new int[] { 30, 32 };
            float[] hRanges = { 0.0f, 20f };
            float[] sRanges = { 50f, 255f };
            float[][] ranges = { hRanges, sRanges };
            imgDst.Zero();
            using (CvHistogram hist = new CvHistogram(histSize, HistogramFormat.Array, ranges, true))
            {
                hist.Calc(hsvPlanes, false, null);
                float minValue, maxValue;
                hist.GetMinMaxValue(out minValue, out maxValue);
                hist.Normalize(imgSrc.Width * imgSrc.Height * 255 / maxValue);
                Cv.CalcBackProject(hsvPlanes, imgDst, hist);
            }
        }

        ///<summary>
        ///라벨링에 의해 최대 면적의 영역을 남긴다
        ///</summary>
        ///<param name="imgSrc"></param>
        ///<param name="imgDst"></param>
        private void FilterByMaximalBolb(IplImage imgSrc, IplImage imgDst)
        {
            CvBlobs blobs = new CvBlobs();

            imgDst.Zero();
            blobs.Label(imgSrc);
            CvBlob max = blobs.GreaterBlob();
            if (max == null)
            {
                return;
            }
            blobs.FilterByArea(max.Area, max.Area);
            blobs.FilterLabels(imgDst);
        }

        ///<summary>
        ///결손 영역을 보완한다
        ///</summary>
        ///<param name="img"></param>
        private void Interpolate(IplImage img)
        {
            Cv.Dilate(img, img, null, 2);
            Cv.Erode(img, img, null, 2);
        }

        ///<summary>
        ///윤곽을 얻는다
        ///</summary>
        ///<param name="img"></param>
        ///<param name="storage"></param>
        ///<returns></returns>
        private CvSeq<CvPoint> FindContours(IplImage img, CvMemStorage storage)
        {
            //윤곽 추출
            CvSeq<CvPoint> contours;
            using (IplImage imgClone = img.Clone())
            {
                Cv.FindContours(imgClone, storage, out contours);
                if(contours == null)
                {
                    return null;
                }
                contours = Cv.ApproxPoly(contours, CvContour.SizeOf, storage, ApproxPolyMethod.DP, 3, true);
            }

            //제일 긴 것 같은 윤곽만을 얻는다
            CvSeq<CvPoint> max = contours;
            for(CvSeq<CvPoint> c = contours; c != null; c=c.HNext)
            {
                if(max.Total < c.Total)
                {
                    max = c;
                }
            }
            return max;
        }

        ///<summary>
        ///ConvexHull 그리기
        ///</summary>
        ///<param name="contours"></param>
        ///<param name="hull"></param>
        ///<param name="img"></param>
        private void DrawConvexHull(CvSeq<CvPoint> contours, int[] hull, IplImage img)
        {
            CvPoint pt0 = contours[hull.Last()].Value;

            foreach(int idx in hull)
            {
                CvPoint pt = contours[idx].Value;
                Cv.Line(img, pt0, pt, new CvColor(255, 255, 255));
                pt0 = pt;
            }

        }

        ///<summary>
        ///ConvexityDefects 그리기
        ///</summary>
        ///<param name="img"></param>
        ///<param name="defect"></param>
        private void DrawDefects(IplImage img, CvSeq<CvConvexityDefect> defect)
        {
            int count = 0;
            foreach(CvConvexityDefect item in defect)
            {
                CvPoint p1 = item.Start, p2 = item.End;
                double dist = Getdistance(p1, p2);
                CvPoint2D64f mid = GetMidpoint(p1, p2);
                img.DrawLine(p1, p2, CvColor.White, 3);
                img.DrawCircle(item.DepthPoint, 10, CvColor.Green, -1);
                img.DrawLine(mid, item.DepthPoint, CvColor.White, 1);
                Console.WriteLine("No:{0} Depth:{1} Dist:{2}", count, item.Depth, dist);
                count++;
            }
        }

        ///<summary>
        ///2점간의 거리를 얻는다
        ///</summary>
        ///<param name="p1"></param>
        ///<param name="p2"></param>
        ///<returns></returns>
        private double Getdistance(CvPoint p1, CvPoint p2)
        {
            return Math.Sqrt(Math.Pow(p1.X - p2.X, 2) + Math.Pow(p1.Y - p2.Y, 2));
        }

        ///<summary>
        ///2점의 중점을 얻는다
        ///</summary>
        ///<param name="p1"></param>
        ///<param name="p2"></param>
        ///<returns></returns>
        private CvPoint2D64f GetMidpoint(CvPoint p1, CvPoint p2)
        {
            return new CvPoint2D64f
            {
                X = (p1.X + p2.X) / 2.0,
                Y = (p1.Y + p2.Y) / 2.0
            };
        }
    }
}

- "hand.jgp"파일은 해당 프로젝트의 Debug 폴더에 넣으시면 되고 예제 파일은 제가 사용한 파일을 업로드

하겠습니다

- 이렇게 이미지 파일을 넣은 뒤 빌드하여 실행하시면 다음과 같은 결과가 나타나게 됩니다

[결과 창]

*원본이미지

* Back projection

*hull

*defect

안녕하세요

저번 포스팅에서 점멸을 포함하는 사각형 그리기에 대해 포스팅 했었는데요

https://codingman.tistory.com/67

이번 포스팅에서는 형태와 상관없이 외곽 점들을 연결시켜 영역을 지정하는것을 해볼려고 합니다

OpenCvSharp 함수 중에 ConvexHull2 이라는 함수를 사용해서 구현을 해볼려고 합니다

이번 포스팅 역시 OpenCvSharp를 이어서 진행 되니 처음 시작 하시는 분의 경우 앞 포스팅을 확인하시기

바랍니다

https://codingman.tistory.com/49

처음에 할 것을 역시 버튼 만들기 겠죠?

[디자인]

- Menu에서 다음과 같이 메뉴를 등록시켜 주세요

- 다음은 컨벡스 헐이라는 메뉴를 클릭 했을때 동작 할 수 있도록 클릭 이벤트를 생성 합니다

- 클릭 이벤트를 생성한뒤 해당 이벤트 발생 지점에 다음과 같으 코딩을 해줍니다

        private void 컨벡스헐ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            CvWindow wind = new CvWindow("결과창");
            convex Cx = new convex();
            Cx.ConvexHull(this.pictureBoxIpl1, this.pictureBoxIpl2, wind);
        }

- 랜덤 점 생성과 생성된 점들의 외곽을 구하고 그 외곽을 연결시키는 기능을 실행할 클래스를 생성합니다

  (클래스 파일 생성은 첫 포스팅에서 확인하세요)

- 생성된 클래스 파일에 다음과 같은 기능을 할 코딩 소스를 넣어 짭니다

  (오류 수정과 테스트로 인한 주석이 존재하니 양해 바랍니다)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using OpenCvSharp;
using OpenCvSharp.UserInterface;

namespace OpenCV_V1
{
    class convex
    {
        IplImage _dst;

        public void ConvexHull(PictureBoxIpl p1, PictureBoxIpl p2, CvWindow wind)
        {

            IplImage img = Cv.CreateImage(new CvSize(500, 500), BitDepth.U8, 3);
            Random rand = new Random();

            int count = rand.Next() % 100 + 1;

            //임의의 점 생성
            CvPoint[] ptseq = new CvPoint[count];
            for (int i = 0; i < count; i++)
            {
                ptseq[i] = new CvPoint
                {
                    X = rand.Next() % (img.Width),
                    Y = rand.Next() % (img.Height)
                };

                /*
                CvPoint pt = new CvPoint
                {
                    X = rand.Next() % (img.Width / 2) + img.Width / 4,
                    Y = rand.Next() % (img.Height / 2) + img.Height / 4
                };
                Cv.SeqPush<CvPoint>(ptseq, pt);
                */
            }


            // 점 그리기
            Cv.Zero(img);
            foreach(CvPoint pt in ptseq)
            {
                Cv.Circle(img, pt, 2, new CvColor(255, 0, 0), -1);
            }

            /*
            for (int i = 0; i < count; i++)
            {
                CvPoint pt = Cv.GetSeqElem<CvPoint>(ptseq, i).Value;
                Cv.Circle(img, pt, 2, new CvColor(255, 0, 0), -1);
            }
            */

            //임의의 점 그린 사진 보여주기
            p1.ImageIpl = img;

            _dst = img.Clone();

            // Hull 찾기
            CvPoint[] hull;
            Cv.ConvexHull2(ptseq, out hull, ConvexHullOrientation.Clockwise);

            //Hull 그리기
            CvPoint pt0 = hull[hull.Length - 1];
            foreach (CvPoint pt in hull)
            {
                Cv.Line(_dst, pt0, pt, CvColor.Green, 3, LineType.AntiAlias);
                pt0 = pt;
            }

            /*
            for (int i = 0; i < hull.Total; i++)
            {
                CvPoint pt = Cv.GetSeqElem<Pointer<CvPoint>>(hull, i).Value.Entity;             // CvPoint pt = **CV_GET_SEQ_ELEM( CvPoint*, hull, i );
                Cv.Line(img, pt0, pt, new CvColor(0, 255, 0));
                pt0 = pt;
            }
            */

            p2.ImageIpl = _dst;
            wind.Image = _dst;
            img.Dispose();
        }
    }
}

- 필드 후 실행한 결과 화면 입니다