OpenCV- Working with OpenCV

If you found these codes useful buy me a beer

2020-06-12T06:54:00.001-07:00

If you found these codes useful buy me a beer

Results Update Feb 4

2012-02-03T23:01:00.000-08:00

getting SURF points of any image

2012-01-10T04:17:00.000-08:00

this post uses OPENCV 2.2 and a simple change of the extract feature will allow use on version 2.3

class atsSURF
{
public:
    cv::Mat extractPoints(cv::Mat img)
    {
        int minHessian = 500;
        cv::SurfFeatureDetector detector(minHessian);
        std::vector<cv::KeyPoint> keypoints;
        detector.detect(img,keypoints,img); //opencv 2.2
        //detector.detect(img,keypoints); //opencv 2.3

        cv::SurfDescriptorExtractor extractor;
        cv::Mat descriptor;
        extractor.compute(img,keypoints,descriptor);
        thisDescriptor = descriptor;
        thisKeypoints = keypoints;

        cv::Mat outim = img;
        cv::drawKeypoints(img,keypoints,outim,Scalar::all(-1),

                               cv::DrawMatchesFlags::DEFAULT);
        return outim;
    }
private:
    cv::Mat thisDescriptor;
    std::vector<cv::KeyPoint> thisKeypoints; 
};

to run from the main function

int main(int argc, char* argv[])
{
char code = (char)-1;
atsImages im("C:/Users/Aresh/Documents/Visual Studio 2010/Projects/opencvTest/Debug/test_connectedComponent_sameColor_sameShape.jpg");
Mat img = im.read("gray");

atsSURF mypoints;



//cv::Mat ima_gray; //in case in RGB

//cv::cvtColor(img,ima_gray,CV_BGR2GRAY); //convert to gray scale

//cv::Mat outim = mypoints.extractPoints(ima_gray);

 
cv::Mat outim = mypoints.extractPoints(img);
cv::imshow("SURF points", outim);
 code = (char)waitKey();
 return 0;
}

and thats all. dont forget the SURF descriptor only accepts GRAY level images. if you feed it a colored image, it will give you the following error:

Unhandled exception at xxxxxx in opencv.exe: Microsoft C++ exception:
cv::Exception at memory location xxxxxxx

Entropy and Gini index experiments

2012-01-01T02:37:00.000-08:00

Conclusion:
1. Entropy and Gini index are unique when color and shape are different
2. Entropy and Gini Index are unique (Small Difference) Color remains the same but different shape
3. Entropy and Gini Index are unique (smaller difference) Color and shape are the same Area and size

Shape and Color are the same, however entropy is unique, Gini Index is even more unique

Blob Detection, Connected Component (Pure Opencv)

2011-12-31T03:10:00.000-08:00

Connected-component labeling (alternatively connected-component analysis, blob extraction, region labeling, blob discovery, or region extraction) is an algorithmic application of graph theory, where subsets of connected components are uniquely labeled based on a given heuristic. Connected-component labeling is not to be confused with segmentation.

i got the initial code from this URL: http://nghiaho.com/?p=1102
However the code did not compile with my setup of OpenCV 2.2, im guessing it was an older version. so a refactored and corrected the errors to come up with this Class

class atsBlobFinder
    {
    public:
        atsBlobFinder()
        {
        }
        ///Original Code by http://nghiaho.com/?p=1102
        ///Changed and added commments. Removed Errors
        ///works with VS2010 and OpenCV 2.2+
        void FindBlobs(const cv::Mat &binary, vector < vector<cv::Point> > &blobs)
        {
            blobs.clear();

            // Fill the label_image with the blobs
            // 0 - background
            // 1 - unlabelled foreground
            // 2+ - labelled foreground

            ///input is a binary image therefore values are either 0 or 1
            ///out objective is to find a set of 1's that are together and assign 2 to it
            ///then look for other 1's, and assign 3 to it....so on a soforth

            cv::Mat label_image;
            binary.convertTo(label_image, CV_32FC1); // weird it doesn't support CV_32S! Because the CV::SCALAR is a double value in the function floodfill

            int label_count = 2; // starts at 2 because 0,1 are used already

            //erode to remove noise-------------------------------
            Mat element = getStructuringElement( MORPH_RECT,
            Size( 2*3 + 1, 2*3+1 ),
            Point( 0, 0 ) );
            /// Apply the erosion operation
            erode( label_image, label_image, element );
            //---------------------------------------------------

            //just check the Matrix of label_image to make sure we have 0 and 1 only
            //cout << label_image << endl;

            for(int y=0; y < binary.rows; y++) {
                for(int x=0; x < binary.cols; x++) {
                    float checker = label_image.at<float>(y,x); //need to look for float and not int as the scalar value is of type double
                    cv::Rect rect;
                    //cout << "check:" << checker << endl;
                    if(checker == 1) {
                        //fill region from a point
                        cv::floodFill(label_image, cv::Point(x,y), cv::Scalar(label_count), &rect, cv::Scalar(0), cv::Scalar(0), 4);
                        label_count++;
                        //cout << label_image << endl <<"by checking: " << label_image.at<float>(y,x) <<endl;
                        //cout << label_image;

                        //a vector of all points in a blob
                        std::vector<cv::Point> blob;

                        for(int i=rect.y; i < (rect.y+rect.height); i++) {
                            for(int j=rect.x; j < (rect.x+rect.width); j++) {
                                float chk = label_image.at<float>(i,j);
                                //cout << chk << endl;
                                if(chk == label_count-1) {
                                    blob.push_back(cv::Point(j,i));
                                }
                            }
                        }
                        //place the points of a single blob in a grouping
                        //a vector of vector points
                        blobs.push_back(blob);
                    }
                }
            }
            cout << label_count <<endl;
            imshow("label image",label_image);
        }
    private:
    };

From the code comments, ive answered and tested a few parts which the original author did not discuss.

Running on Visual Studio 2010 and OpenCV 2.2 using the 4 connected neighbors and opencv internal function FloodFill.

1. Get the Binary image. the binary image should have values of 0 and 1 only.
2. go through each pixel and find the value 1, floodfill and replace all 1 with a counter ie. number 2
3. every blob found should now be part of floodfill and all neighbors value changed to an ascending number
4. from each blob, get the x and y coordinate of that blob and save it in a vector. giving you a vector<Point>
5. save each of those Vector<Point> into another Vector which represents all the blobs found
6. Output the value

atsBlobFinder blb;
cv::Mat output = cv::Mat::zeros(img.size(), CV_8UC3); //3 Channels

            cv::Mat binary;
            vector <vector<cv::Point>> blobs;

            blb.FindBlobs(binary, blobs);
            for(size_t i=0; i < blobs.size(); i++) {
                unsigned char r = 255 * (rand()/(1.0 + RAND_MAX));
                unsigned char g = 255 * (rand()/(1.0 + RAND_MAX));
                unsigned char b = 255 * (rand()/(1.0 + RAND_MAX));

                for(size_t j=0; j < blobs[i].size(); j++) {
                    int x = blobs[i][j].x;
                    int y = blobs[i][j].y;

                    output.at<Vec3b>(y,x)[0] = ima.at<uchar>(y,x); //channel 1
                    output.at<Vec3b>(y,x)[1] = ima.at<uchar>(y,x); //channel 2
                    output.at<Vec3b>(y,x)[2] = ima.at<uchar>(y,x); //channel 3
                }
            }
            imshow("con comp",output);

the vector<vector<Point>> blobs can create a mask and output the blob in separate images

Computing Gini Index of an image (measure of Impurity)

2011-12-28T02:43:00.000-08:00

Using my previous posts Class file and this reference:
http://people.revoledu.com/kardi/tutorial/DecisionTree/how-to-measure-impurity.htm

float computeGiniIndex(Mat r, Mat g, Mat b)

{

        float giniIndex = 0.0;

        float frequency = getFrequencyOfBin(r);

        for( int i = 1; i < histSize; i++ )

{

            float Hc = abs(getHistogramBinValue(r,i));

            giniIndex += Hc*Hc;

}

        frequency = getFrequencyOfBin(g);

        for( int i = 1; i < histSize; i++ )

{

            float Hc = abs(getHistogramBinValue(g,i));

            giniIndex += Hc*Hc;

}

        frequency = getFrequencyOfBin(b);

        for( int i = 1; i < histSize; i++ )

{

            float Hc = abs(getHistogramBinValue(b,i));

            giniIndex += Hc*Hc;

}

        giniIndex = 1 - (giniIndex);

        //cout << giniIndex <<endl;

        return giniIndex;

}

Computing Entropy of an image (CORRECTED)

2011-12-23T21:04:00.000-08:00

entropy is a measure of the uncertainty associated with a random variable.
basically i want to get a single value representing the entropy of an image.

1. Assign 255 bins for the range of values between 0-255
2. separate the image into its 3 channels
3. compute histogram for each channel
4. normalize all 3 channels unifirmely
~~5. for each channel get the bin value (Hc) and use its absolute value (negative log is infinity)~~
~~6. compute Hc*log10(Hc)~~
~~7. add to entropy and continue with 5 until a single value converges~~
5. get the frequency of each channel - add all the values of the bin
6. for each bin get a probability -
if bin 1 = 20
bin 2 = 30
then frequency is 50 and probability is 20/50 and 30/50
then compute using shannon formula

REFERENCE: http://people.revoledu.com/kardi/tutorial/DecisionTree/how-to-measure-impurity.htm

