OpenCV入门函数API解析

一切图像皆Mat

cvtColor:用于将图像从一个颜色空间转换到另一个颜色空间的转换（目前常见的颜色空间均支持），并且在转换的过程中能够保证数据的类型不变，即转换后的图像的数据类型和位深与源图像一致。

 cvtColor(image, hsv, COLOR_BGR2HSV, 0);//H 0-180  S,V 0-255  h,s是控制颜色 V控制亮度

. InputArray src: 输入图像即要进行颜色空间变换的原图像，可以是Mat类 
. OutputArray dst: 输出图像即进行颜色空间变换后存储图像，也可以Mat类 
. int code: 转换的代码或标识，即在此确定将什么制式的图片转换成什么制式的图片，
. int dstCn = 0: 目标图像通道数，如果取值为0，则由src和code决定

imread:找到地址读图

 Mat src = imread("D:/hutao.png");//读进来的图像是一个Mat就是矩阵 8位BGR图像255*255*255如果有透明通道就是2的32次方

imshow:在窗体上显示图片

imshow("HSV", hsv);

imwrite:保存图片到某个路径

imwrite("D:/hsv.png", hsv);

clone：深拷贝完全拷贝

 m1 = image.clone();

copyTo:有重载浅拷贝只拷贝图像非0部分

image.copyTo(m2);
image.copyTo(mask, red);//图像非0的部分不拷贝

 .就可以得到和image一毛一样的矩阵m2。当然需要事先声明m2。并且两者可以互不相关的做各      种操作。

.把mask的非0部分复制到red上

Mat::ones：第一个通道是1其余通道都是0 

Mat::zeros：创建一张黑色的图全是0

 Mat m3 = Mat::zeros(Size(400, 400), CV_8UC3);//8为无符号的单通道（1单通道）(400是图像的尺寸)//上面的1就是单通道就是8*8  如果变成3就是三通道就是8*（8*3）横着的是24竖着的还是8

.图像尺寸大小

.几个通道

at:存取图像中对应坐标为（x，y）的元素坐标

vector:C++的一个类

int pv = image.at(row, col);//uchar是8位的 0-255
image.at(row, col) = 255 - pv;
Vec3b bgr = image.at(row, col);//b就是double
image.at(row, col)[0] = 255 - bgr[0];
image.at(row, col)[1] = 255 - bgr[1];
image.at(row, col)[2] = 255 - bgr[2];

.单通道就是uchar类型

.多通道就是vec类型,3就是三通道，b就是double，单独赋值

ptr:Mat类中的指针

uchar* current_row = image.ptr(row);//获取当前行的指针 是个地址

获取指定指针的地址

add：加操作

subtract：减操作

divide：除操作

multiply：乘操作

  Mat dst = Mat::zeros(image.size(), image.type());
  Mat m = Mat::zeros(image.size(), image.type());//大小类型一致
  m = (2, 2, 2);
  add(image, m, dst);
  imshow("加操作", dst);
  subtract(image, m, dst);
  imshow("减操作", dst);
  /*dst = image / Scalar(2, 2, 2);*/
  divide(image, m, dst);
  imshow("除操作", dst);
  multiply(image, m, dst);
  imshow("乘操作", dst);

输入

输入

输出

scalar：制造一个画布

red = Scalar(40, 40, 200);
image.copyTo(mask, red);//图像非0的部分不拷贝

三通道BGR

addWeighted：函数是将两张相同大小，相同类型的图片融合的函数。他可以实现图片的特效

addWeighted(image, 1.0, m, 0, 3, dst);

参数1：src1，第一个原数组.
参数2：alpha，第一个数组元素权重

参数3：src2第二个原数组
参数4：beta，第二个数组元素权重
参数5：gamma，图1与图2作和后添加的数值。不要太大，不然图片一片白。总和等于255以上就是纯白色了。

参数6：dst，输出图片

createTrackbar：是Opencv中的API，其可在显示图像的窗口中快速创建一个滑动控件，用于手动调节阈值，具有非常直观的效果

createTrackbar("Value Bar", "亮度与对比度调整", &lightness, Max_value, on_lightness, (void*)(&image));//track跟踪bar块 亮度

形式参数一、trackbarname：滑动空间的名称；

形式参数二、winname：滑动空间用于依附的图像窗口的名称；

