Added sample code for tutorial - cpp

samples/cpp/tutorial_code/Basic/AddingImages.cpp

@@ -0,0 +1,52 @@
+/**
+ * @file AddingImages.cpp
+ * @brief Simple linear blender ( dst = alpha*src1 + beta*src2 )
+ * @author OpenCV team
+ */
+
+#include <cv.h>
+#include <highgui.h>
+#include <iostream>
+
+using namespace cv;
+
+/**
+ * @function main
+ * @brief Main function 
+ */
+int main( int argc, char** argv )
+{
+
+   double alpha = 0.5; double beta; double input; 
+
+   Mat src1, src2, dst;
+
+   /// Ask the user enter alpha
+   std::cout<<" Simple Linear Blender "<<std::endl;
+   std::cout<<"-----------------------"<<std::endl;
+   std::cout<<"* Enter alpha [0-1]: ";
+   std::cin>>input;
+
+   // We use the alpha provided by the user iff it is between 0 and 1
+   if( alpha >= 0 && alpha <= 1 )
+     { alpha = input; }
+
+   /// Read image ( same size, same type )
+   src1 = imread("../../images/LinuxLogo.jpg");
+   src2 = imread("../../images/WindowsLogo.jpg");
+
+   if( !src1.data ) { printf("Error loading src1 \n"); return -1; }
+   if( !src2.data ) { printf("Error loading src2 \n"); return -1; }
+
+   /// Create Windows
+   namedWindow("Linear Blend", 1);
+
+   beta = ( 1.0 - alpha );
+   addWeighted( src1, alpha, src2, beta, 0.0, dst);
+  
+   imshow( "Linear Blend", dst );
+
+
+   waitKey(0);
+   return 0;
+}

samples/cpp/tutorial_code/Basic/AddingImagesTrackbar.cpp

@@ -0,0 +1,69 @@
+/**
+ * @file LinearBlend.cpp
+ * @brief Simple linear blender ( dst = alpha*src1 + beta*src2 )
+ * @author OpenCV team
+ */
+
+#include <cv.h>
+#include <highgui.h>
+
+using namespace cv;
+
+/** Global Variables */
+const int alpha_slider_max = 100;
+int alpha_slider; 
+double alpha;
+double beta;  
+
+/** Matrices to store images */
+Mat src1;
+Mat src2;
+Mat dst;
+
+/**
+ * @function on_trackbar
+ * @brief Callback for trackbar
+ */
+void on_trackbar( int, void* )
+{ 
+   alpha = (double) alpha_slider/alpha_slider_max ;
+
+   beta = ( 1.0 - alpha );
+
+   addWeighted( src1, alpha, src2, beta, 0.0, dst);
+  
+   imshow( "Linear Blend", dst );
+}
+
+
+/**
+ * @function main
+ * @brief Main function 
+ */
+int main( int argc, char** argv )
+{
+   /// Read image ( same size, same type )
+   src1 = imread("../../images/LinuxLogo.jpg");
+   src2 = imread("../../images/WindowsLogo.jpg");
+
+   if( !src1.data ) { printf("Error loading src1 \n"); return -1; }
+   if( !src2.data ) { printf("Error loading src2 \n"); return -1; }
+
+   /// Initialize values 
+   alpha_slider = 0;
+
+   /// Create Windows
+   namedWindow("Linear Blend", 1);
+
+   /// Create Trackbars
+   char TrackbarName[50];
+   sprintf( TrackbarName, "Alpha x %d", alpha_slider_max ); 
+   createTrackbar( TrackbarName, "Linear Blend", &alpha_slider, alpha_slider_max, on_trackbar );
+
+   /// Show some stuff
+   on_trackbar( alpha_slider, 0 );
+  
+   /// Wait until user press some key
+   waitKey(0);
+   return 0;
+}

samples/cpp/tutorial_code/Basic/BasicLinearTransforms.cpp