~~class atsHistogram~~
{
~~public:~~
    ~~cv::Mat DrawHistogram(Mat src)~~
    {
        ~~/// Separate the image in 3 places ( R, G and B )~~
        ~~vector<Mat> rgb_planes;~~
        ~~split( src, rgb_planes );~~

        ~~/// Establish the number of bins~~
        ~~int histSize = 255;~~

        ~~/// Set the ranges ( for R,G,B) )~~
        ~~float range[] = { 0, 255 } ;~~
        ~~const float* histRange = { range };~~

        ~~bool uniform = true; bool accumulate = false;~~

        ~~Mat r_hist, g_hist, b_hist;~~

        ~~/// Compute the histograms:~~
        ~~calcHist( &rgb_planes[0], 1, 0, Mat(), r_hist, 1, &histSize, &histRange, uniform, accumulate );~~
        ~~calcHist( &rgb_planes[1], 1, 0, Mat(), g_hist, 1, &histSize, &histRange, uniform, accumulate );~~
        ~~calcHist( &rgb_planes[2], 1, 0, Mat(), b_hist, 1, &histSize, &histRange, uniform, accumulate );~~

        ~~// Draw the histograms for R, G and B~~
        ~~int hist_w = 400; int hist_h = 400;~~
        ~~int bin_w = cvRound( (double) hist_w/histSize );~~

        ~~Mat histImage( hist_w, hist_h, CV_8UC3, Scalar( 0,0,0) );~~

        ~~/// Normalize the result to [ 0, histImage.rows ]~~
        ~~normalize(r_hist, r_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );~~
        ~~normalize(g_hist, g_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );~~
        ~~normalize(b_hist, b_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );~~

        ~~/// Draw for each channel~~
        ~~/*for( int i = 1; i < histSize; i++ )~~
           {
            ~~line( histImage, Point( bin_w*(i-1), hist_h - cvRound(r_hist.at<float>(i-1)) ) ,~~
                            ~~Point( bin_w*(i), hist_h - cvRound(r_hist.at<float>(i)) ),~~
                            ~~Scalar( 0, 0, 255), 2, 8, 0 );~~
            ~~line( histImage, Point( bin_w*(i-1), hist_h - cvRound(g_hist.at<float>(i-1)) ) ,~~
                            ~~Point( bin_w*(i), hist_h - cvRound(g_hist.at<float>(i)) ),~~
                            ~~Scalar( 0, 255, 0), 2, 8, 0 );~~
            ~~line( histImage, Point( bin_w*(i-1), hist_h - cvRound(b_hist.at<float>(i-1)) ) ,~~
                            ~~Point( bin_w*(i), hist_h - cvRound(b_hist.at<float>(i)) ),~~
                            ~~Scalar( 255, 0, 0), 2, 8, 0 );~~
            ~~}*/~~
~~double entropy = (double)computeShannon(r_hist,g_hist,b_hist);~~
        ~~//printf("Entropy: %f" , entropy );~~
        ~~cout << entropy << endl;~~
        ~~return histImage;~~
    }
    ~~float getHistogramBinValue(Mat hist, int binNum)~~
    {
        ~~//return cvRound(hist.at<float>(binNum));~~
        ~~return hist.at<float>(binNum);~~
    }
    ~~float computeShannon(Mat r, Mat g, Mat b)~~
    {
        ~~int histSize = 255; //number of bins~~
        ~~float entropy = 0.0;~~
        ~~for( int i = 1; i < histSize; i++ )~~
        {
            ~~float Hc = abs(getHistogramBinValue(r,i));~~
            ~~//cout << "Red " << Hc << endl;~~
            ~~entropy += Hc * log10(Hc);~~
            ~~//cout << "-" << Hc << " -n- " << entropy << endl;~~
        }
        ~~for( int i = 1; i < histSize; i++ )~~
        {
            ~~float Hc = abs(getHistogramBinValue(g,i));~~
            ~~//cout << "Green " << Hc << endl;~~
            ~~entropy += Hc * log10(Hc);~~
        }
        ~~for( int i = 1; i < histSize; i++ )~~
        {
            ~~float Hc = abs(getHistogramBinValue(b,i));~~
            ~~//cout << "Blue " << Hc << endl;~~
            ~~entropy += Hc * log10(Hc);~~
        }
        ~~entropy = entropy * -1;~~
        ~~//cout << entropy <<endl;~~
        ~~return entropy;~~
    }
~~private:~~
};

     float getHistogramBinValue(Mat hist, int binNum)

{

        return hist.at<float>(binNum);

}

    float getFrequencyOfBin(Mat channel)

{

        float frequency = 0.0;

        for( int i = 1; i < histSize; i++ )

{

            float Hc = abs(getHistogramBinValue(channel,i));

            frequency += Hc;

}

        return frequency;

}

    float computeShannonEntropy(Mat r, Mat g, Mat b)

{

        float entropy = 0.0;

        float frequency = getFrequencyOfBin(r);

        for( int i = 1; i < histSize; i++ )

{

            float Hc = abs(getHistogramBinValue(r,i));

            entropy += -(Hc/frequency) * log10((Hc/frequency));

}

        frequency = getFrequencyOfBin(g);

        for( int i = 1; i < histSize; i++ )

{

            float Hc = abs(getHistogramBinValue(g,i));

            entropy += -(Hc/frequency) * log10((Hc/frequency));

}

        frequency = getFrequencyOfBin(b);

        for( int i = 1; i < histSize; i++ )

{

            float Hc = abs(getHistogramBinValue(b,i));

            entropy += -(Hc/frequency) * log10((Hc/frequency));

}

        entropy = entropy;

        //cout << entropy <<endl;

        return entropy;

}

Opencv 2.3.1 Installation

2011-10-08T01:14:00.000-07:00

alright it took me a while before posting this. for OPENCV 2.3.1 and Visual studio 2010 Professional on a windows 7 64 bit environment

Download The "super pack" and unzip to "C:\OPENCV"
it seems you can only get the source of opencv and need to compile it with CMAKE.
very straight forward.
download CMAKE and use the command prompt to enter CMAKE CMAKELIST.txt at the opencv directory

Open "ALL_BUILD" by double clicking - opens up visual studio
Compile it and wait. (took a minute)
go to properties and select the release version and compile again (took another minute)

your all set with the opencv installation "c:\opencv\build"

create an empty visual studio "win32 console application"

Click on Configuration Properties->VC++ Directories, and edit the Include Directories. Add:

C:\opencv\build\common\tbb30_20110427oss\include (UPDATE)
C:\opencv\build\include

Click on Configuration Properties->VC++ Directories, and edit the Library Directories. Add:
C:\opencv\build\common\tbb30_20110427oss\lib\ia32\vc10 (UPDATE)
C:\opencv\build\x86\vc10\lib

Click on Configuration Properties->Linker->Input, and edit the Additional Dependencies. Add:
opencv_core231d.lib
opencv_imgproc231d.lib
opencv_highgui231d.lib
opencv_ml231d.lib
opencv_video231d.lib
opencv_features2d231d.lib
opencv_calib3d231d.lib
opencv_objdetect231d.lib
opencv_contrib231d.lib
opencv_legacy231d.lib
opencv_flann231d.lib

Click on Configuration Properties->Debugging, and edit the Environment.
PATH=C:\opencv\build\x86\vc10\bin;C:\opencv\build\common\tbb30_20110427oss\bin\ia32\vc10

Your all set.

(UPDATE)
i realized when trying to compile lkdemo.cpp an error:

even though opencv has a tbb folder in the build/common it does not include the complete library so we need to download the whole version from http://threadingbuildingblocks.org/ver.php?fid=171
and unzip it to "c:\opencv\build\common". there is no need to compile it as its already ready for use.

just make the additional changes to the library and include and bin files for this to work.

Condensation algorithm (particle filter) in Legacy opencv

2011-09-19T02:10:00.001-07:00

you need to include the following include:
#include <opencv2/legacy/legacy.hpp>

Create an instance
CvConDensation* ConDens = cvCreateConDensation( DP, MP, nSamples );

for every X and Y coordinate

initialize and update the condensation

refracted Code to Follow

Blobs with opencv (internal function)

2011-09-17T07:49:00.000-07:00

There are many open source opencv BLOB libraries that you can use. i have tried several of these, however because of the 64 bit machine that im using recompiling these are very troublesome.

If you have heard of these libraries:

"cvBlobsLib": http://opencv.willowgarage.com/wiki/cvBlobsLib
"cvBlob": http://code.google.com/p/cvblob/
"Bloblib" by Dave Grossman (also referred to as "Blob Analysis Package"):
Go to http://tech.groups.yahoo.com/group/OpenCV/files/

You will know that opencv also has a built in function that can help you find blobs using cv::findContour and see some statistics using the cv::moments.
eventually make these functions similar to regionprops Matlab function

The BLOB FINDER CLASS:

class atsBlobFinder
{
public:
    atsBlobFinder(cv::Mat src)
    {
        numBlobs = 0;
        cv::Mat img; //must create a temporary Matrix to hold the gray scale or wont work
        cv::cvtColor(src,img,CV_BGR2GRAY); //Convert image to GrayScale
        img = img > 1; //create the binary image
        ////cv::adaptiveThreshold(src,src,64,ADAPTIVE_THRESH_MEAN_C,THRESH_BINARY,7,13); //create a binary image

        findContours( img, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE ); //Find the Contour BLOBS
        vector<Moments> _mu(contours.size() );
        vector<Point2f> _mc( contours.size() );
        for( int i = 0; i < contours.size(); i++ )
        {
            _mu[i] = moments( Mat(contours[i]), false );
            _mc[i] = Point2f( _mu[i].m10/_mu[i].m00 , _mu[i].m01/_mu[i].m00);
        }
        mu = _mu;
        mc = _mc;
        numBlobs = contours.size();
    }
    void Draw(cv::Mat &dst)
    {
        // iterate through all the top-level contours,
        // draw each connected component with its own random color
        for( int i = 0; i < contours.size(); i++ )
        {
            Scalar color( rng.uniform(0,255), rng.uniform(0,255), rng.uniform(0,255) );
            drawContours( dst, contours, i, color, CV_FILLED, 8, hierarchy );
            // drawCross(mc[i],Scalar(0,0,255), 5,dst); //put a cross
            char buff[255];
            sprintf(buff, "%d", i);

            string text = std::string(buff);
            cv::putText(dst,text,mc[i],0,0.5,Scalar(0,0,255),1,8,false);
        }
    }
    int getNumBlobs()
    {
        //need to create a buffer for output or wrong reference
        /*char buff[255];
        sprintf(buff, "%d", numBlobs);*/
        return numBlobs;
    }
private:
    vector<vector<Point> > contours;
    vector<Vec4i> hierarchy;
    vector<Moments> mu;
    vector<Point2f> mc;
    int numBlobs;
};

#include <iostream>

// Include OpenCV
#include <opencv/cv.h>
#include <opencv/highgui.h>

using namespace cv;
#define drawCross( center, color, d, drawing )                                 \
            line( drawing, Point( center.x - d, center.y - d ),                \
            Point( center.x + d, center.y + d ), color, 2, CV_AA, 0); \
            line( drawing, Point( center.x + d, center.y - d ),                \
            Point( center.x - d, center.y + d ), color, 2, CV_AA, 0 )

