Esempio n. 1
0
        /// <summary>
        /// Copy part of image based on mask
        /// </summary>
        /// <param name="currentImage">Current frame YUV</param>
        /// <param name="mask">Object contain Object Silhouette and it's top, lower,right and left point </param>
        /// <returns>copied Image YUV</returns>
        static public Image <Ycc, Byte> CopyImage(Image <Ycc, Byte> currentImage, MaskData mask)
        {
            Image <Ycc, Byte> dest = new Image <Ycc, byte>(mask.Mask.Width, mask.Mask.Height, new Ycc(0, 0, 0));
            int sourceRow          = mask.Top.X;
            int sourceCol          = mask.left.Y * 3;
            int sourceTemp;
            int destCol  = 0;
            int destTemp = 0;
            int maskTemp = 0;

            unsafe
            {
                fixed(byte *ptrcurrentImage = currentImage.Data)
                {
                    fixed(byte *ptrMask = mask.Mask.Data)
                    {
                        fixed(byte *ptrdest = dest.Data)
                        {
                            for (int row = 0; row < mask.Mask.Height; row++)
                            {
                                maskTemp   = row * (mask.Mask.Data.Length / mask.Mask.Height);
                                sourceTemp = sourceRow * ((currentImage.Data.Length / 3) / currentImage.Height) * 3;
                                destTemp   = row * ((dest.Data.Length / 3) / dest.Height) * 3;
                                for (int col = 0; col < mask.Mask.Data.Length / mask.Mask.Height; col++)
                                {
                                    if (*(ptrMask + maskTemp + col) != 0)
                                    {
                                        *(ptrdest + destTemp + destCol)     = *(ptrcurrentImage + sourceTemp + sourceCol);
                                        *(ptrdest + destTemp + destCol + 1) = *(ptrcurrentImage + sourceTemp + sourceCol + 1);
                                        *(ptrdest + destTemp + destCol + 2) = *(ptrcurrentImage + sourceTemp + sourceCol + 2);
                                    }
                                    sourceCol += 3;
                                    destCol   += 3;
                                }
                                destCol   = 0;
                                sourceCol = mask.left.Y * 3;
                                sourceRow++;
                            }
                        }
                    }
                }
            }
            return(dest);
        }
        public Image <Gray, Byte> DetectAndTrack(Mat currentImage)
        {
            Image <Gray, Byte>   tmp2;
            Image <Gray, Byte>   imgReturn;
            Image <Ycc, Byte>    imgYcc;
            List <ComponentData> connectedComp;
            List <ComponentData> humans   = new List <ComponentData>();
            MaskData             maskData = new MaskData();

            imgYcc = currentImage.ToImage <Ycc, Byte>();
            Mat rect_12 = CvInvoke.GetStructuringElement(Emgu.CV.CvEnum.ElementShape.Cross, new Size(5, 5), new Point(3, 3));

            //_bgSubrctObj.Apply(currentImage, currentImage);
            imgReturn     = currentImage.ToImage <Gray, Byte>();
            tmp2          = imgReturn.MorphologyEx(Emgu.CV.CvEnum.MorphOp.Close, rect_12, new Point(3, 3), 1, Emgu.CV.CvEnum.BorderType.Default, new MCvScalar());
            connectedComp = _connectedCompObj.Find_ConnectedComponent(tmp2);
            foreach (ComponentData comp in connectedComp)
            {
                maskData.Mask   = comp.Silhouette.Clone();
                maskData.left   = comp.LeftPoint;
                maskData.Right  = comp.RightPoint;
                maskData.Top    = comp.UpperPoint;
                maskData.Bottom = comp.LowerPoint;
                //comp.Label = 0;
                comp.Label = (byte)_tracking.Track(imgYcc, maskData);// _tracking.Track(currentImage, maskData);
                if (comp.Label != 255)
                {
                    humans.Add(comp);
                }
            }
            Load();
            // humans = classify(connectedComp);
            // trainImage(connectedComp[0].Silhouette);
            // Save();
            imgReturn = connectedComp[0].Silhouette;
            return(imgReturn);
        }
Esempio n. 3
0
        public int Track(Image <Ycc, Byte> currentImage, MaskData mask)
        {
            Image <Ycc, Byte>  blob    = CopyImage(currentImage, mask);
            Image <Gray, Byte> Newblob = getColorImage(blob);

            int[]  histogram        = getHistogram(Newblob, mask.Mask);
            int    nHistogram       = getN_Histogram(histogram);
            double comparisonResult = 0;
            double min         = 160;
            int    objectLabel = -1;
            int    refIndex    = -1;
            bool   foundref    = false;

            int center = getCentered(mask.left.Y, mask.Right.Y);

            if (_reference.Count == 0)
            {
                return(AddNewObject(blob, Newblob, histogram, nHistogram, center));
            }
            else
            {
                for (int i = 0; i < _reference.Count; i++)
                {
                    comparisonResult = Math.Abs(center - _reference[i].TheCenter);
                    if (comparisonResult <= 10)
                    {
                        foundref = true;
                        if (min > comparisonResult)
                        {
                            _reference[i].TheCenter = center;

                            objectLabel = _reference[i].ObjectLabel;
                            refIndex    = i;
                        }
                    }
                }
                if (foundref)
                {
                    foundref = false;
                    _reference[refIndex].TheCenter = center;
                    if (_reference[refIndex].Direction == 1 && _reference[refIndex].TheCenter > 159)
                    {
                        _reference.RemoveAt(refIndex);
                    }
                    else
                    if (_reference[refIndex].Direction == 2 && _reference[refIndex].TheCenter < 1)
                    {
                        _reference.RemoveAt(refIndex);
                    }
                    return(objectLabel);
                }
            }
            if (center > 25 && center < 145 && findOccultation)
            {
                //MessageBox.Show(center.ToString() + " " + mask.left.Y.ToString() + " " + mask.Right.Y.ToString());
                findOccultation = false;
                foreach (ReferenceHumanImage refHmn in _reference)
                {
                    if (mask.left.Y < refHmn.TheCenter && mask.Right.Y > refHmn.TheCenter)
                    {
                        //MessageBox.Show(refHmn.ObjectLabel.ToString() + "    " + refHmn.TheCenter.ToString());
                        if (refHmn.DirectionSetted && refHmn.Direction == 1)
                        {
                            refHmn.TheCenter = mask.Right.Y + 10;
                        }
                        else
                        if (refHmn.DirectionSetted && refHmn.Direction == 2)
                        {
                            refHmn.TheCenter = mask.left.Y - 10;
                        }
                        //MessageBox.Show(refHmn.ObjectLabel.ToString() + "    " + refHmn.TheCenter.ToString());
                    }
                }
                return(255);
            }
            if (center > 25 && center < 145)
            {
                //MessageBox.Show(center.ToString());
                return(255);
            }
            return(AddNewObject(blob, Newblob, histogram, nHistogram, center));
        }