形式参数三、value：初始化阈值；

形式参数四、count：滑动控件的刻度范围；

形式参数五、TrackbarCallback是回调函数，其定义如下：

static void on_lightness(int b, void* userdata)
{
  Mat image = *((Mat*)userdata);
  Mat m = Mat::zeros(image.size(), image.type());
  Mat dst = Mat::zeros(image.size(), image.type());
  addWeighted(image, 1.0, m, 0, b, dst);
  imshow("亮度与对比度调整", dst);
}//亮度

applyColorMap：给图片上色

applyColorMap(image, dst, COLORMAP_AUTUMN);

输入图

输出图

上色类型

rectangle：绘制矩形

rectangle(m1, Rect(100, 100, 80, 80), Scalar(255, 255, 0), -1, LINE_8, 0);//-1就是线宽 大于0就是绘制 小于0就是填充

输入图像

矩形的左上角坐标以及宽度和长度

颜色

-1就是线宽 大于0就是绘制 小于0就是填充

bitwise_and,bitwise_not,bitwise_or,bitwise_xor:与非或异或

 bitwise_and(m1, m2, dst);
 bitwise_or(m1, m2, dst);
 bitwise_xor(m1, m2, dst);
 bitwise_not(m1, dst);

split:分离通道

 std::vectormv;
  split(image, mv);
  imshow("B", mv[0]);//单通道都是灰度图
  imshow("G", mv[1]);
  imshow("R", mv[2]);

merge：合并通道

 Mat dst;
  mv[0] = 0;//蓝色的通道是0
  mv[1] = 0;//绿色的通道是0
  //0，0，255就是红色
  merge(mv, dst);

可以给分离后的通道赋值然后合并

mixChannels：主要就是把输入的矩阵（或矩阵数组）的某些通道拆分复制给对应的输出矩阵（或矩阵数组）的某些通道中，其中的对应关系就由fromTo参数指定.

int from_to[] = { 0, 2, 1, 1, 2, 0 };//int的0通道复制到out的2通道。其他同理
  mixChannels(&image, 1, &dst, 1, from_to, 3);

输入矩阵的向量（可以理解成一队矩阵），所有矩阵必须有相同的大小和深度。

输入矩阵的个数。

输出矩阵的向量。所有的矩阵必须事先分配空间（如用create），大小和深度须与输入矩阵等同。

输出矩阵的个数。

序号对向量，用来决定哪个通道被拷贝。

通道数。

inRange：主要是将在两个阈值内的像素值设置为白色（255），而不在阈值区间内的像素值设置为黑色（0），该功能类似于之间所讲的双阈值化操作。

 inRange(hsv, Scalar(75, 75, 75), Scalar(85, 85, 85), mask);//最小取值和最大取值

• 参数1：输入要处理的图像，可以为单通道或多通道。
• 参数2：包含下边界的数组或标量。
• 参数3：包含上边界数组或标量。
• 参数4：输出图像，与输入图像src 尺寸相同且为CV_8U 类型。

minMaxLoc：寻找矩阵中最小值和最大值的位置. 参数若不需要,则置为NULL或者0,即可. 

 minMaxLoc(mv[i], &minv, &maxv, &minLoc, &maxLoc, Mat());
    std::cout << "min value" << minv << "max value" << maxv << std::endl;//单通道的最小值和最大值

参数1：InputArray类型的src，输入单通道数组（图像）。
参数2：double*类型的minVal，返回最小值的指针。若无须返回，此值置为NULL。（0-255）
参数3：double*类型的maxVal，返回最大值的指针。若无须返回，此值置为NULL。
参数4：Point*类型的minLoc，返回最小位置的指针（二维情况下）。若无须返回，此值置为NULL。（位置坐标）
参数5：Point*类型的maxLoc，返回最大位置的指针（二维情况下）。若无须返回，此值置为NULL。
参数6：InputArray类型的mask，用于选择子阵列的可选掩膜。

meanStdDev：计算矩阵的均值和标准偏差。

  meanStdDev(image, mean, stddev);//均值和标准方差 方差越小有效信息就越小

• 均值反映了图像的亮度，均值越大说明图像亮度越大，反之越小；
• 标准差反映了图像像素值与均值的离散程度，标准差越大说明图像的质量越好；