RNG rng(12345);
int main( int argc, char** argv )
{
    Mat src;
    // the first command line parameter must be file name of binary
    // (black-n-white) image
    if(!(src=imread("pic6.png", CV_LOAD_IMAGE_GRAYSCALE)).data)
    {
        printf("OOOPS");
        waitKey(0);
        return -1;
    }

    Mat dst = Mat::zeros(src.rows, src.cols, CV_8UC3);

    src = src > 1;
    //cv::adaptiveThreshold(src,src,64,ADAPTIVE_THRESH_MEAN_C,THRESH_BINARY,7,13);
    namedWindow( "Source", 1 );
    imshow( "Source", src );

    vector<vector<Point> > contours;
    vector<Vec4i> hierarchy;

    findContours( src, contours, hierarchy,
        CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE );

    /// Get the moments
    vector<Moments> mu(contours.size() );
    vector<Point2f> mc( contours.size() );
    for( int i = 0; i < contours.size(); i++ )
        {
            mu[i] = moments( Mat(contours[i]), false );
            mc[i] = Point2f( mu[i].m10/mu[i].m00 , mu[i].m01/mu[i].m00);
        }

    // iterate through all the top-level contours,
    // draw each connected component with its own random color
    for( int i = 0; i < contours.size(); i++ )
    {
        Scalar color( rng.uniform(0,255), rng.uniform(0,255), rng.uniform(0,255) );
        drawContours( dst, contours, i, color, CV_FILLED, 8, hierarchy );
        // drawCross(mc[i],Scalar(0,0,255), 5,dst); //put a cross
        char buff[255];
        sprintf(buff, "%d", i);

        string text = std::string(buff);
        cv::putText(dst,text,mc[i],0,0.5,Scalar(0,0,255),1,8,false);
    }


    namedWindow( "Components", 1 );
    imshow( "Components", dst );
    waitKey(0);
}

finding the center of gravity in opencv

2011-09-17T04:51:00.000-07:00

Alot of feature detectors such as the Haar classifier will return rectangular shapes presented as a detected feature.

one of the things to do in order to track these, is to find the center of the rectangle.

int main( int argc, char** argv )
{
atscameraCapture movie;
char code = (char)-1;
for(;;)
        {
            //get camera
            cv::Mat imgs = movie.ats_getImage();

#define drawCross( center, color, d, img )                                 \
            line( img, Point( center.x - d, center.y - d ),                \
            Point( center.x + d, center.y + d ), color, 2, CV_AA, 0); \
            line( img, Point( center.x + d, center.y - d ),                \
            Point( center.x - d, center.y + d ), color, 2, CV_AA, 0 )

            cv::Point center;

            //given 2 points representing the rectangle
            cv::Point topLeft(100,100);
            cv::Point bottomRight(200,200);
            cv::rectangle(imgs,topLeft,bottomRight,Scalar( 0, 255, 255 ),-1, 8 );

            //compute for center of triangle
            center.x = (topLeft.x+bottomRight.x)/2;
            center.y = (topLeft.y+bottomRight.y)/2;
            drawCross(center,Scalar(0,0,255), 5,imgs);

            imshow("camera", imgs);
            code = (char)waitKey(100);

            if( code == 27 || code == 'q' || code == 'Q' )
            break;
        }
return 0;

}

Another way of finding the center of gravity is using the internal function of OPENCV called cv::moments

Mat canny_output;
vector<vector<Point> > contours;
vector<Vec4i> hierarchy;
RNG rng(12345);

/** @function main */
int main( int argc, char** argv )
{
atscameraCapture movie;
char code = (char)-1;
for(;;)
        {
            //get camera
            cv::Mat src_gray;
            cv::Mat imgs = movie.ats_getImage();

#define drawCross( center, color, d, img )                                 \
            line( img, Point( center.x - d, center.y - d ),                \
            Point( center.x + d, center.y + d ), color, 2, CV_AA, 0); \
            line( img, Point( center.x + d, center.y - d ),                \
            Point( center.x - d, center.y + d ), color, 2, CV_AA, 0 )

            /// Convert image to gray and blur it
            cvtColor( imgs, src_gray, CV_BGR2GRAY );
            blur( src_gray, src_gray, Size(3,3) );



            /// Detect edges using canny
            Canny( src_gray, canny_output, 10, 50, 3 );
            /// Find contours
            findContours( canny_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );

            /// Get the moments
            vector<Moments> mu(contours.size() );
            for( int i = 0; i < contours.size(); i++ )
                { mu[i] = moments( Mat(contours[i]), false ); }

            /// Get the mass centers:
            vector<Point2f> mc( contours.size() );
            for( int i = 0; i < contours.size(); i++ )
                { mc[i] = Point2f( mu[i].m10/mu[i].m00 , mu[i].m01/mu[i].m00 );
            }
               Mat drawing = Mat::zeros( canny_output.size(), CV_8UC3 );
            for( int i = 0; i< contours.size(); i++ )
                {
                   Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
                   drawContours( drawing, contours, i, color, 2, 8, hierarchy, 0, Point() );
                   circle( drawing, mc[i], 4, color, -1, 8, 0 );
            printf(" * Contour[%d] - Area (M_00) = %.2f - Area OpenCV: %.2f - Length: %.2f \n", i, mu[i].m00, contourArea(Mat(contours[i])), arcLength( Mat(contours[i]), true ) );


            }

            namedWindow( "Contours", CV_WINDOW_AUTOSIZE );
            imshow( "Contours", drawing );

            //imshow("camera", src_gray);
            code = (char)waitKey(1000);

            if( code == 27 || code == 'q' || code == 'Q' )
            break;
        }
return 0;

}

2D/3D estimation using solvePnP in opencv (NOT SOLVED)

2011-09-12T22:02:00.000-07:00

In opencv "solvePnP" is used to find known points on a known 3D object. doing so the objects orientation relative to the camera coordinate system can be found.
the function is equivalent to finding the extrinsic camera parameters. which makes me believe its more for planar objects. need to do a few more experiments to find out why.

im using code from:
http://www.morethantechnical.com/2010/03/19/quick-and-easy-head-pose-estimation-with-opencv-w-code/

#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/calib3d/calib3d.hpp>
#include <opencv2/highgui/highgui.hpp>

#include <iostream>
#include <string>

using namespace cv;

#include <vector>

using namespace std;

#include <GL/gl.h>
#include <GL/glu.h>
#include <glut.h>

void loadNext();
void loadWithPoints(Mat& ip, Mat& img);

const GLfloat light_ambient[] = { 0.0f, 0.0f, 0.0f, 1.0f };
const GLfloat light_diffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f };
const GLfloat light_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
const GLfloat light_position[] = { 2.0f, 5.0f, 5.0f, 0.0f };

const GLfloat mat_ambient[]    = { 0.7f, 0.7f, 0.7f, 1.0f };
const GLfloat mat_diffuse[]    = { 0.8f, 0.8f, 0.8f, 1.0f };
const GLfloat mat_specular[]   = { 1.0f, 1.0f, 1.0f, 1.0f };
const GLfloat high_shininess[] = { 100.0f };

double rot[9] = {0};
Vec3d eav;
GLuint textureID;
Mat backPxls;
vector<double> rv(3), tv(3);
Mat rvec(rv),tvec(tv);
Mat camMatrix;

void resize(int width, int height)
{
    const float ar = (float) width / (float) height;

    glViewport(0, 0, width, height);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(40,1.0,0.01,1000.0);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity() ;
}

int __w=250,__h=250;

void key(unsigned char key, int x, int y)
{
    //static int counter = 0;

    switch (key)
    {
    case 27 :
    case 'Q':
    case 'q':
        break;
    case ' ':
        loadNext();

        glBindTexture(GL_TEXTURE_2D, textureID);//This binds the texture to a texture target
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);//set our filter
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);    //set our filter
        glTexImage2D(GL_TEXTURE_2D, 0, 3, backPxls.cols, backPxls.rows, 0, GL_RGB, GL_UNSIGNED_BYTE, backPxls.data);

        break;
    default:
        break;
    }

    glutPostRedisplay();
}

void idle(void)
{
    glutPostRedisplay();
}

void myGLinit() {
    glClearColor(1,1,1,1);

    glShadeModel(GL_SMOOTH);

    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);

    glEnable(GL_LIGHT0);
    glEnable(GL_NORMALIZE);
    glEnable(GL_COLOR_MATERIAL);
    glColorMaterial ( GL_FRONT, GL_AMBIENT_AND_DIFFUSE );

    glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
    glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
    glLightfv(GL_LIGHT0, GL_POSITION, light_position);

    glMaterialfv(GL_FRONT, GL_AMBIENT,   mat_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE,   mat_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
    glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);

    glEnable(GL_LIGHTING);

    glGenTextures(1, &textureID);
}

void display(void)
{
    glClearColor(1.0f, 1.0f, 1.0f, 0.5f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);    // Clear Screen And Depth Buffer

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    gluLookAt(0,0,0,0,0,1,0,1,0);

    //----------Axes
    glPushMatrix();
    glTranslated(0,0,5);

    glPushMatrix();
    double _d[16] = {    rot[0],rot[1],rot[2],0,
                        rot[3],rot[4],rot[5],0,
                        rot[6],rot[7],rot[8],0,
                        0,       0,    0        ,1};
    glMultMatrixd(_d);
    glRotated(180,1,0,0);

    //Z = red
    glPushMatrix();
    glRotated(180,0,1,0);
    glColor3d(1,0,0);
    glutSolidCone(0.05,1,15,20);
    glTranslated(0,0,1);
    glScaled(.1,.1,.1);
    glutSolidTetrahedron();
    glPopMatrix();

    //Y = green
    glPushMatrix();
    glRotated(-90,1,0,0);
    glColor3d(0,1,0);
    glutSolidCone(0.05,1,15,20);
    glTranslated(0,0,1);
    glScaled(.1,.1,.1);
    glutSolidTetrahedron();
    glPopMatrix();

    //X = blue
    glPushMatrix();
    glRotated(-90,0,1,0);
    glColor3d(0,0,1);
    glutSolidCone(0.05,1,15,20);

    glTranslated(0,0,1);
    glScaled(.1,.1,.1);
    glutSolidTetrahedron();
    glPopMatrix();

    glPopMatrix();
    glPopMatrix();
    //----------End axes

    glutSwapBuffers();
}

