目录
char *argv[] and char **argv
int main (int argc,char *argv[])
int main (int argc,char **argv) // argv points to argv[] , argv[] points to char
#include<stdio.h>
#include<string.h>
int main(int argc,char *argv[])//同int main(int argc,char **argv)
{
char *str_test = "hello wang";
int i,j,len;
for(i=0;i<argc;i++)
{
printf("argv%d is %s
",i,argv[i]);
len = strlen(argv[i]);
printf("len = %d
",len);
for(j=0;j<len;j++)
{
printf("argv%d%d is %c
",i,j,argv[i][j]);
}
}
printf("str_test = %s
",str_test);
printf("str_test = %c
",str_test[1]);
return 0;
}
The result of the program:
The "Square Detector" program
// The "Square Detector" program.
// It loads several images sequentially and tries to find squares in
// each image
#include "opencv2/core/core.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui/highgui.hpp"
#include <iostream>
#include <math.h>
#include <string.h>
using namespace cv;
using namespace std;
static void help)
{
cout <<
"
A program using pyramid scaling, Canny, contours, contour simplification and
"
"memory storage (it's got it all folks) to find
"
"squares in a list of images pic1-6.pn1g
"
"Returns sequence of squares detected on the image.
"
"the sequence is stored in the specified memory storage
"
"Call:
"
"./squares
"
"Using OpenCV version %s
" << CV_VERSION << "
" << endl;
}
int thresh = 50, N = 11;
const char* wndname = "Square Detection Demo";
// helper function:
// finds a cosine of angle between vectors
// from pt0->pt1 and from pt0->pt2
static double angle(Point pt1, Point pt2, Point pt0)
{
double dx1 = pt1.x - pt0.x;
double dy1 = pt1.y - pt0.y;
double dx2 = pt2.x - pt0.x;
double dy2 = pt2.y - pt0.y;
return (dx1*dx2 + dy1*dy2) / sqrt((dx1*dx1 + dy1*dy1)*(dx2*dx2 + dy2*dy2) + 1e-10);
}
// returns sequence of squares detected on the image.
// the sequence is stored in the specified memory storage
static void findSquares(const Mat& image, vector<vector<Point> >& squares)
{
squares.clear();
Mat pyr, timg, gray0(image.size(), CV_8U), gray;
// down-scale and upscale the image to filter out the noise
pyrDown(image, pyr, Size(image.cols / 2, image.rows / 2));
pyrUp(pyr, timg, image.size());
vector<vector<Point> > contours;
// find squares in every color plane of the image
for (int c = 0; c < 3; c++)
{
int ch[] = { c, 0 };
mixChannels(&timg, 1, &gray0, 1, ch, 1);
// try several threshold levels
for (int l = 0; l < N; l++)
{
// hack: use Canny instead of zero threshold level.
// Canny helps to catch squares with gradient shading
if (l == 0)
{
// apply Canny. Take the upper threshold from slider
// and set the lower to 0 (which forces edges merging)
Canny(gray0, gray, 0, thresh, 5);
// dilate canny output to remove potential
// holes between edge segments
dilate(gray, gray, Mat(), Point(-1, -1));
}
else
{
// apply threshold if l!=0:
// tgray(x,y) = gray(x,y) < (l+1)*255/N ? 255 : 0
gray = gray0 >= (l + 1) * 255 / N;
}
// find contours and store them all as a list
findContours(gray, contours, RETR_LIST, CHAIN_APPROX_SIMPLE);
vector<Point> approx;
// test each contour
for (size_t i = 0; i < contours.size(); i++)
{
// approximate contour with accuracy proportional
// to the contour perimeter
approxPolyDP(Mat(contours[i]), approx, arcLength(Mat(contours[i]), true)*0.02, true);
// square contours should have 4 vertices after approximation
// relatively large area (to filter out noisy contours)
// and be convex.
// Note: absolute value of an area is used because
// area may be positive or negative - in accordance with the
// contour orientation
if (approx.size() == 4 &&
fabs(contourArea(Mat(approx))) > 1000 &&
isContourConvex(Mat(approx)))
{
double maxCosine = 0;
for (int j = 2; j < 5; j++)
{
// find the maximum cosine of the angle between joint edges
double cosine = fabs(angle(approx[j % 4], approx[j - 2], approx[j - 1]));
maxCosine = MAX(maxCosine, cosine);
}
// if cosines of all angles are small
// (all angles are ~90 degree) then write quandrange
// vertices to resultant sequence
if (maxCosine < 0.3)
squares.push_back(approx);
}
}
}
}
}
// the function draws all the squares in the image
static void drawSquares(Mat& image, const vector<vector<Point> >& quares)
{
for (size_t i = 0; i < squares.size(); i++)
{
const Point* p = &squares[i][0];
int n = (int)squares[i].size();
polylines(image, &p, &n, 1, true, Scalar(0, 255, 0), 3, LINE_AA);
}
imshow(wndname, image);
}
int main(int /*argc*/, char** /*argv*/)
{
static const char* names[] = { "D:/OpenCV 3.1/opencv/sources/samples/data/pic1.png",
"D:/OpenCV 3.1/opencv/sources/samples/data/pic2.png",
"D:/OpenCV 3.1/opencv/sources/samples/data/pic3.png",
"D:/OpenCV 3.1/opencv/sources/samples/data/pic4.png",
"D:/OpenCV 3.1/opencv/sources/samples/data/pic5.png",
"D:/OpenCV 3.1/opencv/sources/samples/data/pic6.png", 0 };
help();
namedWindow(wndname, 1);
vector<vector<Point> > squares;
for (int i = 0; names[i] != 0; i++)
{
Mat image = imread(names[i], 1);
if (image.empty())
{
cout << "Couldn't load " << names[i] << endl;
continue;
}
findSquares(image, squares);
drawSquares(image, squares);
int c = waitKey();
if ((char)c == 27)
break;
}
return 0;
}
The End Of The Code
The Unknown Word
| First Column | Second Column |
|---|---|
| cosine | 余弦 |
| a cosine of angle | 角度的余弦值 |
| cast | 铸造；投射；投掷[kaest] |
| Named Casts | 命名的强制类型转化 |
| reinterpret | 重新解读[ri:in'te:rprit] |
| grammar | 语法['graeme] |
| the specific kind of the conversion | 某种特定的转化 |
| is performed on the expression | 在expression上执行 |
| sort | 分类[so:rt] |
The gerenal form for the named cast notation is the following:
cast-name<type>(expression);
- cast-name may be one of static-cast,const-cast,dynamic-cast,or reinterpret-cast.
- type is the target type of the conversion.
- expression is the value to be cast.
- The type of cast determines the specific kind of conversion that is performed on the expression.
Defining a Dynamic Array
When we dynamically allocate an array,we specify the type and size but do not name the object.Instead,the new expression returns a pointer to the first element in the newly allocated array:
int *pia=new int[10]; //array of 10 uninitialized ints
Freeing Dynamic Memory
delete [] pia;
deallocates the array pointed to by pia,returning the associated memory to the free store.The empty bracket pair between the delete keyword and the pinter is necessary:It indicates to the compiler that the pointer addresses an array of elements on the free store and not simply a single object.
Arguments to main
argument is often novice programmer's first encouter with pointers to arrays of pointers and can prove intimidating.However,it is quite simple to understand.Since argv is used to refer to an array of strings,its declaration will look like this char *argv[]
- int main(int argc,char *argv[]);
- int main(int argc,char **argv);
Pointer This(Introducing const Member Functions)
This is a keyword in C++,and also a const pointer.It points to the current object,and it can access all the members of the current object.For example,for stu.show(),stu is the current object,and this points to stu.
The following is a complete example of using this:
#include <iostream>
using namespace std;
class Student{
public:
void setname(char *name);
void setage(int age);
void setscore(float score);
void show();
private:
char *name;
int age;
float score;
};
void Student::setname(char *name){
this->name = name;
}
void Student::setage(int age){
this->age = age;
}
void Student::setscore(float score){
this->score = score;
}
void Student::show(){
cout<<this->name<<"的年龄是"<<this->age<<"，成绩是"<<this->score<<endl;
}
int main(){
Student *pstu = new Student;
pstu -> setname("李华");
pstu -> setage(16);
pstu -> setscore(96.5);
pstu -> show();
return 0;
}
- The Result