Lucas-Kanade & Farneback

LucasKanade Tracker

        // Check if there are points to track

```
        if(!trackingPoints[0].empty())
```
```
        {
```

            // Status vector to indicate whether the flow for the corresponding features has been found

```
            vector<uchar> statusVector;
```
```
 
```

            // Error vector to indicate the error for the corresponding feature

```
            vector<float> errorVector;
```
```
 
```

            // Check if previous image is empty

```
            if(prevGrayImage.empty())
```
```
            {
```

                curGrayImage.copyTo(prevGrayImage);

```
            }
```
```
 
```

            // Calculate the optical flow using Lucas-Kanade algorithm

            calcOpticalFlowPyrLK(prevGrayImage, curGrayImage, trackingPoints[0], trackingPoints[1], statusVector, errorVector, windowSize, 3, terminationCriteria, 0, 0.001);

```
 
```
```
            int count = 0;
```
```
 
```

            // Minimum distance between any two tracking points

```
            int minDist = 7;
```
```
 
```

            for(int i=0; i < trackingPoints[1].size(); i++)

```
            {
```
```
                if(pointTrackingFlag)
```
```
                {
```

                    // If the new point is within 'minDist' distance from an existing point, it will not be tracked

                    if(norm(currentPoint - trackingPoints[1][i]) <= minDist)

```
                    {
```

                        pointTrackingFlag = false;

```
                        continue;
```
```
                    }
```
```
                }
```
```
 
```

                // Check if the status vector is good

```
                if(!statusVector[i])
```
```
                    continue;
```
```
 
```

                trackingPoints[1][count++] = trackingPoints[1][i];

```
 
```

                // Draw a filled circle for each of the tracking points

```
                int radius = 8;
```
```
                int thickness = 2;
```
```
                int lineType = 8;
```

                circle(image, trackingPoints[1][i], radius, Scalar(0,255,0), thickness, lineType);

```
            }
```
```
 
```

            trackingPoints[1].resize(count);

```
        }
```
```
 
```

        // Refining the location of the feature points

        if(pointTrackingFlag && trackingPoints[1].size() < maxNumPoints)

```
        {
```
```
            vector<Point2f> tempPoints;
```

            tempPoints.push_back(currentPoint);

```
 
```

            // Function to refine the location of the corners to subpixel accuracy.

            // Here, 'pixel' refers to the image patch of size 'windowSize' and not the actual image pixel

            cornerSubPix(curGrayImage, tempPoints, windowSize, cvSize(-1,-1), terminationCriteria);

```
 
```

            trackingPoints[1].push_back(tempPoints[0]);

```
            pointTrackingFlag = false;
```
```
        }
```

Farneback Tracker

```
        // Check if the image is valid
```
```
        if(prevGray.data)
```
```
        {
```

            // Initialize parameters for the optical flow algorithm

```
            float pyrScale = 0.5;
```
```
            int numLevels = 3;
```
```
            int windowSize = 15;
```
```
            int numIterations = 3;
```
```
            int neighborhoodSize = 5;
```
```
            float stdDeviation = 1.2;
```
```
 
```

            // Calculate optical flow map using Farneback algorithm

            calcOpticalFlowFarneback(prevGray, curGray, flowImage, pyrScale, numLevels, windowSize, numIterations, neighborhoodSize, stdDeviation, OPTFLOW_USE_INITIAL_FLOW);

```
 
```
```
            // Convert to 3-channel RGB
```

            cvtColor(prevGray, flowImageGray, COLOR_GRAY2BGR);

```
 
```

            // Draw the optical flow map

            drawOpticalFlow(flowImage, flowImageGray);

```
 
```
```
            // Display the output image
```

            imshow(windowName, flowImageGray);

```
        }
```