int start_opengl_with_stereo(int argc,char** argv) {
    glutInitWindowSize(250,250);
    glutInitWindowPosition(40,40);
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE);
    glutCreateWindow("3D points coordinate");

    myGLinit();

    glutReshapeFunc(resize);
    glutDisplayFunc(display);
    glutKeyboardFunc(key);
    glutIdleFunc(idle);

    glutMainLoop();

    return 1;
}

Mat op;

void loadNext() {
    vector<Point2f > points;

float x,y;

x=282;y=274;
points.push_back(cv::Point2f(x,y));
x=397;y=227;
points.push_back(cv::Point2f(x,y));
x=577;y=271;
points.push_back(cv::Point2f(x,y));
x=462;y=318;
points.push_back(cv::Point2f(x,y));
x=270;y=479;
points.push_back(cv::Point2f(x,y));
x=450;y=523;
points.push_back(cv::Point2f(x,y));
x=566;y=475;
points.push_back(cv::Point2f(x,y));

    Mat ip(points);

    Mat img = Mat::zeros( 800, 600, CV_8UC3 );
    for(unsigned int i = 0; i < points.size(); ++i)
    {
    std::cout << points[i] << std::endl;
    cv::circle(img,points[i],2,cv::Scalar(0, 0, 255, 0),1,8,0);
    }
    loadWithPoints(ip,img);

}

void loadWithPoints(Mat& ip, Mat& img) {
    double _dc[] = {0,0,0,0};
    solvePnP(op,ip,camMatrix,Mat(1,4,CV_64FC1,_dc),rvec,tvec,true);

    Mat rotM(3,3,CV_64FC1,rot);
    Rodrigues(rvec,rotM);
    double* _r = rotM.ptr<double>();

    Mat tmp,tmp1,tmp2,tmp3,tmp4,tmp5;
    double _pm[12] = {_r[0],_r[1],_r[2],0,
                    _r[3],_r[4],_r[5],0,
                    _r[6],_r[7],_r[8],0};
    decomposeProjectionMatrix(Mat(3,4,CV_64FC1,_pm),tmp,tmp1,tmp2,tmp3,tmp4,tmp5,eav);
    imshow("tmp",img);
}

int main(int argc, char** argv)
{

    vector<Point3f > modelPoints;
    float x,y,z;

x=.5;y=.5;z=-.5;
modelPoints.push_back(cv::Point3f(x,y,z));
x=.5;y=.5;z=.5;
modelPoints.push_back(cv::Point3f(x,y,z));
x=-.5;y=.5;z=.5;
modelPoints.push_back(cv::Point3f(x,y,z));
x=-.5;y=.5;z=-.5;
modelPoints.push_back(cv::Point3f(x,y,z));
x=.5;y=-.5;z=-.5;
modelPoints.push_back(cv::Point3f(x,y,z));
x=-.5;y=-.5;z=-.5;
modelPoints.push_back(cv::Point3f(x,y,z));
x=-.5;y=-.5;z=.5;
modelPoints.push_back(cv::Point3f(x,y,z));

    op = Mat(modelPoints);

    rvec = Mat(rv);
    double _d[9] = {1,0,0,
                    0,-1,0,
                    0,0,-1};
    Rodrigues(Mat(3,3,CV_64FC1,_d),rvec);
    tv[0]=0;tv[1]=0;tv[2]=1;
    tvec = Mat(tv);
    double _cm[9] = { 40, 0, 400,
                    0, 40, 500,
                    0, 0,   40 }; //caliberation matrix PROBLEM!?
    camMatrix = Mat(3,3,CV_64FC1,_cm);

    namedWindow("tmp",1);
    loadNext();

    start_opengl_with_stereo(argc,argv);

    return 0;
}

Opencv with OpenGL (installation and trials)

2011-09-12T20:46:00.000-07:00

so i needed to install opengl for a 2D/3D test using opencv

since Opengl libraries come preinstalled just needed to download GLUT from:
http://www.xmission.com/~nate/glut.html

since im running on a 64bit machine i need to place the GLUT32.dll in the C:\Windows\SysWOW64 instead of C:\Windows\System32

i then place the GLUT.h in the:
C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include

and the GLUT32.lib in the
C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\lib

in the visual studio dependencies i just add the following:
opengl32.lib
glut32.lib
glu32.lib

and im all set and good to go with the test program

/**********************************
Simple.cpp
A simple GLUT program.

****************************************************************************/

#include <string.h>
#include <glut.h>

void mydisplay( void )
{
    glClearColor (0.0, 0.0, 0.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT);

    /* set drawing/fill color to white */

    glColor3f(1.0, 1.0, 1.0);

    /* set up standard orthogonal view with clipping */
    /* box as cube of side 2 centered at origin */
    /* This is default view and these statement could be removed */

    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();
    glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
    /* define unit square polygon */

    glBegin(GL_POLYGON);
    glVertex2f(-0.5, -0.5);
    glVertex2f(-0.5, 0.5);
    glVertex2f(0.5, 0.5);
    glVertex2f(0.5, -0.5);
    glEnd();

    /* flush GL buffers */

    glFlush();}

/**************************************** main() ********************/
void init()
{
    glClearColor (0.0, 0.0, 0.0, 1.0);

    glColor3f(1.0, 1.0, 1.0);

    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();
    glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
}

void main(int argc, char* argv[])
{
    glutInit(&argc,argv);
    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(500,500);
    glutInitWindowPosition(0,0);
    glutCreateWindow("simple");
    glutDisplayFunc(mydisplay);

    init();

    glutMainLoop();

}

Histogram computation on a video

2011-09-04T17:40:00.000-07:00

Histograms are collected counts of data organized into a set of predefined bins

refracted class for histogram: given an input image, output the histogram image