@@ -0,0 +1,58 @@
+/**
+ * @file BasicLinearTransforms.cpp
+ * @brief Simple program to change contrast and brightness
+ * @author OpenCV team
+ */
+
+#include <cv.h>
+#include <highgui.h>
+#include <iostream>
+
+using namespace cv;
+
+double alpha; /**< Simple contrast control */
+int beta;  /**< Simple brightness control */
+
+/**
+ * @function main
+ * @brief Main function 
+ */
+int main( int argc, char** argv )
+{
+   /// Read image given by user
+   Mat image = imread( argv[1] );
+   Mat new_image = Mat::zeros( image.size(), image.type() );
+
+   /// Initialize values 
+   std::cout<<" Basic Linear Transforms "<<std::endl;
+   std::cout<<"-------------------------"<<std::endl;
+   std::cout<<"* Enter the alpha value [1.0-3.0]: ";std::cin>>alpha;
+   std::cout<<"* Enter the beta value [0-100]: "; std::cin>>beta;
+
+
+   /// Do the operation new_image(i,j) = alpha*image(i,j) + beta
+   /// Instead of these 'for' loops we could have used simply:
+   /// image.convertTo(new_image, -1, alpha, beta);
+   /// but we wanted to show you how to access the pixels :)
+   for( int y = 0; y < image.rows; y++ )
+      { for( int x = 0; x < image.cols; x++ )
+           { for( int c = 0; c < 3; c++ )
+                {
+		  new_image.at<Vec3b>(y,x)[c] = saturate_cast<uchar>( alpha*( image.at<Vec3b>(y,x)[c] ) + beta );
+                }
+	   }
+      }
+
+   /// Create Windows
+   namedWindow("Original Image", 1);
+   namedWindow("New Image", 1);
+
+   /// Show stuff
+   imshow("Original Image", image);
+   imshow("New Image", new_image);
+
+   
+   /// Wait until user press some key
+   waitKey();
+   return 0;
+}

samples/cpp/tutorial_code/Basic/BasicLinearTransformsTrackbar.cpp

@@ -0,0 +1,71 @@
+/**
+ * @file LinearTransforms.cpp
+ * @brief Simple program to change contrast and brightness
+ * @date Mon, June 6, 2011
+ * @author OpenCV team
+ */
+
+#include <cv.h>
+#include <highgui.h>
+
+using namespace cv;
+
+/** Global Variables */
+const int alpha_max = 5;
+const int beta_max = 125;
+int alpha; /**< Simple contrast control */
+int beta;  /**< Simple brightness control*/
+
+/** Matrices to store images */
+Mat image;
+Mat new_image;
+
+/**
+ * @function on_trackbar
+ * @brief Called whenever any of alpha or beta changes
+ */
+void on_trackbar( int, void* )
+{  
+   Mat new_image = Mat::zeros( image.size(), image.type() );
+
+   for( int y = 0; y < image.rows; y++ )
+      { for( int x = 0; x < image.cols; x++ )
+           { for( int c = 0; c < 3; c++ )
+                {
+		  new_image.at<Vec3b>(y,x)[c] = saturate_cast<uchar>( alpha*( image.at<Vec3b>(y,x)[c] ) + beta );
+                }
+	   }
+      }
+   imshow("New Image", new_image);
+}
+
+
+/**
+ * @function main
+ * @brief Main function 
+ */
+int main( int argc, char** argv )
+{
+   /// Read image given by user
+   image = imread( argv[1] );
+
+   /// Initialize values 
+   alpha = 1;
+   beta = 0;
+
+   /// Create Windows
+   namedWindow("Original Image", 1);
+   namedWindow("New Image", 1);
+
+   /// Create Trackbars
+   createTrackbar( "Contrast Trackbar", "New Image", &alpha, alpha_max, on_trackbar );
+   createTrackbar( "Brightness Trackbar", "New Image", &beta, beta_max, on_trackbar );   
+
+   /// Show some stuff
+   imshow("Original Image", image);
+   imshow("New Image", image);
+   
+   /// Wait until user press some key
+   waitKey();
+   return 0;
+}

