Skip to main content

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

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

Comments

Popular posts from this blog

Computing Entropy of an image (CORRECTED)

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 )    

Artificial Intelligence (K Nearest Neighbor) in OPENCV

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 plo

Blob Detection, Connected Component (Pure Opencv)

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 la