class atsHistogram
{
public:
    cv::Mat DrawHistogram(Mat src)
    {
        /// Separate the image in 3 places ( R, G and B )
        vector<Mat> rgb_planes;
        split( src, rgb_planes );

        /// Establish the number of bins
        int histSize = 255;

        /// Set the ranges ( for R,G,B) )
        float range[] = { 0, 255 } ;
        const float* histRange = { range };

        bool uniform = true; bool accumulate = false;

        Mat r_hist, g_hist, b_hist;

        /// Compute the histograms:
        calcHist( &rgb_planes[0], 1, 0, Mat(), r_hist, 1, &histSize, &histRange, uniform, accumulate );
        calcHist( &rgb_planes[1], 1, 0, Mat(), g_hist, 1, &histSize, &histRange, uniform, accumulate );
        calcHist( &rgb_planes[2], 1, 0, Mat(), b_hist, 1, &histSize, &histRange, uniform, accumulate );

        // Draw the histograms for R, G and B
        int hist_w = 400; int hist_h = 400;
        int bin_w = cvRound( (double) hist_w/histSize );

        Mat histImage( hist_w, hist_h, CV_8UC3, Scalar( 0,0,0) );

        /// Normalize the result to [ 0, histImage.rows ]
        normalize(r_hist, r_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
        normalize(g_hist, g_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
        normalize(b_hist, b_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );

        /// Draw for each channel
        for( int i = 1; i < histSize; i++ )
           {
            line( histImage, Point( bin_w*(i-1), hist_h - cvRound(r_hist.at<float>(i-1)) ) ,
                            Point( bin_w*(i), hist_h - cvRound(r_hist.at<float>(i)) ),
                            Scalar( 0, 0, 255), 2, 8, 0 );
            line( histImage, Point( bin_w*(i-1), hist_h - cvRound(g_hist.at<float>(i-1)) ) ,
                            Point( bin_w*(i), hist_h - cvRound(g_hist.at<float>(i)) ),
                            Scalar( 0, 255, 0), 2, 8, 0 );
            line( histImage, Point( bin_w*(i-1), hist_h - cvRound(b_hist.at<float>(i-1)) ) ,
                            Point( bin_w*(i), hist_h - cvRound(b_hist.at<float>(i)) ),
                            Scalar( 255, 0, 0), 2, 8, 0 );
            }
        return histImage;
    }
private:
};

Nose Tracking using Kalman Filter and Viola and Jones Classifier

2011-09-02T01:24:00.000-07:00

class atsKalman
{
public:
    atsKalman()
    {
        KalmanFilter KF(4, 2, 0);
        Mat_<float> state(4, 1); /* (x, y, Vx, Vy) */
        Mat processNoise(4, 1, CV_32F);
        Mat_<float> measurement(2,1);
        measurement.setTo(Scalar(0));

        KFs = KF;
        measurements = measurement;
    }
    void setKalman(int x, int y)
    {
        KFs.statePre.at<float>(0) = x;
        KFs.statePre.at<float>(1) = y;
        KFs.statePre.at<float>(2) = 0;
        KFs.statePre.at<float>(3) = 0;
        KFs.transitionMatrix = *(Mat_<float>(4, 4) << 1,0,0,0,   0,1,0,0, 0,0,1,0, 0,0,0,1);

        setIdentity(KFs.measurementMatrix);
        setIdentity(KFs.processNoiseCov, Scalar::all(1e-4));
        setIdentity(KFs.measurementNoiseCov, Scalar::all(1e-1));
        setIdentity(KFs.errorCovPost, Scalar::all(.1));


    }
    Point step1()
    {
        Mat prediction = KFs.predict();
        Point predictPt(prediction.at<float>(0),prediction.at<float>(1));
        return predictPt;
    }
    Point step2()
    {
        Mat estimated = KFs.correct(measurements);
        Point statePt(estimated.at<float>(0),estimated.at<float>(1));
        return statePt;
    }
    void changeMeasure(int x,int y)
    {
        measurements(0) = x;
        measurements(1) = y;
    }
private:
    KalmanFilter KFs;
    Mat_<float> measurements;
};

Viola and Jones Classifier is used to detect the nose. the X and Y coordinate of the found nose is sent to the first step of Kalman which is the prediction part. The second step of measurement correction completes the kalman filter.

class atsViolaJones
{
public:
    atsViolaJones()
    {
        storage = cvCreateMemStorage( 0 );
        cascade = ( CvHaarClassifierCascade* )cvLoad("haarcascade_mcs_nose.xml", 0, 0, 0 );
    }
    cv::Point Find(cv::Mat image )
    {
        IplImage imgs =image;
        IplImage* img = &imgs;



        int i;
        CvSeq *faces = cvHaarDetectObjects(
        img,
        cascade,
        storage,
        1.1,
        3,
        0,
        cvSize( 40, 40 ) );

        //get one image
        CvRect *r = ( CvRect* )cvGetSeqElem( faces, 0 );

        cv::Point found;
        found.x = (r->x + r->width);
        found.y = (r->y + r->height);

        return found;
    }
    ~atsViolaJones()
    {
        cvReleaseHaarClassifierCascade( &cascade );
        cvReleaseMemStorage( &storage );
    }
private:
    CvHaarClassifierCascade *cascade;
    CvMemStorage *storage;
};

UPDATED class to OPENCV 2.2:

class atsViolaJones
{
public:
    atsViolaJones(String filename)
    {
        if (filename == "")
            filename = "haarcascade_mcs_nose.xml";
        else
        {
        if( !face_cascade.load( filename ) ){ printf("--(!)Error loading\n"); };
        }
    }
    cv::Point Find(cv::Mat frame )
    {
        std::vector<Rect> faces;
        Mat frame_gray;

        cvtColor( frame, frame_gray, CV_BGR2GRAY );
        equalizeHist( frame_gray, frame_gray );

        face_cascade.detectMultiScale( frame_gray, faces, 1.1, 2, 0|CV_HAAR_SCALE_IMAGE, Size(30, 30) );

        cv::Point found;
        found.x = faces[0].x; //Face[0] is the first face found
        found.y = faces[0].y;

        return found;
    }
private:
    CascadeClassifier face_cascade;

};

This is the main function

int main (int argc, char * const argv[]) {
    Mat img(500, 500, CV_8UC3);

    //init the stuff
    atsKalman ats;
    atscameraCapture movie;
    atsViolaJones haar;

    char code = (char)-1;


    for(;;)
    {

        //init kalman
        ats.setKalman(0,0);



        mousev.clear();
        kalmanv.clear();

        for(;;)
        {
            //get camera
            img = movie.ats_getImage();


            //Step 1
            Point predictPt = ats.step1();

            //object X Y coordinte from another method
            cv::Point found;
            found = haar.Find(img);
            int x = found.x;
            int y = found.y;

            //
            ats.changeMeasure(x,y);

            Point measPt(x,y);
            mousev.push_back(measPt);

            //Step 2
            Point statePt = ats.step2();
            kalmanv.push_back(statePt);

            // plot points
            #define drawCross( center, color, d )                                 \
            line( img, Point( center.x - d, center.y - d ),                \
            Point( center.x + d, center.y + d ), color, 2, CV_AA, 0); \
            line( img, Point( center.x + d, center.y - d ),                \
            Point( center.x - d, center.y + d ), color, 2, CV_AA, 0 )

            drawCross( statePt, Scalar(0,255,255), 5 );
            drawCross( measPt, Scalar(0,0,255), 5 );

            for (int i = 0; i < mousev.size()-1; i++) {
                line(img, mousev[i], mousev[i+1], Scalar(255,255,0), 1);
            }
            for (int i = 0; i < kalmanv.size()-1; i++) {
                line(img, kalmanv[i], kalmanv[i+1], Scalar(0,255,0), 1);
            }


            imshow( "kalman", img );

            //imshow("kalman",haar.Find(img));
            code = (char)waitKey(100);

            if( code > 0 )
                break;
        }
        if( code == 27 || code == 'q' || code == 'Q' )
            break;
    }

    return 0;
}

Artificial Intelligence (K Nearest Neighbor) in OPENCV

2011-07-19T18:38:00.000-07:00

In pattern recognition, the k-nearest neighbor algorithm (k-NN) is a method for classifying objects based on closest training examples in the feature space. k-NN is a type of instance-based learning, or lazy learning where the function is only approximated locally and all computation is deferred until classification. The k-nearest neighbor algorithm is amongst the simplest of all machine learning algorithms: an object is classified by a majority vote of its neighbors, with the object being assigned to the class most common amongst its k nearest neighbors (k is a positive integer, typically small). If k = 1, then the object is simply assigned to the class of its nearest neighbor.

The k-NN algorithm can also be adapted for use in estimating continuous variables. One such implementation uses an inverse distance weighted average of the k-nearest multivariate neighbors. This algorithm functions as follows:

Compute Euclidean or Mahalanobis distance from target plot to those that were sampled.
Order samples taking for account calculated distances.
Choose heuristically optimal k nearest neighbor based on RMSE done by cross validation technique.
Calculate an inverse distance weighted average with the k-nearest multivariate neighbors.

Using a weighted k-NN also significantly improves the results: the class (or value, in regression problems) of each of the k nearest points is multiplied by a weight proportional to the inverse of the distance between that point and the point for which the class is to be predicted.

class atsKNN{
public :
    void knn(cv::Mat& trainingData, cv::Mat& trainingClasses, cv::Mat& testData, cv::Mat& testClasses, int K)
    {
        cv::KNearest knn(trainingData, trainingClasses, cv::Mat(), false, K);
        cv::Mat predicted(testClasses.rows, 1, CV_32F);
        for(int i = 0; i < testData.rows; i++) {
                const cv::Mat sample = testData.row(i);
                predicted.at<float>(i,0) = knn.find_nearest(sample, K);
        }

        float percentage = evaluate(predicted, testClasses) * 100;
        cout << "K Nearest Neighbor Evaluated Accuracy = " << percentage << "%" << endl;
        prediction = predicted;
    }
    void showplot(cv::Mat testData)
    {
        plot_binary(testData, prediction, "Predictions Backpropagation");
    }
private:
    cv::Mat prediction;

};

the simplicity of the algorithm in classifying things requires you to provide alot of training samples to ensure lots of vectors are created within K. therefore it is not optimized for speed and space. in addition to consuming alot of memory it is really slow.

Artificial Intelligence (support vector machine (SVM)) in OPENCV

2011-07-12T19:39:00.000-07:00

A support vector machine (SVM) is a concept in computer science for a set of related supervised learning methods that analyze data and recognize patterns, used for classification and regression analysis. The standard SVM takes a set of input data and predicts, for each given input, which of two possible classes the input is a member of, which makes the SVM a non-probabilistic binary linear classifier. Given a set of training examples, each marked as belonging to one of two categories, an SVM training algorithm builds a model that assigns new examples into one category or the other. An SVM model is a representation of the examples as points in space, mapped so that the examples of the separate categories are divided by a clear gap that is as wide as possible. New examples are then mapped into that same space and predicted to belong to a category based on which side of the gap they fall on.

A Support Vector Machine (SVM) performs classification by constructing an N-dimensional hyperplane that optimally separates the data into two categories. SVM models are closely related to neural networks. In fact, a SVM model using a sigmoid kernel function is equivalent to a two-layer, perceptron neural network.

The accuracy of an SVM model is largely dependent on the selection of the model parameters.

In the parlance of SVM literature, a predictor variable is called an attribute, and a transformed attribute that is used to define the hyperplane is called a feature. The task of choosing the most suitable representation is known as feature selection. A set of features that describes one case (i.e., a row of predictor values) is called a vector. So the goal of SVM modeling is to find the optimal hyperplane that separates clusters of vector in such a way that cases with one category of the target variable are on one side of the plane and cases with the other category are on the other size of the plane. The vectors near the hyperplane are the support vectors.

#include<opencv2/ml/ml.hpp>

class atsSVM

{

public:

    void svm(cv::Mat& trainingData, cv::Mat& trainingClasses, cv::Mat& testData, cv::Mat& testClasses) {

        //SVM Parameters

        CvSVMParams param = CvSVMParams();

        param.svm_type = CvSVM::C_SVC;

        param.kernel_type = CvSVM::RBF; //CvSVM::RBF, CvSVM::LINEAR ...

        param.degree = 0; // for poly

        param.gamma = 20; // for poly/rbf/sigmoid

        param.coef0 = 0; // for poly/sigmoid

        param.C = 7; // for CV_SVM_C_SVC, CV_SVM_EPS_SVR and CV_SVM_NU_SVR

        param.nu = 0.0; // for CV_SVM_NU_SVC, CV_SVM_ONE_CLASS, and CV_SVM_NU_SVR

        param.p = 0.0; // for CV_SVM_EPS_SVR

        param.class_weights = NULL; // for CV_SVM_C_SVC

        param.term_crit.type = CV_TERMCRIT_ITER +CV_TERMCRIT_EPS;

        param.term_crit.max_iter = 1000;

        param.term_crit.epsilon = 1e-6;

        // SVM training (use train auto for OpenCV>=2.0)

        CvSVM svm(trainingData, trainingClasses, cv::Mat(), cv::Mat(), param);

        cv::Mat predicted(testClasses.rows, 1, CV_32F);

        for(int i = 0; i < testData.rows; i++) {

            cv::Mat sample = testData.row(i);

            float x = sample.at<float>(0,0);

            float y = sample.at<float>(0,1);

            predicted.at<float>(i, 0) = svm.predict(sample);

        }

        float percentage = evaluate(predicted, testClasses) * 100;

        cout << "Support Vector Machine Evaluated Accuracy = " << percentage << "%" << endl;

    }

    void showplot(cv::Mat testData)

    {

        plot_binary(testData, prediction, "Predictions SVM");

    }

private:

        cv::Mat prediction;

};

The major strengths of SVM are the training is relatively easy. No local optimal, unlike in neural networks. It scales relatively well to high dimensional data and the trade-off between classifier complexity and error can be controlled explicitly. The weakness includes the need for a good kernel function

Artificial Intelligence (Multilayered perceptrons) in OPENCV

2011-07-11T19:05:00.000-07:00

Neural networks are models of biological neural structures. The starting point for most neural networks is a model neuron. Each input is modified by a weight, which multiplies with the input value. The neuron will combine these weighted inputs and, with reference to a threshold value and activation function, use these to determine its output. This behavior follows closely our understanding of how real neurons work.

Neural neworks are typically organized in layers. Layers are made up of a number of interconnected 'nodes' which contain an 'activation function'. Patterns are presented to the network via the 'input layer', which communicates to one or more 'hidden layers' where the actual processing is done via a system of weighted 'connections'. The hidden layers then link to an 'output layer' where the answer is output as shown in the graphic below.

Backpropagation is a common method of teaching artificial neural networks how to perform a given task.
It is a supervised learning method, and is a generalization of the delta rule. It requires a teacher that knows, or can calculate, the desired output for any input in the training set. It is most useful for feed-forward networks (networks that have no feedback, or simply, that have no connections that loop). The term is an abbreviation for "backward propagation of errors". Backpropagation requires that the activation function used by the artificial neurons (or "nodes") be differentiable.

The Steps

1. Initilaize weights with random values
2. Present the input vector to the network
3. Evaluate the output of the network after a forward propagation of the signal

4.Calculate error (T - O) at the output units

5.Compute delta_wh for all weights from hidden layer to output layer ; backward pass

6.Compute delta_wi for all weights from input layer to hidden layer ; backward pass continued

7. Update weights

8. Termination Criteria. Goto Step 2 for a xed number of iterations or an error.

#include<opencv2/ml/ml.hpp>

 class atsANN

{

public:

    void atstraineval(cv::Mat trainingData, cv::Mat trainingClasses, cv::Mat testData, cv::Mat testClasses) 

    {

        cv::Mat layers = cv::Mat(4, 1, CV_32SC1); //create 4 layers

        layers.row(0) = cv::Scalar(2); //input layer accepts x and y

        layers.row(1) = cv::Scalar(10);//hidden layer

        layers.row(2) = cv::Scalar(15);//hidden layer

        layers.row(3) = cv::Scalar(1); //output layer returns 1 or -1

        //Create the ANN

        CvANN_MLP ann;

        //ANN criteria for termination

        CvTermCriteria criter;

        criter.max_iter = 100;

        criter.epsilon = 0.00001f;

        criter.type = CV_TERMCRIT_ITER | CV_TERMCRIT_EPS;

        //ANN parameters

        CvANN_MLP_TrainParams params;

        params.train_method = CvANN_MLP_TrainParams::BACKPROP;

        params.bp_dw_scale = 0.05f;

        params.bp_moment_scale = 0.05f;

        params.term_crit = criter; //termination criteria

        ann.create(layers);

        // train

        ann.train(trainingData, trainingClasses, cv::Mat(), cv::Mat(), params);

        cv::Mat response(1, 1, CV_32FC1);

        cv::Mat predicted(testClasses.rows, 1, CV_32F);

        for(int i = 0; i < testData.rows; i++) {

            cv::Mat response(1, 1, CV_32FC1);

            cv::Mat sample = testData.row(i);

            ann.predict(sample, response);

            predicted.at<float>(i,0) = response.at<float>(0,0);

        }

        float percentage = evaluate(predicted, testClasses) * 100;

        cout << "Artificial Neural Network Evaluated Accuracy = " << percentage << "%" << endl;

        prediction = predicted;

    }

    void showplot(cv::Mat testData)

    {

        plot_binary(testData, prediction, "Predictions Backpropagation");

    }

private:

    cv::Mat prediction;

};

There are many advantages and limitations to neural network analysis and to discuss this subject properly we would have to look at each individual type of network, which isn't necessary for this general discussion. In reference to backpropagational networks however, there are some specific issues potential users should be aware of.

Backpropagational neural networks (and many other types of networks) are in a sense the ultimate 'black boxes'. Apart from defining the general archetecture of a network and perhaps initially seeding it with a random numbers, the user has no other role than to feed it input and watch it train and await the output. In fact, it has been said that with backpropagation, "you almost don't know what you're doing". Some software freely available software packages (NevProp, bp, Mactivation) do allow the user to sample the networks 'progress' at regular time intervals, but the learning itself progresses on its own. The final product of this activity is a trained network that provides no equations or coefficients defining a relationship (as in regression) beyond it's own internal mathematics. The network 'IS' the final equation of the relationship.
Backpropagational networks also tend to be slower to train than other types of networks and sometimes require thousands of epochs. If run on a truly parallel computer system this issue is not really a problem, but if the BPNN is being simulated on a standard serial machine (i.e. a single SPARC, Mac or PC) training can take some time. This is because the machines CPU must compute the function of each node and connection separately, which can be problematic in very large networks with a large amount of data. However, the speed of most current machines is such that this is typically not much of an issue.

#include <iostream>
#include <math.h>
#include <string>

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>

//required for multilayer perceptrons
   #include<opencv2/ml/ml.hpp>

using namespace cv;
using namespace std;

#define numTrainingPoints 200
#define numTestPoints 2000
#define size 200

// accuracy
float evaluate(cv::Mat& predicted, cv::Mat& actual) {
   assert(predicted.rows == actual.rows);
   int t = 0;
   int f = 0;
   for(int i = 0; i < actual.rows; i++) {
       float p = predicted.at<float>(i,0);
       float a = actual.at<float>(i,0);
       if((p >= 0.0 && a >= 0.0) || (p <= 0.0 && a <= 0.0)) {
           t++;
       } else {
           f++;
       }
   }
   return (t * 1.0) / (t + f);
}

// plot data and class
void plot_binary(cv::Mat& data, cv::Mat& classes, string name) {
   cv::Mat plot(size, size, CV_8UC3);
   plot.setTo(CV_RGB(255,255,255));
   for(int i = 0; i < data.rows; i++) {

       float x = data.at<float>(i,0) * size;
       float y = data.at<float>(i,1) * size;

       if(classes.at<float>(i, 0) > 0) {
           cv::circle(plot, Point(x,y), 2, CV_RGB(255,0,0),1);
       } else {
           cv::circle(plot, Point(x,y), 2, CV_RGB(0,255,0),1);
       }
   }
   cv::imshow(name, plot);
}

// function to learn
int dataLearn(float x, float y) {
   return y > atan(y/x) ? -1 : 1;

}

// label data with equation
cv::Mat labelData(cv::Mat points) {
   cv::Mat labels(points.rows, 1, CV_32FC1);
   for(int i = 0; i < points.rows; i++) {
           float x = points.at<float>(i,0);
           float y = points.at<float>(i,1);
           labels.at<float>(i, 0) = dataLearn(x, y);
       }
   return labels;
}

class atsANN
{

public:

   void atstraineval(cv::Mat trainingData, cv::Mat trainingClasses, cv::Mat testData, cv::Mat testClasses)
   {
       cv::Mat layers = cv::Mat(4, 1, CV_32SC1); //create 4 layers

       layers.row(0) = cv::Scalar(2); //input layer accepts x and y
       layers.row(1) = cv::Scalar(10);//hidden layer
       layers.row(2) = cv::Scalar(15);//hidden layer
       layers.row(3) = cv::Scalar(1); //output layer returns 1 or -1

       //Create the ANN
       CvANN_MLP ann;

       //ANN criteria for termination
       CvTermCriteria criter;
       criter.max_iter = 100;
       criter.epsilon = 0.00001f;
       criter.type = CV_TERMCRIT_ITER | CV_TERMCRIT_EPS;

       //ANN parameters
       CvANN_MLP_TrainParams params;
       params.train_method = CvANN_MLP_TrainParams::BACKPROP;
       params.bp_dw_scale = 0.05f;
       params.bp_moment_scale = 0.05f;
       params.term_crit = criter; //termination criteria

       ann.create(layers);
       // train
       ann.train(trainingData, trainingClasses, cv::Mat(), cv::Mat(), params);

       cv::Mat response(1, 1, CV_32FC1);
       cv::Mat predicted(testClasses.rows, 1, CV_32F);

       for(int i = 0; i < testData.rows; i++) {
           cv::Mat response(1, 1, CV_32FC1);
           cv::Mat sample = testData.row(i);

           ann.predict(sample, response);
           predicted.at<float>(i,0) = response.at<float>(0,0);

       }
       float percentage = evaluate(predicted, testClasses) * 100;
       cout << "Artificial Neural Network Evaluated Accuracy = " << percentage << "%" << endl;
       prediction = predicted;

   }
   void showplot(cv::Mat testData)
   {
       plot_binary(testData, prediction, "Predictions Backpropagation");
   }
private:
   cv::Mat prediction;
};

int main() {

   cv::Mat trainingData(numTrainingPoints, 2, CV_32FC1);
   cv::Mat testData(numTestPoints, 2, CV_32FC1);

   cv::randu(trainingData,0,1); //generate uniformly-distributed random numbers from the range [low, high)
   cv::randu(testData,0,1);

   cv::Mat trainingClasses = labelData(trainingData);
   cv::Mat testClasses = labelData(testData);

   plot_binary(trainingData, trainingClasses, "Plot of Training Data");
   plot_binary(testData, testClasses, "Plot ofTest Data");

   atsANN myANN;
   myANN.atstraineval(trainingData,trainingClasses,testData,testClasses);
   myANN.showplot(testData);

   cv::waitKey();

   return 0;
}

OPENCV2 C++ basics (OOP) old style vs new style

2011-07-06T02:09:00.000-07:00

Version 2.2 of the opencv library has divided its library into modules.
These library modules have their own associated header files which is required therefore any code you see on the internet that looks like this:
#include "cv.h"
#include <cv.h> and so on
is done using the old style, C or C++. However after the restructuring of the opencv library into modules, not all functionality was ported to the new style:
#include <opencv2/core/core.hpp>

one example of such method is the LOGPOLAR transform.
Another thing to take note here is, the old deprecated IplImage is changed to the matrix cv::Mat. therefore you should avoid using such unless your using the old style.

For the Log-Polar Transform i will be using this header file:
#include <opencv2/imgproc/imgproc_c.h>

Also to make things easy, ive created a class to convert between cv::Mat and IplImage

class atsoldtonew
{
public:
    IplImage convertOld(cv::Mat MatImage)
    {
        IplImage img =MatImage;
        return img;
    }
    cv::Mat convertNew(IplImage *iplImage)
    {
        cv::Mat imgMat(iplImage);
        return imgMat;
    }
private:
};

So the Log-Polar Class is the following:

class atslogPolar
{
public:
    void convert(cv::Mat image)
    {
        IplImage src;
        IplImage img =image;
        IplImage* newsrc = &img;
        IplImage* dst = cvCreateImage( cvGetSize(newsrc), 8, 3 );
        IplImage* dst2 = cvCreateImage( cvGetSize(newsrc), 8, 3 );

        cvLogPolar( newsrc, dst, cvPoint2D32f(image.size().width/2,image.size().height/2), 40,
        CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS );

        cvLogPolar( dst, dst2, cvPoint2D32f(image.size().width/2,image.size().height/2), 40,
        CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS+CV_WARP_INVERSE_MAP );

        newIm = dst;
        newImage = dst2;
    }
    void view()
    {
        cvShowImage( "inverse log-polar", newIm );
        cvShowImage( "reinverse log-polar", newImage );
    }
    IplImage* logpolar()
    {
        return newIm; //return the local variable
    }
    IplImage* Inverselogpolar()
    {
        return newImage; //return the local variable
    }
private:
    IplImage* newIm; //keep a local variable
    IplImage* newImage; //keep a local variable
};

This Class uses the old style however by converting to and from cv::Mat to IplImage your main function can be written as the following

#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
#include <vector>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
int main()
{
    atscameraCapture mine; //initialize
    for(;;)
        {
        cv::Mat image = mine.ats_getImage();
        cv::imshow("image",image); //CAMERA IMAGE

        atslogPolar pl;
        pl.convert(image);
        pl.view();   //show using the old style
        atsoldtonew conv;
        cv::imshow("image logpolar",conv.convertNew(pl.logpolar())); //show using the new style

        if(cv::waitKey(30) >= 0) break;
        }
    return 0;
}

You can easily add the class to my previous Post code to add the new added functionality

OPENCV2 C++ basics (OOP) edge detection using CANNY

2011-07-05T19:46:00.000-07:00

if you have an OK background on C++ you can follow easily:

ive seperated the camera capturing and the edge detection to separate classes.
the main entry point remains the same.
you can use the code to add a new class to process images using the atscameraCapture class.

#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
#include <vector>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>

//for atsEdges
#include <opencv2/imgproc/imgproc.hpp>

class atscameraCapture
{
public:
    cv::Mat ats_getImage()
    {
        //check if Camera is still open
        if (!cap.isOpened())
        {
            std::cout< "Cant Capture";
            exit(0);
        }
        //camera is open so get a frame
            cv::Mat frame;
            cap>> frame;
        //return the frame
            return frame;
    }
    atscameraCapture()
    {
        //create a camera capture and assign it to a local private variable
        cv::VideoCapture capture(0);
        cap = capture;
    }
private:
    cv::VideoCapture cap;
};

class atsEdges
{
public:
    cv::Mat getEdges(cv::Mat image)
    {
        cv::Mat edges;
        cvtColor(image,edges,CV_BGR2GRAY); //convert from RGB color space to GRAY
        Canny(edges,edges,
            0,    // double threshold1
            30,    //double threshold2
            3); //int apertureSize=3, bool L2gradient=false)
        return edges;

    }

private:
};

int main()
{
    atscameraCapture mine; //initialize
    for(;;)
        {
        cv::Mat image = mine.ats_getImage();
        cv::imshow("image",image);

        atsEdges pl;

        cv::imshow("pl image",pl.getEdges(image));

        if(cv::waitKey(30) >= 0) break;
        }
    return 0;
}

build a cascade of boosted classifiers based on Haar-like features

2011-07-03T21:28:00.000-07:00

Step 1 -

Tools Needed:
You can find these executables as part of the opencv default installation. they are located in the BIN folder

Samples:
you should have alot of positive and negative images.
Take note that compressed images such as jpeg have certain issues therefore selecting a BMP image is recommended.

Create folders for the Negative and Positive images and include an info file aswell

Basically there should be four sets of images that you work on:
- a positive sample set representing your object that you want to train
- another positive sample set for testing purpose
- a negative sample set (or so-called backgrounds) for training
- and another negative sample set for testing, too

so your 2 folders containing the images are:
/opencv/project/negative
/opencv/project/positive
as well as the info file:
-train.txt
-test.txt

To work with these images in the utilities, a list of the files is needed. Using Win32 as host OS,
you can get the list via command promt. Move to the folder where the info file will be stored and
type “dir /b /s > infofile.txt”. Open “infofile.txt” and make the paths relative to the
info file (i.e. find “C:\Temp\negatives\” and replace with “”).

Step 2 - Test Creation
Once your done preparing you need to create a vec-file in the data folder. This is done by createsamples.exe by calling:

opencv_createsamples.exe -info positives/train.txt -vec data/positives.vec -num 1300 -w 20 –h 20

the numbers show 1300 samples with a width and height of 20
double check if the vec file really contains the desired images.

Step 3 Training
Im assuming the following the default values of hitrate (0.995), maxfalsealarm (0.5), weighttrimming (0.95) and boosting type (GAB, “Gentle Ada Boost”) are good in most cases we use the following call:"

haartraining.exe -data data/cascade -vec data/positives.vec -bg negatives/train.txt
-npos 1300 -nneg 5000 -nstages 30 -mem 1300 -mode ALL -w 20 -h 20

- 1300 positive images
- 5000 negative images
- 30 stages
- 1300 MB of RAM

Step 4 Testing

the test of hitrate and falsealarm will be done by calling

performance.exe -data data/cascade -info positives/testing/testing.txt -w 20 -h 20 -rs 30

Thats it, tell me how it goes.,,,

Affine VS Perspective Transformation using CAMERA

2010-12-29T18:37:00.000-08:00

I have used OpenCV's AFFINE and PERSPECTIVE transform to WARP the images.
this same process can be done using HARRIS and RANSAC

#include <opencv2/video/tracking.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <stdio.h>
#include <opencv2/objdetect/objdetect.hpp>
#include <opencv2/features2d/features2d.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/calib3d/calib3d.hpp>
#include <opencv2/imgproc/imgproc_c.h>
#include <opencv2/video/tracking.hpp>
#include <iostream>
#include <vector>

void PrintMatrix ( CvMat *Matrix , char * name )
{
printf ("%s\n", name );
   for ( int i=0;i<Matrix -> rows ;i++)
   {
       for ( int j =0;j< Matrix -> cols ;j ++)
       {
           printf (" %.3f\t",cvGet2D ( Matrix ,i,j).val [0]) ;
       }
   printf ("\n");
   }
printf ("\n");
}
// define whether to use approximate nearest-neighbor search
#define USE_FLANN
IplImage *image = 0;
double compareSURFDescriptors( const float* d1, const float* d2, double best, int length )
{
double total_cost = 0;
assert( length % 4 == 0 );
for( int i = 0; i < length; i += 4 )
{
double t0 = d1[i] - d2[i];
double t1 = d1[i+1] - d2[i+1];
double t2 = d1[i+2] - d2[i+2];
double t3 = d1[i+3] - d2[i+3];
total_cost += t0*t0 + t1*t1 + t2*t2 + t3*t3;
if( total_cost > best )
break;
}
return total_cost;
}

int naiveNearestNeighbor( const float* vec, int laplacian,
const CvSeq* model_keypoints,
const CvSeq* model_descriptors )
{
int length = (int)(model_descriptors->elem_size/sizeof(float));
int i, neighbor = -1;
double d, dist1 = 1e6, dist2 = 1e6;
CvSeqReader reader, kreader;
cvStartReadSeq( model_keypoints, &kreader, 0 );
cvStartReadSeq( model_descriptors, &reader, 0 );
for( i = 0; i < model_descriptors->total; i++ )
{
const CvSURFPoint* kp = (const CvSURFPoint*)kreader.ptr;
const float* mvec = (const float*)reader.ptr;
CV_NEXT_SEQ_ELEM( kreader.seq->elem_size, kreader );
CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader );
if( laplacian != kp->laplacian )
continue;
d = compareSURFDescriptors( vec, mvec, dist2, length );
if( d < dist1 )
{
dist2 = dist1;
dist1 = d;
neighbor = i;
}
else if ( d < dist2 )
dist2 = d;
}
if ( dist1 < 0.6*dist2 )
return neighbor;
return -1;
}

void findPairs( const CvSeq* objectKeypoints, const CvSeq* objectDescriptors,
const CvSeq* imageKeypoints, const CvSeq* imageDescriptors, vector<int>& ptpairs )
{
int i;
CvSeqReader reader, kreader;
cvStartReadSeq( objectKeypoints, &kreader );
cvStartReadSeq( objectDescriptors, &reader );
ptpairs.clear();

for( i = 0; i < objectDescriptors->total; i++ )
{
const CvSURFPoint* kp = (const CvSURFPoint*)kreader.ptr;
const float* descriptor = (const float*)reader.ptr;
CV_NEXT_SEQ_ELEM( kreader.seq->elem_size, kreader );
CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader );
int nearest_neighbor = naiveNearestNeighbor( descriptor, kp->laplacian, imageKeypoints, imageDescriptors );

if( nearest_neighbor >= 0 )
{
ptpairs.push_back(i);
ptpairs.push_back(nearest_neighbor);
}
}
}