samples/cpp/tutorial_code/Basic/DisplayImage.cpp

@@ -0,0 +1,28 @@
+/**
+ * @file DisplayImage.cpp
+ * @brief Sample code that show how to read and display an image in a OpenCV window
+ * @author OpenCV team
+ */
+#include <cv.h>
+#include <highgui.h>
+
+using namespace cv;
+
+int main( int argc, char** argv )
+{
+   Mat image;
+   image = imread( argv[1], 1 );
+
+   if( argc != 2 || !image.data )
+     { 
+       printf( "No image data \n" );
+       return -1; 
+     }
+
+   namedWindow( "Display Image", CV_WINDOW_AUTOSIZE );
+   imshow( "Display Image", image );
+
+   waitKey(0);
+
+   return 0;
+}

samples/cpp/tutorial_code/Basic/Drawing_1.cpp

@@ -0,0 +1,172 @@
+/**
+ * @file Drawing_1.cpp
+ * @brief Simple sample code
+ */
+
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+
+#define w 400
+
+using namespace cv;
+
+/// Function headers
+void MyEllipse( Mat img, double angle );
+void MyFilledCircle( Mat img, Point center );
+void MyPolygon( Mat img );
+void MyLine( Mat img, Point start, Point end );
+
+/**
+ * @function main
+ * @brief Main function
+ */
+int main( int argc, char **argv ){
+
+  /// Windows names
+  char atom_window[] = "Drawing 1: Atom";
+  char rook_window[] = "Drawing 2: Rook";
+
+  /// Create black empty images 
+  Mat atom_image = Mat::zeros( w, w, CV_8UC3 );
+  Mat rook_image = Mat::zeros( w, w, CV_8UC3 );
+
+  /// 1. Draw a simple atom:
+  /// -----------------------
+
+  /// 1.a. Creating ellipses 
+  MyEllipse( atom_image, 90 );
+  MyEllipse( atom_image, 0 );
+  MyEllipse( atom_image, 45 );
+  MyEllipse( atom_image, -45 );
+
+  /// 1.b. Creating circles
+  MyFilledCircle( atom_image, Point( w/2.0, w/2.0) );
+
+  /// 2. Draw a rook
+  /// ------------------
+
+  /// 2.a. Create a convex polygon
+  MyPolygon( rook_image );
+
+  /// 2.b. Creating rectangles
+  rectangle( rook_image,
+	     Point( 0, 7*w/8.0 ),
+	     Point( w, w),
+	     Scalar( 0, 255, 255 ),
+	     -1,
+	     8 );
+
+  /// 2.c. Create a few lines 
+  MyLine( rook_image, Point( 0, 15*w/16 ), Point( w, 15*w/16 ) );
+  MyLine( rook_image, Point( w/4, 7*w/8 ), Point( w/4, w ) );
+  MyLine( rook_image, Point( w/2, 7*w/8 ), Point( w/2, w ) );
+  MyLine( rook_image, Point( 3*w/4, 7*w/8 ), Point( 3*w/4, w ) );
+
+  /// 3. Display your stuff!
+  imshow( atom_window, atom_image );
+  cvMoveWindow( atom_window, 0, 200 );
+  imshow( rook_window, rook_image );
+  cvMoveWindow( rook_window, w, 200 );
+
+  waitKey( 0 );
+  return(0);
+}
+
+/// Function Declaration
+
+/**
+ * @function MyEllipse
+ * @brief Draw a fixed-size ellipse with different angles
+ */
+void MyEllipse( Mat img, double angle )
+{
+  int thickness = 2;
+  int lineType = 8;
+
+  ellipse( img,
+	   Point( w/2.0, w/2.0 ),
+	   Size( w/4.0, w/16.0 ),
+	   angle,
+	   0, 
+	   360,
+	   Scalar( 255, 0, 0 ),
+	   thickness,
+	   lineType );  
+}
+
+/**
+ * @function MyFilledCircle
+ * @brief Draw a fixed-size filled circle
+ */
+void MyFilledCircle( Mat img, Point center )
+{
+  int thickness = -1;
+  int lineType = 8;
+
+  circle( img, 
+	  center,
+	  w/32.0,
+	  Scalar( 0, 0, 255 ),
+	  thickness, 
+	  lineType );
+}
+
+/**
+ * @function MyPolygon
+ * @function Draw a simple concave polygon (rook)
+ */
+void MyPolygon( Mat img )
+{
+  int lineType = 8;
+
+  /** Create some points */
+  Point rook_points[1][20];
+  rook_points[0][0] = Point( w/4.0, 7*w/8.0 );
+  rook_points[0][1] = Point( 3*w/4.0, 7*w/8.0 );
+  rook_points[0][2] = Point( 3*w/4.0, 13*w/16.0 );
+  rook_points[0][3] = Point( 11*w/16.0, 13*w/16.0 );
+  rook_points[0][4] = Point( 19*w/32.0, 3*w/8.0 );
+  rook_points[0][5] = Point( 3*w/4.0, 3*w/8.0 );
+  rook_points[0][6] = Point( 3*w/4.0, w/8.0 );
+  rook_points[0][7] = Point( 26*w/40.0, w/8.0 );
+  rook_points[0][8] = Point( 26*w/40.0, w/4.0 );
+  rook_points[0][9] = Point( 22*w/40.0, w/4.0 );
+  rook_points[0][10] = Point( 22*w/40.0, w/8.0 );
+  rook_points[0][11] = Point( 18*w/40.0, w/8.0 );
+  rook_points[0][12] = Point( 18*w/40.0, w/4.0 );
+  rook_points[0][13] = Point( 14*w/40.0, w/4.0 );
+  rook_points[0][14] = Point( 14*w/40.0, w/8.0 );
+  rook_points[0][15] = Point( w/4.0, w/8.0 );
+  rook_points[0][16] = Point( w/4.0, 3*w/8.0 );
+  rook_points[0][17] = Point( 13*w/32.0, 3*w/8.0 );
+  rook_points[0][18] = Point( 5*w/16.0, 13*w/16.0 );
+  rook_points[0][19] = Point( w/4.0, 13*w/16.0) ;
+
+  const Point* ppt[1] = { rook_points[0] };
+  int npt[] = { 20 };
+
+  fillPoly( img,
+	    ppt,
+	    npt,
+            1,
+	    Scalar( 255, 255, 255 ),
+	    lineType );			
+}
+
+/**
+ * @function MyLine
+ * @brief Draw a simple line
+ */
+void MyLine( Mat img, Point start, Point end )
+{
+  int thickness = 2;
+  int lineType = 8;
+  line( img, 
+	start,
+	end,
+	Scalar( 0, 0, 0 ),
+	thickness,
+	lineType );
+}
+
+

