vcs.maemo.org Git - opencv/blob - samples/c/image.cpp

   1 #include "cv.h" // include standard OpenCV headers, same as before
   2 #include "highgui.h"
   3
   4 using namespace cv; // all the new API is put into "cv" namespace. Export its content
   5
   6 // enable/disable use of mixed API in the code below.
   7 #define DEMO_MIXED_API_USE 1
   8
   9 int main( int argc, char** argv )
  10 {
  11     const char* imagename = argc > 1 ? argv[1] : "lena.jpg";
  12 #if DEMO_MIXED_API_USE
  13     Ptr<IplImage> iplimg = cvLoadImage(imagename); // Ptr<T> is safe ref-conting pointer class
  14     if(iplimg.empty())
  15     {
  16         fprintf(stderr, "Can not load image %s\n", imagename);
  17         return -1;
  18     }
  19     Mat img(iplimg); // cv::Mat replaces the CvMat and IplImage, but it's easy to convert
  20     // between the old and the new data structures (by default, only the header
  21     // is converted, while the data is shared)
  22 #else
  23     Mat img = imread(imagename); // the newer cvLoadImage alternative, MATLAB-style function
  24     if(img.empty())
  25     {
  26         fprintf(stderr, "Can not load image %s\n", imagename);
  27         return -1;
  28     }
  29 #endif
  30
  31     if( !img.data ) // check if the image has been loaded properly
  32         return -1;
  33
  34     Mat img_yuv;
  35     cvtColor(img, img_yuv, CV_BGR2YCrCb); // convert image to YUV color space. The output image will be created automatically
  36
  37     vector<Mat> planes; // Vector is template vector class, similar to STL's vector. It can store matrices too.
  38     split(img_yuv, planes); // split the image into separate color planes
  39
  40 #if 1
  41     // method 1. process Y plane using an iterator
  42     MatIterator_<uchar> it = planes[0].begin<uchar>(), it_end = planes[0].end<uchar>();
  43     for(; it != it_end; ++it)
  44     {
  45         double v = *it*1.7 + rand()%21-10;
  46         *it = saturate_cast<uchar>(v*v/255.);
  47     }
  48
  49     // method 2. process the first chroma plane using pre-stored row pointer.
  50     // method 3. process the second chroma plane using individual element access
  51     for( int y = 0; y < img_yuv.rows; y++ )
  52     {
  53         uchar* Uptr = planes[1].ptr<uchar>(y);
  54         for( int x = 0; x < img_yuv.cols; x++ )
  55         {
  56             Uptr[x] = saturate_cast<uchar>((Uptr[x]-128)/2 + 128);
  57             uchar& Vxy = planes[2].at<uchar>(y, x);
  58             Vxy = saturate_cast<uchar>((Vxy-128)/2 + 128);
  59         }
  60     }
  61
  62 #else
  63     Mat noise(img.size(), CV_8U); // another Mat constructor; allocates a matrix of the specified size and type
  64     randn(noise, Scalar::all(128), Scalar::all(20)); // fills the matrix with normally distributed random values;
  65                                                      // there is also randu() for uniformly distributed random number generation
  66     GaussianBlur(noise, noise, Size(3, 3), 0.5, 0.5); // blur the noise a bit, kernel size is 3x3 and both sigma's are set to 0.5
  67
  68     const double brightness_gain = 0;
  69     const double contrast_gain = 1.7;
  70 #if DEMO_MIXED_API_USE
  71     // it's easy to pass the new matrices to the functions that only work with IplImage or CvMat:
  72     // step 1) - convert the headers, data will not be copied
  73     IplImage cv_planes_0 = planes[0], cv_noise = noise;
  74     // step 2) call the function; do not forget unary "&" to form pointers
  75     cvAddWeighted(&cv_planes_0, contrast_gain, &cv_noise, 1, -128 + brightness_gain, &cv_planes_0);
  76 #else
  77     addWeighted(planes[0], constrast_gain, noise, 1, -128 + brightness_gain, planes[0]);
  78 #endif
  79     const double color_scale = 0.5;
  80     // Mat::convertTo() replaces cvConvertScale. One must explicitly specify the output matrix type (we keep it intact - planes[1].type())
  81     planes[1].convertTo(planes[1], planes[1].type(), color_scale, 128*(1-color_scale));
  82     // alternative form of cv::convertScale if we know the datatype at compile time ("uchar" here).
  83     // This expression will not create any temporary arrays and should be almost as fast as the above variant
  84     planes[2] = Mat_<uchar>(planes[2]*color_scale + 128*(1-color_scale));
  85
  86     // Mat::mul replaces cvMul(). Again, no temporary arrays are created in case of simple expressions.
  87     planes[0] = planes[0].mul(planes[0], 1./255);
  88 #endif
  89
  90     // now merge the results back
  91     merge(planes, img_yuv);
  92     // and produce the output RGB image
  93     cvtColor(img_yuv, img, CV_YCrCb2BGR);
  94
  95     // this is counterpart for cvNamedWindow
  96     namedWindow("image with grain", CV_WINDOW_AUTOSIZE);
  97 #if DEMO_MIXED_API_USE
  98     // this is to demonstrate that img and iplimg really share the data - the result of the above
  99     // processing is stored in img and thus in iplimg too.
 100     cvShowImage("image with grain", iplimg);
 101 #else
 102     imshow("image with grain", img);
 103 #endif
 104     waitKey();
 105
 106     return 0;
 107     // all the memory will automatically be released by Vector<>, Mat and Ptr<> destructors.
 108 }
 109