void flannFindPairs( const CvSeq*, const CvSeq* objectDescriptors,
const CvSeq*, const CvSeq* imageDescriptors, vector<int>& ptpairs )
{
int length = (int)(objectDescriptors->elem_size/sizeof(float));
cv::Mat m_object(objectDescriptors->total, length, CV_32F);
cv::Mat m_image(imageDescriptors->total, length, CV_32F);

// copy descriptors
CvSeqReader obj_reader;
float* obj_ptr = m_object.ptr<float>(0);
cvStartReadSeq( objectDescriptors, &obj_reader );
for(int i = 0; i < objectDescriptors->total; i++ )
{
const float* descriptor = (const float*)obj_reader.ptr;
CV_NEXT_SEQ_ELEM( obj_reader.seq->elem_size, obj_reader );
memcpy(obj_ptr, descriptor, length*sizeof(float));
obj_ptr += length;
}

CvSeqReader img_reader;
float* img_ptr = m_image.ptr<float>(0);
cvStartReadSeq( imageDescriptors, &img_reader );
for(int i = 0; i < imageDescriptors->total; i++ )
{
const float* descriptor = (const float*)img_reader.ptr;
CV_NEXT_SEQ_ELEM( img_reader.seq->elem_size, img_reader );
memcpy(img_ptr, descriptor, length*sizeof(float));
img_ptr += length;
}

// find nearest neighbors using FLANN
cv::Mat m_indices(objectDescriptors->total, 2, CV_32S);
cv::Mat m_dists(objectDescriptors->total, 2, CV_32F);
cv::flann::Index flann_index(m_image, cv::flann::KDTreeIndexParams(4)); // using 4 randomized kdtrees

flann_index.knnSearch(m_object, m_indices, m_dists, 2, cv::flann::SearchParams(64) ); // maximum number of leafs checked

int* indices_ptr = m_indices.ptr<int>(0);
float* dists_ptr = m_dists.ptr<float>(0);
for (int i=0;i<m_indices.rows;++i) {
if (dists_ptr[2*i]<0.6*dists_ptr[2*i+1]) {
ptpairs.push_back(i);
ptpairs.push_back(indices_ptr[2*i]);
}
}
}

