EmguCV: ऑप्टिकल फ्लो का उपयोग करके मोशन में ऑब्जेक्ट पर समोच्च बनाएं?

Question

मैं गति में ऑब्जेक्ट को हटाने या ओवरले को आकर्षित करने के लिए अग्रभूमि में निकालने के लिए सी # (इमगुसीवी 3.0 का उपयोग करके) में गति का पता लगाना चाहता हूं।

यहां नमूने के परीक्षण मैं एक Kinect के साथ किया

मैं कैसे EmguCV 3.0 के साथ शुरू कर सकते हैं (क्योंकि यह एक गहराई कैमरा है) है?

• मुझे लगता है कि
• काम नहीं करते ऐसा लगता है OpticalFlow एक अच्छी शुरुआत है, लेकिन EmguCV 3.0
• में कोई उदाहरण सी अगर मैं सबसे बड़ा ब्लॉब मैं अपनी आकृति कैसे पा सकते हैं खोजने के कई पृष्ठभूमि हटाने कोड की कोशिश की?

कोई मुझे शुरू करने में मदद कर सकता है?

संपादित करें: http://www.emgu.com/wiki/files/3.0.0-rc1/document/html/b72c032d-59ae-c36f-5e00-12f8d621dfb8.htm

वहाँ केवल है: 17/06/2015

EmguCV3.0.0 आर सी में मैं पैकेज और दस्तावेज में OpticalFlow नहीं दिख रहा है DenseOpticalFlow, OpticalFlowDualTVL1 ???

यह एक AbsDiff कोड है:

var grayFrame = frame.Convert<Gray, Byte>(); 
var motionFrame = grayFrame.AbsDiff(backFrame) 
          .ThresholdBinary(new Gray(20), new Gray(255)) 
          .Erode(2) 
          .Dilate(2); 

परिणाम:

मैं कैसे सफेद में गति प्राप्त करने के लिए पता नहीं है?

इस ब्लॉब कोड है:

Image<Bgr, Byte> smoothedFrame = new Image<Bgr, byte>(frame.Size); 
CvInvoke.GaussianBlur(frame, smoothedFrame, new Size(3, 3), 1); //filter out noises 

Mat forgroundMask = new Mat(); 
fgDetector.Apply(smoothedFrame, forgroundMask); 

CvBlobs blobs = new CvBlobs(); 
blobDetector.Detect(forgroundMask.ToImage<Gray, byte>(), blobs); 
blobs.FilterByArea(400, int.MaxValue); 
blobTracker.Update(blobs, 1.0, 0, 1); 

foreach (var pair in blobs) { 
    CvBlob b = pair.Value; 
    CvInvoke.Rectangle(frame, b.BoundingBox, new MCvScalar(255.0, 255.0, 255.0), 2); 
} 

परिणाम:

क्यों इतना झूठी सकारात्मक?

यह एक MOG2 कोड है:

forgroundDetector.Apply(frame, forgroundMask); 
motionHistory.Update(forgroundMask); 
var motionMask = GetMotionMask(); 
Image<Bgr, Byte> motionImage = new Image<Bgr, byte>(motionMask.Size); 
CvInvoke.InsertChannel(motionMask, motionImage, 0); 

Rectangle[] rects; 
using (VectorOfRect boundingRect = new VectorOfRect()) { 
    motionHistory.GetMotionComponents(segMask, boundingRect); 
    rects = boundingRect.ToArray(); 
} 

foreach (Rectangle comp in rects) { ... 

परिणाम:

अगर मैं सबसे बड़ी क्षेत्र का चयन कैसे मैं वस्तु की समोच्च मिल सकता है?

Answer 1

सबसे पहले, मैं आपको कुछ उदाहरण ऑप्टिकल फ्लो कोड दे सकता हूं।

oldImage और newImage पिछले और वर्तमान फ्रेम को रखने वाले चर हो। मेरे कोड में, यह Image<Gray, Byte> प्रकार है।

// prep containers for x and y vectors 
Image<Gray, float> velx = new Image<Gray, float>(newImage.Size); 
Image<Gray, float> vely = new Image<Gray, float>(newImage.Size); 

// use the Horn and Schunck dense optical flow algorithm. 
OpticalFlow.HS(oldImage, newImage, true, velx, vely, 0.1d, new MCvTermCriteria(100)); 

// color each pixel 
Image<Hsv, Byte> coloredMotion = new Image<Hsv, Byte>(newImage.Size); 
for (int i = 0; i < coloredMotion.Width; i++) 
{ 
    for (int j = 0; j < coloredMotion.Height; j++) 
    { 
     // Pull the relevant intensities from the velx and vely matrices 
     double velxHere = velx[j, i].Intensity; 
     double velyHere = vely[j, i].Intensity; 

     // Determine the color (i.e, the angle) 
     double degrees = Math.Atan(velyHere/velxHere)/Math.PI * 90 + 45; 
     if (velxHere < 0) 
     { 
      degrees += 90; 
     } 
     coloredMotion.Data[j, i, 0] = (Byte) degrees; 
     coloredMotion.Data[j, i, 1] = 255; 

     // Determine the intensity (i.e, the distance) 
     double intensity = Math.Sqrt(velxHere * velxHere + velyHere * velyHere) * 10; 
     coloredMotion.Data[j, i, 2] = (intensity > 255) ? 255 : intensity; 
    } 
} 
// coloredMotion is now an image that shows intensity of motion by lightness 
// and direction by color. 

कैसे अग्रभूमि दूर करने के लिए की बड़ा सवाल के बारे में:

अगर मैं एक स्थिर पृष्ठभूमि छवि प्राप्त करने के लिए एक रास्ता था, कि सबसे अच्छा तरीका शुरू करने के लिए है।फिर, AbsDiff method द्वारा अग्रभूमि का पता लगाया जाएगा और छवि को सुचारू बनाने के लिए Erode और Dilate या Gaussian का उपयोग किया जाएगा, फिर ब्लॉब पहचान का उपयोग करें।

सरल अग्रभूमि पहचान के लिए, मैंने ऑप्टिकल फ्लो को बहुत अधिक प्रोसेसिंग (8fps अधिकतम) के रूप में पाया, जबकि एब्सडिफ विधि बिल्कुल सटीक थी लेकिन फ़्रेमेट पर कोई प्रभाव नहीं पड़ा।

समोच्चों के संबंध में, यदि आप केवल आकार, स्थिति और अन्य क्षणों को ढूंढ रहे हैं, तो उपरोक्त AbsDiff ट्यूटोरियल में ब्लॉब डिटेक्शन पर्याप्त प्रतीत होता है, जो Image.FindContours(...) का उपयोग करता है।

यदि नहीं, तो मैं में उपयोग किए गए CvBlobDetector कक्षा को देखना शुरू कर दूंगा। एक अंतर्निहित DrawBlob फ़ंक्शन है जो आसानी से आ सकता है।