src：输入矩阵，这个矩阵应该是1-4通道的

mean：输出参数，计算均值

stddev：输出参数，计算标准差

mask：可选参数

rectangle:画矩形

Rect rect;
  rect.x = 200;
  rect.y = 200;
  rect.width = 100;
  rect.height = 100;
  rectangle(image, rect, Scalar(0, 0, 255), 2, 8, 0);

img：图像.
pt1：矩形的一个顶点。
pt2：矩形对角线上的另一个顶点
color：线条颜色 (RGB) 或亮度（灰度图像 ）(grayscale image）。
thickness：组成矩形的线条的粗细程度。取负值时（如 CV_FILLED）函数绘制填充了色彩的矩形。
line_type：线条的类型。见cvLine的描述
shift：坐标点的小数点位数。

circle:画圆

 circle(image, Point(300, 300), 15, Scalar(255, 0, 0), 2, 8, 0);

img为图像

center为圆心坐标

radius为圆的半径

color为设定圆的颜色，规则根据B（蓝）G（绿）R（红）

thickness 如果是正数，表示组成圆的线条的粗细程度。否则，-1表示圆是否被填充

line_type 线条的类型。默认是8

shift 圆心坐标点和半径值的小数点位数

line:画线

 line(image, Point(200, 200), Point(300, 300), Scalar(0, 255, 0), 2, LINE_AA, 0);//反锯齿

第一个参数img：要划的线所在的图像;

第二个参数pt1：直线起点

第二个参数pt2：直线终点

第三个参数color：直线的颜色 e.g:Scalor(0,0,255)

第四个参数thickness=1：线条粗细

第五个参数line_type=8, 

   8 (or 0) - 8-connected line（8邻接)连接 线。
   4 - 4-connected line(4邻接)连接线。

   CV_AA - antialiased 线条。抗锯齿

第六个参数：坐标点的小数点位数。

ellipse：画椭圆

RotatedRect rrt;
  rrt.center = Point(200, 200);
  rrt.size = Size(100, 200);
  rrt.angle = 90.0;
  ellipse(image, rrt, (0, 0, 0), 2, 8);

img：图像。
center：椭圆圆心坐标。
axes：轴的长度。
angle：偏转的角度。
start_angle：圆弧起始角的角度。.
end_angle：圆弧终结角的角度。
color：线条的颜色。
thickness：线条的粗细程度。
line_type：线条的类型,见CVLINE的描述。
shift：圆心坐标点和数轴的精度。

setMouseCallback：

setMouseCallback("鼠标绘制", on_draw, (void*)(&image));
//回调函数
static void on_draw(int event, int x, int y, int flags, void* userdata)
{
  Mat image = *((Mat*)userdata);
  if (event == EVENT_LBUTTONDOWN)
  {
    sp.x = x;
    sp.y = y;
  }
  else if (event == EVENT_LBUTTONUP)
  {
    ep.x = x;
    ep.y = y;
    int dx = ep.x - sp.x;
    int dy = ep.y - sp.y;
    if (dx > 0 && dy > 0)
    {
      Rect rect(sp.x, sp.y, dx, dy);
      rectangle(image, rect, Scalar(0, 0, 255), 2, 8, 0);
      imshow("鼠标绘制", image);
      imshow("ROI区域", temp(rect));//在temp上截取区域
      //为下一次绘画准备
      sp.x = -1;
      sp, y = -1;
    }
  }
  else if (event == EVENT_MOUSEMOVE)
  {
    if (sp.x > 0 && sp.y > 0)
    {
      ep.x = x;
      ep.y = y;
      int dx = ep.x - sp.x;
      int dy = ep.y - sp.y;
      if (dx > 0 && dy > 0)
      {
        Rect rect(sp.x, sp.y, dx, dy);
        temp.copyTo(image);
        rectangle(image, rect, Scalar(0, 0, 255), 2, 8, 0);
        imshow("鼠标绘制", image);
      }
    }
  }
}

 void setMousecallback(const string& winname, MouseCallback onMouse, void* userdata=0)
    winname:窗口的名字
    onMouse:鼠标响应函数，回调函数。指定窗口里每次鼠标时间发生的时候，被调用的函数指针。 这个函数的原型应该为void on_Mouse(int event, int x, int y, int flags, void* param);
    userdate：传给回调函数的参数 