samples/cpp/tutorial_code/Basic/Drawing_2.cpp

@@ -0,0 +1,326 @@
+/**
+ * @file Drawing_2.cpp
+ * @brief Simple sample code
+ */
+
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <iostream>
+#include <stdio.h>
+
+using namespace cv;
+
+/// Global Variables
+const int NUMBER = 100; 
+const int DELAY = 5;
+
+const int window_width = 900;
+const int window_height = 600;
+int x_1 = -window_width/2;
+int x_2 = window_width*3/2;
+int y_1 = -window_width/2;
+int y_2 = window_width*3/2;
+
+/// Function headers
+static Scalar randomColor( RNG& rng );
+int Drawing_Random_Lines( Mat image, char* window_name, RNG rng );
+int Drawing_Random_Rectangles( Mat image, char* window_name, RNG rng );
+int Drawing_Random_Ellipses( Mat image, char* window_name, RNG rng );
+int Drawing_Random_Polylines( Mat image, char* window_name, RNG rng );
+int Drawing_Random_Filled_Polygons( Mat image, char* window_name, RNG rng );
+int Drawing_Random_Circles( Mat image, char* window_name, RNG rng );
+int Displaying_Random_Text( Mat image, char* window_name, RNG rng );
+int Displaying_Big_End( Mat image, char* window_name, RNG rng );
+
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  int c;
+
+  /// Start creating a window
+  char window_name[] = "Drawing_2 Tutorial";
+
+  /// Also create a random object (RNG)
+  RNG rng( 0xFFFFFFFF ); 
+
+  /// Initialize a matrix filled with zeros
+  Mat image = Mat::zeros( window_height, window_width, CV_8UC3 );
+  /// Show it in a window during DELAY ms
+  imshow( window_name, image ); 
+  waitKey( DELAY );
+  
+  /// Now, let's draw some lines
+  c = Drawing_Random_Lines(image, window_name, rng);
+  if( c != 0 ) return 0;
+
+  /// Go on drawing, this time nice rectangles
+  c = Drawing_Random_Rectangles(image, window_name, rng);
+  if( c != 0 ) return 0;
+
+  /// Draw some ellipses
+  c = Drawing_Random_Ellipses( image, window_name, rng );
+  if( c != 0 ) return 0;
+
+  /// Now some polylines
+  c = Drawing_Random_Polylines( image, window_name, rng );
+  if( c != 0 ) return 0;
+
+  /// Draw filled polygons
+  c = Drawing_Random_Filled_Polygons( image, window_name, rng );
+  if( c != 0 ) return 0;
+
+  /// Draw circles
+  c = Drawing_Random_Circles( image, window_name, rng );
+  if( c != 0 ) return 0;
+
+  /// Display text in random positions
+  c = Displaying_Random_Text( image, window_name, rng );
+  if( c != 0 ) return 0;
+
+  /// Displaying the big end!
+  c = Displaying_Big_End( image, window_name, rng );
+  if( c != 0 ) return 0;
+
+  waitKey(0);
+  return 0;
+}
+
+/// Function definitions
+
+/**
+ * @function randomColor
+ * @brief Produces a random color given a random object
+ */
+static Scalar randomColor( RNG& rng )
+{
+  int icolor = (unsigned) rng;
+  return Scalar( icolor&255, (icolor>>8)&255, (icolor>>16)&255 );
+}
+
+
+/**
+ * @function Drawing_Random_Lines
+ */
+int Drawing_Random_Lines( Mat image, char* window_name, RNG rng )
+{
+  int lineType = 8;
+  Point pt1, pt2;
+
+  for( int i = 0; i < NUMBER; i++ )
+  {
+    pt1.x = rng.uniform( x_1, x_2 );
+    pt1.y = rng.uniform( y_1, y_2 );
+    pt2.x = rng.uniform( x_1, x_2 );
+    pt2.y = rng.uniform( y_1, y_2 );
+
+    line( image, pt1, pt2, randomColor(rng), rng.uniform(1, 10), 8 );
+    imshow( window_name, image );
+    if( waitKey( DELAY ) >= 0 )
+      { return -1; }
+  }
+
+  return 0;
+}
+
+/**
+ * @function Drawing_Rectangles
+ */
+int Drawing_Random_Rectangles( Mat image, char* window_name, RNG rng )
+{
+  Point pt1, pt2;
+  int lineType = 8;
+  int thickness = rng.uniform( -3, 10 );
+
+  for( int i = 0; i < NUMBER; i++ )
+  {
+    pt1.x = rng.uniform( x_1, x_2 );
+    pt1.y = rng.uniform( y_1, y_2 );
+    pt2.x = rng.uniform( x_1, x_2 );
+    pt2.y = rng.uniform( y_1, y_2 );
+
+    rectangle( image, pt1, pt2, randomColor(rng), MAX( thickness, -1 ), lineType );
+
+    imshow( window_name, image );
+    if( waitKey( DELAY ) >= 0 )
+      { return -1; } 
+  }
+
+  return 0;
+}
+
+/**
+ * @function Drawing_Random_Ellipses
+ */
+int Drawing_Random_Ellipses( Mat image, char* window_name, RNG rng )
+{
+  int lineType = 8;
+
+  for ( int i = 0; i < NUMBER; i++ )
+  {
+    Point center;
+    center.x = rng.uniform(x_1, x_2);
+    center.y = rng.uniform(y_1, y_2);
+    
+    Size axes;
+    axes.width = rng.uniform(0, 200);
+    axes.height = rng.uniform(0, 200);
+
+    double angle = rng.uniform(0, 180);
+
+    ellipse( image, center, axes, angle, angle - 100, angle + 200,
+             randomColor(rng), rng.uniform(-1,9), lineType );
+        
+    imshow( window_name, image );
+    
+    if( waitKey(DELAY) >= 0 ) 
+      { return -1; }
+  }
+
+  return 0;
+}
+
+/**
+ * @function Drawing_Random_Polylines
+ */
+int Drawing_Random_Polylines( Mat image, char* window_name, RNG rng )
+{
+  int lineType = 8;
+
+  for( int i = 0; i< NUMBER; i++ )
+  {
+    Point pt[2][3];
+    pt[0][0].x = rng.uniform(x_1, x_2);
+    pt[0][0].y = rng.uniform(y_1, y_2);
+    pt[0][1].x = rng.uniform(x_1, x_2); 
+    pt[0][1].y = rng.uniform(y_1, y_2); 
+    pt[0][2].x = rng.uniform(x_1, x_2);
+    pt[0][2].y = rng.uniform(y_1, y_2);
+    pt[1][0].x = rng.uniform(x_1, x_2); 
+    pt[1][0].y = rng.uniform(y_1, y_2);
+    pt[1][1].x = rng.uniform(x_1, x_2); 
+    pt[1][1].y = rng.uniform(y_1, y_2);
+    pt[1][2].x = rng.uniform(x_1, x_2); 
+    pt[1][2].y = rng.uniform(y_1, y_2);
+
+    const Point* ppt[2] = {pt[0], pt[1]};
+    int npt[] = {3, 3};
+        
+    polylines(image, ppt, npt, 2, true, randomColor(rng), rng.uniform(1,10), lineType);
+        
+    imshow( window_name, image );
+    if( waitKey(DELAY) >= 0 )
+      { return -1; }
+  }
+  return 0;
+}    
+
+/**
+ * @function Drawing_Random_Filled_Polygons
+ */
+int Drawing_Random_Filled_Polygons( Mat image, char* window_name, RNG rng )
+{
+  int lineType = 8;
+
+  for ( int i = 0; i < NUMBER; i++ )
+  {
+    Point pt[2][3];
+    pt[0][0].x = rng.uniform(x_1, x_2);
+    pt[0][0].y = rng.uniform(y_1, y_2);
+    pt[0][1].x = rng.uniform(x_1, x_2); 
+    pt[0][1].y = rng.uniform(y_1, y_2); 
+    pt[0][2].x = rng.uniform(x_1, x_2);
+    pt[0][2].y = rng.uniform(y_1, y_2);
+    pt[1][0].x = rng.uniform(x_1, x_2); 
+    pt[1][0].y = rng.uniform(y_1, y_2);
+    pt[1][1].x = rng.uniform(x_1, x_2); 
+    pt[1][1].y = rng.uniform(y_1, y_2);
+    pt[1][2].x = rng.uniform(x_1, x_2); 
+    pt[1][2].y = rng.uniform(y_1, y_2);
+
+    const Point* ppt[2] = {pt[0], pt[1]};
+    int npt[] = {3, 3};
+        
+    fillPoly( image, ppt, npt, 2, randomColor(rng), lineType );
+        
+    imshow( window_name, image );
+    if( waitKey(DELAY) >= 0 )
+       { return -1; }
+  }
+  return 0;
+}
+
+/**
+ * @function Drawing_Random_Circles
+ */
+int Drawing_Random_Circles( Mat image, char* window_name, RNG rng )
+{
+  int lineType = 8;
+
+  for (int i = 0; i < NUMBER; i++)
+  {
+    Point center;
+    center.x = rng.uniform(x_1, x_2);
+    center.y = rng.uniform(y_1, y_2);
+        
+    circle( image, center, rng.uniform(0, 300), randomColor(rng),
+            rng.uniform(-1, 9), lineType );
+        
+    imshow( window_name, image );
+    if( waitKey(DELAY) >= 0 )
+      { return -1; }
+  }
+
+  return 0;
+}
+
+/**
+ * @function Displaying_Random_Text
+ */
+int Displaying_Random_Text( Mat image, char* window_name, RNG rng )
+{
+  int lineType = 8;
+
+  for ( int i = 1; i < NUMBER; i++ )
+  {
+    Point org;
+    org.x = rng.uniform(x_1, x_2);
+    org.y = rng.uniform(y_1, y_2);
+
+    putText( image, "Testing text rendering", org, rng.uniform(0,8),
+             rng.uniform(0,100)*0.05+0.1, randomColor(rng), rng.uniform(1, 10), lineType);
+        
+    imshow( window_name, image );
+    if( waitKey(DELAY) >= 0 )
+      { return -1; }
+  }
+
+  return 0;
+}
+
+/**
+ * @function Displaying_Big_End
+ */
+int Displaying_Big_End( Mat image, char* window_name, RNG rng )
+{
+  Size textsize = getTextSize("OpenCV forever!", CV_FONT_HERSHEY_COMPLEX, 3, 5, 0);
+  Point org((window_width - textsize.width)/2, (window_height - textsize.height)/2);
+  int lineType = 8;
+    
+  Mat image2;
+
+  for( int i = 0; i < 255; i += 2 )
+  {
+    image2 = image - Scalar::all(i);
+    putText( image2, "OpenCV forever!", org, CV_FONT_HERSHEY_COMPLEX, 3,
+             Scalar(i, i, 255), 5, lineType );
+        
+    imshow( window_name, image2 );
+    if( waitKey(DELAY) >= 0 )
+       { return -1; }
+  }
+
+  return 0;
+}

