Adding two image & changing the contrast and blightness & Basic Drawing

Adding (blending) two images using OpenCV

sscanf(argv[1],"%lf",&input);//将输入的char* 变换成double类型。

 

the function addWeighted comes quite handy:
beta = ( 1.0 - alpha );
addWeighted( src1, alpha, src2, beta, 0.0, dst);
since addWeighted produces:
dst = α · src1 + β · src2 + γ
In this case, γ is the argument 0.0 in the code above.

Mat src1,dst;

src1 = imread(argv[2],1);

imshow( "Linear Blend", dst );

#include <cv.h>
#include <highgui.h>
#include <iostream>
using namespace cv;
int main( int argc, char** argv )
{
double alpha = 0.5; double beta; double input;
Mat src1, src2, dst;
/// Ask the user enter alpha
/// We use the alpha provided by the user iff it is between 0 and 1
if( argc !=4 )
{
        std::cout<<"Usage: "<<argv[0]<<" alpha(0-1) pic1 pic2"<<std::endl;
        return -1;
}
sscanf(argv[1],"%lf",&input);
if( input >= 0 && input <= 1 ) //the original one in tutorials is incorrect
{ alpha = input; }
/// Read image ( same size, same type )
src1 = imread(argv[2],1);
src2 = imread(argv[3],1);
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;
}

 

Changing the contrast(对比度） and brightness of an image!

 

Mat new_image = Mat::zeros( image.size(), image.type() );
We observe that Mat::zeros returns a Matlab-style zero initializer based on image.size() and image.type()

 

operating with RGB images,

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 ); }
}
}

 

  To access each pixel in the images we are using this syntax: image.at<Vec3b>(y,x)[c] where y is the row,
x is the column and c is R, G or B (0, 1 or 2).
• Since the operation α · p(i, j) + β can give values out of range or not integers (if α is float), we use
saturate_cast to make sure the values are valid.

Basic Drawing

/// Create black empty images
Mat atom_image = Mat::zeros( w, w, CV_8UC3 );

line( img,
start,
end,
Scalar( 0, 0, 0 ),
thickness,
lineType );

– Draw a line from Point start to Point end
– The line is displayed in the image img
– The line color is defined by Scalar( 0, 0, 0) which is the RGB value correspondent to Black
– The line thickness is set to thickness (in this case 2)
– The line is a 8-connected one (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 );

– The ellipse is displayed in the image img
– The ellipse center is located in the point (w/2.0, w/2.0) and is enclosed in a box of size (w/4.0, w/16.0)
– The ellipse is rotated angle degrees
– The ellipse extends an arc between 0 and 360 degrees
– The color of the figure will be Scalar( 255, 255, 0) which means blue in RGB value.
– The ellipse’s thickness is 2.

circle( img,
center,
w/32.0,
Scalar( 0, 0, 255 ),
thickness,
lineType );

– The image where the circle will be displayed (img)
– The center of the circle denoted as the Point center
– The radius of the circle: w/32.0
– The color of the circle: Scalar(0, 0, 255) which means Red in BGR
– Since thickness = -1, the circle will be drawn filled.

/**
 * @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,   7*w/8 );
  rook_points[0][1]  = Point(  3*w/4,   7*w/8 );
  rook_points[0][2]  = Point(  3*w/4,  13*w/16 );
  rook_points[0][3]  = Point( 11*w/16, 13*w/16 );
  rook_points[0][4]  = Point( 19*w/32,  3*w/8 );
  rook_points[0][5]  = Point(  3*w/4,   3*w/8 );
  rook_points[0][6]  = Point(  3*w/4,     w/8 );
  rook_points[0][7]  = Point( 26*w/40,    w/8 );
  rook_points[0][8]  = Point( 26*w/40,    w/4 );
  rook_points[0][9]  = Point( 22*w/40,    w/4 );
  rook_points[0][10] = Point( 22*w/40,    w/8 );
  rook_points[0][11] = Point( 18*w/40,    w/8 );
  rook_points[0][12] = Point( 18*w/40,    w/4 );
  rook_points[0][13] = Point( 14*w/40,    w/4 );
  rook_points[0][14] = Point( 14*w/40,    w/8 );
  rook_points[0][15] = Point(    w/4,     w/8 );
  rook_points[0][16] = Point(    w/4,   3*w/8 );
  rook_points[0][17] = Point( 13*w/32,  3*w/8 );
  rook_points[0][18] = Point(  5*w/16, 13*w/16 );
  rook_points[0][19] = Point(    w/4,  13*w/16 );

  const Point* ppt[1] = { rook_points[0] };
  int npt[] = { 20 };

  fillPoly( img,
        ppt,
        npt,
            1,
        Scalar( 255, 255, 255 ),
        lineType );
}

– The polygon will be drawn on img
– The vertices of the polygon are the set of points in ppt
– The total number of vertices to be drawn are npt
– The number of polygons to be drawn is only 1
– The color of the polygon is defined by Scalar( 255, 255, 255), which is the BGR value for white

rectangle( rook_image,
Point( 0, 7*w/8.0 ),
Point( w, w),
Scalar( 0, 255, 255 ),
-1,
8 );

– The rectangle will be drawn on rook_image
– Two opposite vertices of the rectangle are defined by ** Point( 0, 7*w/8.0 )** and Point( w, w)
– The color of the rectangle is given by Scalar(0, 255, 255) which is the BGR value for yellow
– Since the thickness value is given by -1, the rectangle will be filled.