void on_Mouse(int event, int x, int y, int flags, void* param);
event是 CV_EVENT_*变量之一
x和y是鼠标指针在图像坐标系的坐标（不是窗口坐标系） 
flags是CV_EVENT_FLAG的组合， param是用户定义的传递到setMouseCallback函数调用的参数。

附常用的event：
EVENT_MOUSEMOVE

EVENT_LBUTTONDOWN 

EVENT_RBUTTONDOWN   

EVENT_LBUTTONUP    

EVENT_RBUTTONUP   

和标志位flags有关的：

EVENT_FLAG_LBUTTON 

鼠标响应原文链接：https://blog.csdn.net/qq_29540745/article/details/52562101

normalize：归一化使数据在0-1范围内

 image.convertTo(image, CV_32F);//把三通道的CV_8UC3编程浮点类型 F换成S就是int类型 实现归一化
  //归一化之后 必须要进行这步操作才能显示 也就是说归一化之后 取值必须是O-1之间
  normalize(image, dst, 1.0, 0, NORM_MINMAX);

src：输入数组

dst：输出数组，支持原地运算

alpha：range normalization模式的最小值

beta：range normalization模式的最大值，不用于norm normalization(范数归一化)模式。

normType：归一化的类型，可以有以下的取值：

    NORM_MINMAX:数组的数值被平移或缩放到一个指定的范围，线性归一化，一般较常用。

    NORM_INF: 此类型的定义没有查到，根据OpenCV 1的对应项，可能是归一化数组的C-范数(绝对值的最大值)

    NORM_L1 :  归一化数组的L1-范数(绝对值的和)

    NORM_L2: 归一化数组的(欧几里德)L2-范数

dtype：dtype为负数时，输出数组的type与输入数组的type相同；否则，输出数组与输入数组只是通道数相同，而tpye=CV_MAT_DEPTH(dtype).

mask：操作掩膜，用于指示函数是否仅仅对指定的元素进行操作。

convertTo：图像类型转换

 image.convertTo(image, CV_32F);//把三通道的CV_8UC3编程浮点类型 F换成S就是int类型 实现归一化
  //归一化之后 必须要进行这步操作才能显示 也就是说归一化之后 取值必须是O-1之间

dst：目的矩阵；
type：需要的输出矩阵类型，或者更明确的，是输出矩阵的深度，如果是负值（常用-1）则输出矩阵和输入矩阵类型相同；
scale:比例因子；
shift：将输入数组元素按比例缩放后添加的值；

resize：图像缩放

 resize(image, zoommin, Size(w / 2, h / 2), 0, 0, INTER_LINEAR);//最后的参数有四种方法 去他的csdn

InputArray src ：输入，原图像，即待改变大小的图像；
OutputArray dst： 输出，改变后的图像。这个图像和原图像具有相同的内容，只是大小和原图像不一样而已；
dsize：输出图像的大小。
如果这个参数不为0，那么就代表将原图像缩放到这个Size(width，height)指定的大小；如果这个参数为0，那么原图像缩放之后的大小就要通过下面的公式来计算：
dsize = Size(round(fxsrc.cols), round(fysrc.rows))

其中，fx和fy就是下面要说的两个参数，是图像width方向和height方向的缩放比例。
fx：width方向的缩放比例，如果它是0，那么它就会按照(double)dsize.width/src.cols来计算；
fy：height方向的缩放比例，如果它是0，那么它就会按照(double)dsize.height/src.rows来计算；

interpolation：这个是指定插值的方式，图像缩放之后，肯定像素要进行重新计算的，就靠这个参数来指定重新计算像素的方式，有以下几种：
INTER_NEAREST - 最邻近插值
INTER_LINEAR - 双线性插值，如果最后一个参数你不指定，默认使用这种方法
INTER_AREA - resampling using pixel area relation. It may be a preferred method for image decimation, as it gives moire’-free results. But when the image is zoomed, it is similar to the INTER_NEAREST method.
INTER_CUBIC - 4x4像素邻域内的双立方插值
INTER_LANCZOS4 - 8x8像素邻域内的Lanczos插值

flip：镜像图像

 Mat dst;
  flip(image, dst, 0);
  imshow("上下翻转", dst);
  flip(image, dst, 1);
  imshow("左右翻转", dst);
  flip(image, dst, -1);
  imshow("上下左右翻转", dst);//对角线翻转