samples/cpp/tutorial_code/Basic/LoadSaveImage.cpp

@@ -0,0 +1,52 @@
+/**
+ * @file LoadSaveImage.cpp
+ * @brief Sample code that load an image, modify it and save the new image.  
+ * @author OpenCV team
+ */
+
+#include <cv.h>
+#include <highgui.h>
+
+using namespace cv;
+
+/**
+ * @function main
+ * @brief Self-explanatory
+ */
+int main( int argc, char** argv )
+{
+  /// Get the name of the file to be loaded
+  char* imageName = argv[1];
+
+  /// Create a Mat object
+  Mat image;
+  
+  /// Load the image using imread
+  image = imread( imageName, 1 );
+  
+  /// Verify that the image was loaded
+  if( argc != 2 || !image.data )
+    {
+      printf( " No image data \n " );
+      return -1;
+    }
+
+  /// Change the image to Grayscale
+  Mat gray_image;
+  cvtColor( image, gray_image, CV_RGB2GRAY );
+
+  /// Save our gray image
+  imwrite( "../../images/Gray_Image.png", gray_image );
+
+  /// Create a couple of windows and show our images
+  namedWindow( imageName, CV_WINDOW_AUTOSIZE );
+  namedWindow( "Gray image", CV_WINDOW_AUTOSIZE );
+
+  imshow( imageName, image );
+  imshow( "Gray image", gray_image ); 
+
+  /// Wait until user finish the application   
+  waitKey(0);
+
+  return 0;
+}