bbiwarg-original/bbiwarg/Recognition/HandRecognition/HandDetector.cs

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using bbiwarg.Images;
using bbiwarg.Recognition.FingerRecognition;
using bbiwarg.Graphics;
using bbiwarg.Utility;
using Emgu.CV;
using Emgu.CV.Structure;

namespace bbiwarg.Recognition.HandRecognition
{
    class HandDetector
    {
        private EdgeImage edgeImage;
        private List<Finger> fingers;
        public List<Hand> Hands { get; private set; }
        public Image<Gray, byte> HandMask { get; private set; }

        public HandDetector(EdgeImage edgeImage, List<Finger> fingers)
        {
            this.edgeImage = edgeImage;
            this.fingers = fingers;

            detectHands();
        }

        private void detectHands()
        {
            int width = edgeImage.Width;
            int height = edgeImage.Height;
            int maxArea = width * height;
            Image<Gray, byte> image = edgeImage.Image.Copy().Dilate(2).Erode(2).Mul(255);
            HandMask = image.CopyBlank();

            //draw top finger slice
            foreach (Finger finger in fingers)
            {
                Contour<Point> contour = finger.Contour;
                image.FillConvexPoly(contour.ToArray(), new Gray(0));
                image.DrawPolyline(finger.Contour.ToArray(), true, new Gray(255), 1);

                FingerSlice slice = finger.SliceTrail.EndSlice;
                Vector2D direction = slice.LineSegment.Line.Direction;
                Vector2D start = slice.Start + (Constants.FingerContourMargin + Constants.FingerSliceOverlapFactor) * direction;
                Vector2D end = slice.End - (Constants.FingerContourMargin + Constants.FingerSliceOverlapFactor) * direction;
                image.Draw(new Emgu.CV.Structure.LineSegment2D(start, end), new Gray(0), 2);

                //FingerSlice slice = finger.SliceTrail.Slices[1];
                //image.Draw(new Emgu.CV.Structure.LineSegment2D(slice.Start, slice.End), new Gray(255), 2);
            }

            Hands = new List<Hand>();

            foreach (Finger finger in fingers)
            {
                bool newHand = true;
                foreach (Hand hand in Hands)
                {
                    if (hand.isInside(finger.HandPoint))
                    {
                        hand.addFinger(finger);
                        finger.setHand(hand);
                        newHand = false;
                        break;
                    }
                }

                if (newHand)
                {
                    Image<Gray, byte> mask = new Image<Gray, byte>(width + 2, height + 2);
                    MCvConnectedComp comp = new MCvConnectedComp();
                    CvInvoke.cvFloodFill(image, finger.HandPoint, new MCvScalar(255), new MCvScalar(1), new MCvScalar(1), out comp, Emgu.CV.CvEnum.CONNECTIVITY.FOUR_CONNECTED, Emgu.CV.CvEnum.FLOODFILL_FLAG.DEFAULT, mask);
                    if (comp.area < maxArea * Constants.HandMaxSize)
                    {
                        Image<Gray, byte> cropedMask = mask.Copy(new Rectangle(1, 1, width, height)).Dilate(1);
                        Hand hand = new Hand(cropedMask);
                        Hands.Add(hand);
                        hand.addFinger(finger);
                        finger.setHand(hand);

                        HandMask = HandMask.Or(cropedMask);
                    }
                }
            }

            float minX = float.MaxValue;
            foreach (Hand hand in Hands)
            {
                if (hand.Centroid.X < minX)
                    minX = hand.Centroid.X;
            }

            foreach (Hand hand in Hands)
            {
                if (hand.Centroid.X == minX)
                    hand.Side = Hand.HandSide.Left;
                else
                    hand.Side = Hand.HandSide.Right;
            }

            if (Hands.Count == 1 && Hands[0].Fingers.Count == 1)
            {
                if (Hands[0].Centroid.X < Hands[0].Fingers[0].HandPoint.X)
                    Hands[0].Side = Hand.HandSide.Right;
                else
                    Hands[0].Side = Hand.HandSide.Left;
            }
        }
    }
}