0：上下翻转

1：左右翻转

2：对角线翻转

getRotationMatrix2D:图像旋转

 M = getRotationMatrix2D(Point2f(w / 2, h / 2), 45, 1.0);//图像中心，旋转角度，缩放

Point2f center：表示旋转的中心点

double angle：表示旋转的角度

double scale：图像缩放因子

warpAffine：放射变换

  warpAffine(image, dst, M, Size(nw, nh), INTER_LINEAR, 0, Scalar(255, 0, 0));

src - 输入图像。
M - 变换矩阵。
dsize - 输出图像的大小。
flags - 插值方法的组合（int 类型！）
borderMode - 边界像素模式（int 类型！）
borderValue - （重点！）边界填充值; 默认情况下，它为0。

VideoCapture：视频读类

VideoCapture capture("D:/leishen.mp4");//0就是开摄像头
int frame_width = capture.get(CAP_PROP_FRAME_WIDTH);//set可以取分辨率 看相机支不支持
capture.read(frame);

VideoWriter：视频写类

 VideoWriter writer("D:/text.mp4", capture.get(CAP_PROP_FOURCC), fps, Size(frame_width, frame_height), true);
writer.write(frame);

文件的名称，格式，帧率，帧大小，是否彩色

calcHist：计算直方图通道

std::vector bgr_plane;
  split(image, bgr_plane);
  // 定义参数变量
  const int channels[1] = { 0 };
  const int bins[1] = { 256 };//灰度级别
  float hranges[2] = { 0,255 };//通道取值范围
  const float* ranges[1] = { hranges };
  Mat b_hist;
  Mat g_hist;
  Mat r_hist;
  // 计算Blue, Green, Red通道的直方图
  calcHist(&bgr_plane[0], 1, 0, Mat(), b_hist, 1, bins, ranges);
  calcHist(&bgr_plane[1], 1, 0, Mat(), g_hist, 1, bins, ranges);
  calcHist(&bgr_plane[2], 1, 0, Mat(), r_hist, 1, bins, ranges);

onst Mat* images：输入图像

 int nimages：输入图像的个数

const int* channels：需要统计直方图的第几通道

InputArray mask：掩膜，，计算掩膜内的直方图  ...Mat()

OutputArray hist:输出的直方图数组

int dims：需要统计直方图通道的个数

const int* histSize：指的是直方图分成多少个区间，就是 bin的个数

const float** ranges： 统计像素值得区间

bool uniform=true::是否对得到的直方图数组进行归一化处理

bool accumulate=false：在多个图像时，是否累计计算像素值得个数

normalize：归一化

 int hist_w = 512;
  int hist_h = 400;
  int bin_w = cvRound((double)hist_w / bins[0]);
  Mat histImage = Mat::zeros(hist_h, hist_w, CV_8UC3);
  // 归一化直方图数据
  normalize(b_hist, b_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat());
  normalize(g_hist, g_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat());
  normalize(r_hist, r_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat());

src：输入数组

dst：输出数组，支持原地运算

alpha：range normalization模式的最小值

beta：range normalization模式的最大值，不用于norm normalization(范数归一化)模式。

normType

    归一化的类型，可以有以下的取值：

    NORM_MINMAX:数组的数值被平移或缩放到一个指定的范围，线性归一化，一般较常用。

    NORM_INF: 此类型的定义没有查到，根据OpenCV 1的对应项，可能是归一化数组的C-范数(绝对值的最大值)

    NORM_L1 :  归一化数组的L1-范数(绝对值的和)

    NORM_L2: 归一化数组的(欧几里德)L2-范数

dtype：dtype为负数时，输出数组的type与输入数组的type相同；否则，输出数组与输入数组只是通道数相同，而tpye=CV_MAT_DEPTH(dtype).

mask：操作掩膜，用于指示函数是否仅仅对指定的元素进行操作

cvRound：返回跟参数最接近的整数值；

 line(histImage, Point(bin_w * (i - 1), hist_h - (b_hist.at(i - 1))),
      Point(bin_w * (i), hist_h - cvRound(b_hist.at(i))), Scalar(255, 0, 0), 2, 8, 0);