/* a rough implementation for object location */
int locatePlanarObject( const CvSeq* objectKeypoints, const CvSeq* objectDescriptors,
const CvSeq* imageKeypoints, const CvSeq* imageDescriptors,
const CvPoint src_corners[4], CvPoint dst_corners[4] )
{

double h[9];
CvMat _h = cvMat(3, 3, CV_64F, h);
vector<int> ptpairs;
vector<CvPoint2D32f> pt1, pt2;
CvMat _pt1, _pt2;
int i, n;
#ifdef USE_FLANN
flannFindPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
#else
findPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
#endif

n = (int)(ptpairs.size()/2);
if( n < 4 )
return 0;
pt1.resize(n);
pt2.resize(n);
for( i = 0; i < n; i++ )
{
pt1[i] = ((CvSURFPoint*)cvGetSeqElem(objectKeypoints,ptpairs[i*2]))->pt;
pt2[i] = ((CvSURFPoint*)cvGetSeqElem(imageKeypoints,ptpairs[i*2+1]))->pt;
}

_pt1 = cvMat(1, n, CV_32FC2, &pt1[0] );
_pt2 = cvMat(1, n, CV_32FC2, &pt2[0] );
if( !cvFindHomography( &_pt1, &_pt2, &_h, CV_RANSAC, 5 ))
return 0;

for( i = 0; i < 4; i++ )
{
double x = src_corners[i].x, y = src_corners[i].y;
double Z = 1./(h[6]*x + h[7]*y + h[8]);
double X = (h[0]*x + h[1]*y + h[2])*Z;
double Y = (h[3]*x + h[4]*y + h[5])*Z;
dst_corners[i] = cvPoint(cvRound(X), cvRound(Y));
}
return 1;
}

