How does FindContours cycle through the image? OpenCV 2.3 - c++

Question

We are writing a program that takes input from a webcam, substracts all color except the green values, finds the seperated BLOBs and numerates them. Eventually, this will be used as an input for a video game, but that is irrelevent right now.
The code in question is not the code that actually does all of this, but instead, a rewritten segment of the code to test how FindContours actually works.
Usually, with imageprocessing, we have been tought that the image is read from top left to bottom right, but after some testing, it seems that it does the exact opposite, starting at the lower right corner and moving to the upper left!
So the question here is: In which order does FindContours find it's Contours? Am I right in my assumption or is it my own code confusing me?
Input: Blobtest06
"Components" window
Console
#include <opencv2/opencv.hpp>
#include <iostream>
#include <opencv2/core/mat.hpp>
#include <Windows.h> //for sleep function
using namespace cv;
using namespace std;
void IsolateGreen(Mat mIn, Mat& mOut)
{
Mat inImg (mIn.rows, mIn.cols, CV_8UC3, Scalar(1,2,3));
inImg.data = mIn.data;
Mat channelRed (inImg.rows, inImg.cols, CV_8UC1);
Mat channelGreen (inImg.rows, inImg.cols, CV_8UC1);
Mat channelBlue (inImg.rows, inImg.cols, CV_8UC1);
Mat outImg[] = {channelRed, channelGreen, channelBlue};
int fromTo[] = { 0,2, 1,1, 2,0};
mixChannels( &inImg, 1, outImg, 3, fromTo, 3);
mOut = (channelGreen) - (channelRed + channelBlue);
threshold(mOut, mOut, 5, 255, THRESH_BINARY);
erode(mOut, mOut, Mat(), Point (-1,-1), 1);
dilate(mOut, mOut, Mat(), Point(-1,-1), 2);
}
void FindContours(Mat& mDst, Mat mGreenScale, vector<vector<Point>>& vecContours, vector<Vec4i>& vecHierarchy, Mat img)
{
//This is empty at all times. We need it to avoid crashes.
vector<Vec4i> vecHierarchy2;
// mGreenScale = mGreenScale > 1; //// MIGHT be entirely unneeded
mDst = img > 1;
findContours( mGreenScale, vecContours, vecHierarchy,
CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE );
/* Colors, in order:
1st. = Red
2nd. = Dark red
3rd. = Purple
4th. = Blue
5th. = Baby blue
6th. = Green
7th. = Olive green
8th. = Dark green
*/
int aRed[] = {255, 100, 128, 0, 191, 0, 202, 0};
int aGreen[] = {0, 0, 0, 0, 239, 255, 255, 100};
int aBlue[] = {0, 0, 128, 255, 255, 0, 112, 0};
string sColor[] = {"Red", "Dark red", "Purple", "Blue", "Baby blue", "Green", "Light green", "Dark green"};
//its important that we check if there is anything in vecHierarchy (else) {crash} :P
//function drawContours cannot handle an empty vedHierarchy
if (vecHierarchy != vecHierarchy2)
{
// iterate through all the top-level contours,
for(int idx = 0; idx >= 0; idx = vecHierarchy[idx][0] )
{
// draw each connected component with its own FIXED color
Scalar color( aBlue[idx], aGreen[idx], aRed[idx] );
drawContours( mDst, vecContours, idx, color, /*1*/ CV_FILLED, 8, vecHierarchy );
cout << vecContours[idx][0] << " - - " << sColor[idx] << " - - Index: " << idx << endl;
}
}
cout << "Objects: ";
cout << vecContours.size();
cout << endl;
}
int main()
{
Mat img = imread("Blobtest06.png");
Mat mGreenScale;
//These next 5 instances ties to contourfinding
cvtColor(img, mGreenScale, CV_8UC3); //sets the right rows and cols
vector<vector<Point>> vecContours; //points to each pixel in a contour
vector<Vec4i> vecHierarchy; //A hierarchy for the functions
Mat mDst = Mat::zeros(mGreenScale.rows, mGreenScale.cols, CV_8UC3); //mDst image
IsolateGreen(img, mGreenScale);
FindContours(mDst, mGreenScale, vecContours, vecHierarchy, img);
namedWindow( "Components", 1 );
imshow( "Components", mDst );
namedWindow( "Source", 1 );
imshow( "Source", mGreenScale );
waitKey();
return 0;
}
PS: Sorry for horrible syntax. The site is being difficult and it's just about lunchtime.

Answer 1

If you care about the details of implementation of OpenCV, which is an Open Source library by the way, you can always download the source and read it yourself.
Warning: the C++ API uses the C API for some things, including FindCountours(). So if you check the file: modules/imgproc/src/contours.cpp line 1472 you'll see the C++ implementation of this function:
1472 void cv::findContours( InputOutputArray _image, OutputArrayOfArrays _contours,
1473 OutputArray _hierarchy, int mode, int method, Point offset )
1474 {
1475 Mat image = _image.getMat();
1476 MemStorage storage(cvCreateMemStorage());
1477 CvMat _cimage = image;
1478 CvSeq* _ccontours = 0;
1479 if( _hierarchy.needed() )
1480 _hierarchy.clear();
1481 cvFindContours(&_cimage, storage, &_ccontours, sizeof(CvContour), mode, method, offset);
1482 if( !_ccontours )
1483 {
1484 _contours.clear();
1485 return;
1486 }
calling cvFindContours(), which is from the C API, defined in this same file on line 1424.
The scanning process itself is described on cvFindNextContour(), located at line 794:
793 CvSeq *
794 cvFindNextContour( CvContourScanner scanner )
795 {
and you can clearly see:
824 for( ; y < height; y++, img += step )
825 {
826 for( ; x < width; x++ )
827 {