cvFloor：返回不大于参数的最大整数值；

cvCeil：返回不小于参数的最小整数值。

applyColorMap：伪彩色函数

applyColorMap(hist2d_image, hist2d_image, COLORMAP_JET);

最后一个参数：colormap（色度图）

equalizeHist：图像均衡化，用于提高图像的质量（增强对比度）

 Mat gray;
  cvtColor(image, gray, COLOR_BGR2GRAY);
  imshow("灰度图", gray);
  Mat dst;
  equalizeHist(gray, dst);
  imshow("均衡化", dst);

blur：blur的作用是对输入的图像src进行均值滤波后用dst输出。

 blur(image, dst, Size(3, 3), Point(-1, -1));//3X3的卷积 -1，-1是卷积和中心

第一个参数，InputArray类型的src，输入图像，即源图像，填Mat类的对象即可。该函数对通道是独立处理的，且可以处理任意通道数的图片，但需要注意，待处理的图片深度应该为CV_8U, CV_16U, CV_16S, CV_32F 以及 CV_64F之一。
第二个参数，OutputArray类型的dst，即目标图像，需要和源图片有一样的尺寸和类型。比如可以用Mat::Clone，以源图片为模板，来初始化得到如假包换的目标图。
第三个参数，Size类型（对Size类型稍后有讲解）的ksize，内核的大小。一般这样写Size( w,h )来表示内核的大小( 其中，w 为像素宽度， h为像素高度)。Size（3,3）就表示3x3的核大小，Size（5,5）就表示5x5的核大小
第四个参数，Point类型的anchor，表示锚点（即被平滑的那个点），注意他有默认值Point(-1,-1)。如果这个点坐标是负值的话，就表示取核的中心为锚点，所以默认值Point(-1,-1)表示这个锚点在核的中心。
第五个参数，int类型的borderType，用于推断图像外部像素的某种边界模式。有默认值BORDER_DEFAULT，我们一般不去管它。
原文链接：https://blog.csdn.net/mao_hui_fei/article/details/79934269

GaussianBlur：高斯模糊

GaussianBlur(image, dst, Size(5, 5), 15);

​

src，输入图像，即源图像，填Mat类的对象即可。它可以是单独的任意通道数的图片，但需要注意，图片深度应该为CV_8U,CV_16U, CV_16S, CV_32F 以及 CV_64F之一。

dst，即目标图像，需要和源图片有一样的尺寸和类型。比如可以用Mat::Clone，以源图片为模板，来初始化得到如假包换的目标图。

ksize，高斯内核的大小。其中ksize.width和ksize.height可以不同，但他们都必须为正数和奇数（并不能理解）。或者，它们可以是零的，它们都是由sigma计算而来。

sigmaX，表示高斯核函数在X方向的的标准偏差。

sigmaY，表示高斯核函数在Y方向的的标准偏差。若sigmaY为零，就将它设为sigmaX，如果sigmaX和sigmaY都是0，那么就由ksize.width和ksize.height计算出来。
原文链接：https://blog.csdn.net/godadream/article/details/81568844

bilateralFilter：高斯双边模糊（美颜）

 bilateralFilter(image, dst, 0, 100, 10);

. InputArray src: 输入图像，可以是Mat类型，图像必须是8位或浮点型单通道、三通道的图像。
. OutputArray dst: 输出图像，和原图像有相同的尺寸和类型。
. int d: 表示在过滤过程中每个像素邻域的直径范围。如果这个值是非正数，则函数会从第五个参数sigmaSpace计算该值。
. double sigmaColor: 颜色空间过滤器的sigma值，这个参数的值月大，表明该像素邻域内有月宽广的颜色会被混合到一起，产生较大的半相等颜色区域。
. double sigmaSpace: 坐标空间中滤波器的sigma值，如果该值较大，则意味着颜色相近的较远的像素将相互影响，从而使更大的区域中足够相似的颜色获取相同的颜色。当d>0时，d指定了邻域大小且与sigmaSpace五官，否则d正比于sigmaSpace.
. int borderType=BORDER_DEFAULT: 用于推断图像外部像素的某种边界模式，有默认值BORDER_DEFAULT.
原文链接：https://blog.csdn.net/keith_bb/article/details/54427779

各位加油，为了我们的梦想，为了成为自己想要成为的人。