int main(int argc, char** argv)
{
CvCapture* capture = cvCreateCameraCapture(0);
CvMat* image = 0, *object = 0;
CvSeq *imageKeypoints = 0, *imageDescriptors = 0,*objectKeypoints = 0, *objectDescriptors = 0;
CvMemStorage* storage = cvCreateMemStorage(0);
int i;
static CvScalar colors[] =
{
{{0,0,255}},
{{0,128,255}},
{{0,255,255}},
{{0,255,0}},
{{255,128,0}},
{{255,255,0}},
{{255,0,0}},
{{255,0,255}},
{{255,255,255}}
};

if( !capture )
return -1;

for(;;)
{
int firstFrame = object == 0;
int percent = 50;
IplImage* source = cvQueryFrame(capture);
// declare a destination IplImage object with correct size, depth and channels
IplImage *frame = cvCreateImage
( cvSize((int)((source->width*percent)/100) , (int)((source->height*percent)/100) ),
source->depth, source->nChannels );

//use cvResize to resize source to a destination image
cvResize(source, frame);
if(!frame)
break;
if(!object)
{
object = cvCreateMat(frame->height, frame->width, CV_8UC1);
image = cvCreateMat(object->rows, object->cols, object->type);
}
cvCvtColor(frame, object, CV_BGR2GRAY);

if( !firstFrame )
{

//Extract SURF points by initializing parameters
CvSURFParams params = cvSURFParams(500, 1);
cvExtractSURF( image, 0, &imageKeypoints, &imageDescriptors, storage, params );
cvExtractSURF( object, 0, &objectKeypoints, &objectDescriptors, storage, params );
CvPoint src_corners[4] = {{0,0}, {object->width,0}, {object->width, object->height}, {0, object->height}};
CvPoint dst_corners[4];
IplImage* correspond = cvCreateImage( cvSize(image->width, object->height+image->height), 8, 1 );
cvSetImageROI( correspond, cvRect( 0, 0, object->width, object->height ) );
cvCopy( object, correspond );
cvSetImageROI( correspond, cvRect( 0, object->height, correspond->width, correspond->height ) );
cvCopy( image, correspond );
cvResetImageROI( correspond );

if( locatePlanarObject( objectKeypoints, objectDescriptors, imageKeypoints,
imageDescriptors, src_corners, dst_corners ))
{
for( i = 0; i < 4; i++ )
{
CvPoint r1 = dst_corners[i%4];
CvPoint r2 = dst_corners[(i+1)%4];
cvLine( correspond, cvPoint(r1.x, r1.y+object->height ),
cvPoint(r2.x, r2.y+object->height ), colors[8] );
}
}
vector<int> ptpairs;
#ifdef USE_FLANN
flannFindPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
#else
findPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
#endif
CvPoint2D32f srcTri[4], dstTri[4];

IplImage *dst = cvCloneImage( frame );
IplImage *dst1 = cvCloneImage( frame );
int jk=0;
for( i = 0; i < (int)ptpairs.size(); i += 2 )
{
CvSURFPoint* r1 = (CvSURFPoint*)cvGetSeqElem( objectKeypoints, ptpairs[i] );
CvSURFPoint* r2 = (CvSURFPoint*)cvGetSeqElem( imageKeypoints, ptpairs[i+1] );
if (i<8)
{
   srcTri[jk] = r1->pt;
   dstTri[jk] = r2->pt;
   jk++;
}
cvLine( correspond, cvPointFrom32f(r1->pt),
cvPoint(cvRound(r2->pt.x), cvRound(r2->pt.y+object->height)), colors[8] );
}
   CvMat* warp_mat = cvCreateMat(3,3,CV_32FC1);
   CvMat* rot_mat = cvCreateMat(2,3,CV_32FC1);

cvGetAffineTransform( srcTri, dstTri, rot_mat );
cvWarpAffine( frame, dst1, rot_mat );

cvGetPerspectiveTransform( srcTri, dstTri, warp_mat );
cvWarpPerspective( frame, dst, warp_mat );

       PrintMatrix(warp_mat,"Perspective Matrix");
       PrintMatrix(rot_mat,"Affine Rotation Matrix");


       //show the image
       cvShowImage("output Perspective Transform", dst);
       cvShowImage("output Affine Transform", dst1);

cvShowImage( "Object Correspond", correspond );
for( i = 0; i < objectKeypoints->total; i++ )
{
CvSURFPoint* r = (CvSURFPoint*)cvGetSeqElem( objectKeypoints, i );
CvPoint center;
int radius;
center.x = cvRound(r->pt.x);
center.y = cvRound(r->pt.y);
radius = cvRound(r->size*1.2/9.*2);
cvCircle( frame, center, radius, colors[0], 1, 8, 0 );
}
cvShowImage( "Object", frame );
}
cvWaitKey(250);
{
CvMat* temp;
CV_SWAP(image, object, temp);
}
}
cvReleaseCapture(&capture);
return 0;
}

Live video stabilization Trials

2010-12-27T00:54:00.000-08:00

the angle of rotation and scaling is not yet done. need to find these in the previous image and after warping transform

logpolar transform using Camera

2010-12-26T17:37:00.000-08:00

The logpolar transform function emulates the human “foveal” vision and can be used for fast scale and rotation-invariant template matching, for object tracking and so forth. The function can not operate in-place.
"The foveal system of the human eye is the only part of the retina that permits 100% visual acuity. The line-of-sight is a virtual line connecting the fovea with a fixation point in the outside world." Wikipedia;

Code:

Camera Affine Transformation

2010-12-25T18:48:00.000-08:00

An affine transform allows the user to warp, stretch, rotate and resize an image or a footage from a camera. Essentially the image is multiplied by 2x3 matrix to perform the transformation. An affine transform produces parallelograms (which includes standard rectangles).

#include <opencv2/video/tracking.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <stdio.h>
#include <opencv2/objdetect/objdetect.hpp>
#include <opencv2/features2d/features2d.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/calib3d/calib3d.hpp>
#include <opencv2/imgproc/imgproc_c.h>
#include <opencv2/video/tracking.hpp>
#include <iostream>
#include <vector>

int angle_switch_value = 0;
int angleInt = 0;
int scale_switch_value = 0;
int scaleInt = 0;

void switch_callback_a( int position ){
angleInt = position;
}
void switch_callback_s( int position ){
scaleInt = position;
}

int main(int argc, char** argv)
{
// Set up variables
CvPoint2D32f srcTri[3], dstTri[3];
CvMat* rot_mat = cvCreateMat(2,3,CV_32FC1);
CvMat* warp_mat = cvCreateMat(2,3,CV_32FC1);
IplImage *src, *dst;
const char* name = "Affine_Transform";

//create capture
CvCapture* capture = cvCreateCameraCapture(0);
for(;;)
{
IplImage* src = cvQueryFrame(capture);
dst = cvCloneImage( src );
dst->origin = src->origin;
cvZero( dst );
cvNamedWindow( name, 1 );

// Create angle and scale
double angle = 0.0;
double scale = 1.0;

// Create trackbars
cvCreateTrackbar( "Angle", name, &angle_switch_value, 4, switch_callback_a );
cvCreateTrackbar( "Scale", name, &scale_switch_value, 4, switch_callback_s );

// Compute warp matrix
srcTri[0].x = 0;
srcTri[0].y = 0;
srcTri[1].x = src->width - 1;
srcTri[1].y = 0;
srcTri[2].x = 0;
srcTri[2].y = src->height - 1;

dstTri[0].x = src->width*0.0;
dstTri[0].y = src->height*0.25;
dstTri[1].x = src->width*0.90;
dstTri[1].y = src->height*0.15;
dstTri[2].x = src->width*0.10;
dstTri[2].y = src->height*0.75;

cvGetAffineTransform( srcTri, dstTri, warp_mat );
cvWarpAffine( src, dst, warp_mat );
cvCopy ( dst, src );

switch( angleInt ){
case 0:
angle = 0.0;
break;
case 1:
angle = 20.0;
break;
case 2:
angle = 40.0;
break;
case 3:
angle = 60.0;
break;
case 4:
angle = 90.0;
break;
}
switch( scaleInt ){
case 0:
scale = 1.0;
break;
case 1:
scale = 0.8;
break;
case 2:
scale = 0.6;
break;
case 3:
scale = 0.4;
break;
case 4:
scale = 0.2;
break;
}

// Compute rotation matrix
CvPoint2D32f center = cvPoint2D32f( src->width/2, src->height/2 );
cv2DRotationMatrix( center, angle, scale, rot_mat );

// Do the transformation
cvWarpAffine( src, dst, rot_mat );

cvShowImage( name, dst );
cvWaitKey( 15 );
}
cvReleaseImage( &dst );
cvReleaseMat( &rot_mat );
cvReleaseMat( &warp_mat );

return 0;
}