根据http://blog.csdn.net/poem_qianmo/article/details/20537737操作，文章内容基本出自该文，并写了一点自己的理解~
1.imread函数
imread函数，载入图片，转到定义处，第一个参数为文件名，第二个flag为加载图片的颜色类型，
Mat imread( const String& filename, int flags = IMREAD_COLOR );
转到IMREAD_COLOR的定义处，可以看到
//! Imread flags enum ImreadModes { IMREAD_UNCHANGED = -1, //!< If set, return the loaded image as is (with alpha channel, otherwise it gets cropped). IMREAD_GRAYSCALE = 0, //!< If set, always convert image to the single channel grayscale image. IMREAD_COLOR = 1, //!< If set, always convert image to the 3 channel BGR color image. IMREAD_ANYDEPTH = 2, //!< If set, return 16-bit/32-bit image when the input has the corresponding depth, otherwise convert it to 8-bit. IMREAD_ANYCOLOR = 4, //!< If set, the image is read in any possible color format. IMREAD_LOAD_GDAL = 8, //!< If set, use the gdal driver for loading the image. IMREAD_REDUCED_GRAYSCALE_2 = 16, //!< If set, always convert image to the single channel grayscale image and the image size reduced 1/2. IMREAD_REDUCED_COLOR_2 = 17, //!< If set, always convert image to the 3 channel BGR color image and the image size reduced 1/2. IMREAD_REDUCED_GRAYSCALE_4 = 32, //!< If set, always convert image to the single channel grayscale image and the image size reduced 1/4. IMREAD_REDUCED_COLOR_4 = 33, //!< If set, always convert image to the 3 channel BGR color image and the image size reduced 1/4. IMREAD_REDUCED_GRAYSCALE_8 = 64, //!< If set, always convert image to the single channel grayscale image and the image size reduced 1/8. IMREAD_REDUCED_COLOR_8 = 65 //!< If set, always convert image to the 3 channel BGR color image and the image size reduced 1/8. };
flags默认值为1，根据注释得到当调用时缺少参数的时候，默认加载图片为三通道的彩色图像，关于通道的理解，参考了这篇文章--学习OpenCV2——Mat之通道的理解
flags的值为2的时候，即当载入图片深度为16位/32位的图片，则载入对应深度的图片，否则载入8位图像。关于深度，深度为该图片存储每个像素所用的位数，图像深度确定彩色图像的每个像素可能有的颜色数,或者确定灰度图像的每个像素可能有的灰度级数。（若深度为n，则可能有的颜色数为2的n次方/灰度数目为2的n次方）
2.namedWindow函数
namedWindow函数，创建窗口，转到定义处，第一个参数为创建的窗口名，第二个参数flag为窗口类型，并转到WINDOW_AUTOSIZE的定义处
void namedWindow(const String& winname, int flags = WINDOW_AUTOSIZE);
//! Flags for cv::namedWindow enum WindowFlags { WINDOW_NORMAL = 0x00000000, //!< the user can resize the window (no constraint) / also use to switch a fullscreen window to a normal size. WINDOW_AUTOSIZE = 0x00000001, //!< the user cannot resize the window, the size is constrainted by the image displayed. WINDOW_OPENGL = 0x00001000, //!< window with opengl support. WINDOW_FULLSCREEN = 1, //!< change the window to fullscreen. WINDOW_FREERATIO = 0x00000100, //!< the image expends as much as it can (no ratio constraint). WINDOW_KEEPRATIO = 0x00000000 //!< the ratio of the image is respected. };
当flags值为WINDOW_NORMAL时可以重新定义窗口的大小，WINDOW_AUTOSIZE时为自适应大小，且不能重新定义大小
3.imshow函数
imshow函数，用于在指定的窗口中显示图像，第一个参数为窗口的名字，如果窗口是用CV_WINDOW_AUTOSIZE（默认值）标志创建的，那么显示图像原始大小。否则，将图像进行缩放以适合窗口。而imshow 函数缩放图像，取决于图像的深度；第二个类型为InputArray的参数mat，转到其定义处
void imshow(const String& winname, InputArray mat);
InputArray为自定义类型，查看其结构
class CV_EXPORTS _InputArray { public: enum { KIND_SHIFT = 16, FIXED_TYPE = 0x8000 << KIND_SHIFT, FIXED_SIZE = 0x4000 << KIND_SHIFT, KIND_MASK = 31 << KIND_SHIFT, NONE = 0 << KIND_SHIFT, MAT = 1 << KIND_SHIFT, MATX = 2 << KIND_SHIFT, STD_VECTOR = 3 << KIND_SHIFT, STD_VECTOR_VECTOR = 4 << KIND_SHIFT, STD_VECTOR_MAT = 5 << KIND_SHIFT, EXPR = 6 << KIND_SHIFT, OPENGL_BUFFER = 7 << KIND_SHIFT, CUDA_HOST_MEM = 8 << KIND_SHIFT, CUDA_GPU_MAT = 9 << KIND_SHIFT, UMAT =10 << KIND_SHIFT, STD_VECTOR_UMAT =11 << KIND_SHIFT, STD_BOOL_VECTOR =12 << KIND_SHIFT, STD_VECTOR_CUDA_GPU_MAT = 13 << KIND_SHIFT }; _InputArray(); _InputArray(int _flags, void* _obj); _InputArray(const Mat& m); _InputArray(const MatExpr& expr); _InputArray(const std::vector<Mat>& vec); template<typename _Tp> _InputArray(const Mat_<_Tp>& m); template<typename _Tp> _InputArray(const std::vector<_Tp>& vec); _InputArray(const std::vector<bool>& vec); template<typename _Tp> _InputArray(const std::vector<std::vector<_Tp> >& vec); template<typename _Tp> _InputArray(const std::vector<Mat_<_Tp> >& vec); template<typename _Tp> _InputArray(const _Tp* vec, int n); template<typename _Tp, int m, int n> _InputArray(const Matx<_Tp, m, n>& matx); _InputArray(const double& val); _InputArray(const cuda::GpuMat& d_mat); _InputArray(const std::vector<cuda::GpuMat>& d_mat_array); _InputArray(const ogl::Buffer& buf); _InputArray(const cuda::HostMem& cuda_mem); template<typename _Tp> _InputArray(const cudev::GpuMat_<_Tp>& m); _InputArray(const UMat& um); _InputArray(const std::vector<UMat>& umv); Mat getMat(int idx=-1) const; Mat getMat_(int idx=-1) const; UMat getUMat(int idx=-1) const; void getMatVector(std::vector<Mat>& mv) const; void getUMatVector(std::vector<UMat>& umv) const; void getGpuMatVector(std::vector<cuda::GpuMat>& gpumv) const; cuda::GpuMat getGpuMat() const; ogl::Buffer getOGlBuffer() const; int getFlags() const; void* getObj() const; Size getSz() const; int kind() const; int dims(int i=-1) const; int cols(int i=-1) const; int rows(int i=-1) const; Size size(int i=-1) const; int sizend(int* sz, int i=-1) const; bool sameSize(const _InputArray& arr) const; size_t total(int i=-1) const; int type(int i=-1) const; int depth(int i=-1) const; int channels(int i=-1) const; bool isContinuous(int i=-1) const; bool isSubmatrix(int i=-1) const; bool empty() const; void copyTo(const _OutputArray& arr) const; void copyTo(const _OutputArray& arr, const _InputArray & mask) const; size_t offset(int i=-1) const; size_t step(int i=-1) const; bool isMat() const; bool isUMat() const; bool isMatVector() const; bool isUMatVector() const; bool isMatx() const; bool isVector() const; bool isGpuMatVector() const; ~_InputArray(); protected: int flags; void* obj; Size sz; void init(int _flags, const void* _obj); void init(int _flags, const void* _obj, Size _sz); };
emmm可以看到，_InputArray类的里面首先定义了一个枚举，然后是各类的模板类型和一些方法，(并不想看)并不看懂(xxxx)，不过在mat.hpp在_InputArray类前有一段介绍，大致理解为用来存储Mat对象的容器
/** @brief This is the proxy class for passing read-only input arrays into OpenCV functions. It is defined as: @code typedef const _InputArray& InputArray; @endcode where _InputArray is a class that can be constructed from `Mat`, `Mat_<T>`, `Matx<T, m, n>`, `std::vector<T>`, `std::vector<std::vector<T> >` or `std::vector<Mat>`. It can also be constructed from a matrix expression. Since this is mostly implementation-level class, and its interface may change in future versions, we do not describe it in details. There are a few key things, though, that should be kept in mind: - When you see in the reference manual or in OpenCV source code a function that takes InputArray, it means that you can actually pass `Mat`, `Matx`, `vector<T>` etc. (see above the complete list). - Optional input arguments: If some of the input arrays may be empty, pass cv::noArray() (or simply cv::Mat() as you probably did before). - The class is designed solely for passing parameters. That is, normally you *should not* declare class members, local and global variables of this type. - If you want to design your own function or a class method that can operate of arrays of multiple types, you can use InputArray (or OutputArray) for the respective parameters. Inside a function you should use _InputArray::getMat() method to construct a matrix header for the array (without copying data). _InputArray::kind() can be used to distinguish Mat from `vector<>` etc., but normally it is not needed. Here is how you can use a function that takes InputArray : @code std::vector<Point2f> vec; // points or a circle for( int i = 0; i < 30; i++ ) vec.push_back(Point2f((float)(100 + 30*cos(i*CV_PI*2/5)), (float)(100 - 30*sin(i*CV_PI*2/5)))); cv::transform(vec, vec, cv::Matx23f(0.707, -0.707, 10, 0.707, 0.707, 20)); @endcode That is, we form an STL vector containing points, and apply in-place affine transformation to the vector using the 2x3 matrix created inline as `Matx<float, 2, 3>` instance. Here is how such a function can be implemented (for simplicity, we implement a very specific case of it, according to the assertion statement inside) : @code void myAffineTransform(InputArray _src, OutputArray _dst, InputArray _m) { // get Mat headers for input arrays. This is O(1) operation, // unless _src and/or _m are matrix expressions. Mat src = _src.getMat(), m = _m.getMat(); CV_Assert( src.type() == CV_32FC2 && m.type() == CV_32F && m.size() == Size(3, 2) ); // [re]create the output array so that it has the proper size and type. // In case of Mat it calls Mat::create, in case of STL vector it calls vector::resize. _dst.create(src.size(), src.type()); Mat dst = _dst.getMat(); for( int i = 0; i < src.rows; i++ ) for( int j = 0; j < src.cols; j++ ) { Point2f pt = src.at<Point2f>(i, j); dst.at<Point2f>(i, j) = Point2f(m.at<float>(0, 0)*pt.x + m.at<float>(0, 1)*pt.y + m.at<float>(0, 2), m.at<float>(1, 0)*pt.x + m.at<float>(1, 1)*pt.y + m.at<float>(1, 2)); } } @endcode There is another related type, InputArrayOfArrays, which is currently defined as a synonym for InputArray: @code typedef InputArray InputArrayOfArrays; @endcode It denotes function arguments that are either vectors of vectors or vectors of matrices. A separate synonym is needed to generate Python/Java etc. wrappers properly. At the function implementation level their use is similar, but _InputArray::getMat(idx) should be used to get header for the idx-th component of the outer vector and _InputArray::size().area() should be used to find the number of components (vectors/matrices) of the outer vector. */
4.imwrite函数
imwirte函数，输出图像到文件，第一个参数为图片名字，第二个为InputArray类型的图片 InputArray类型在上面有介绍。第三个参数const vector<int>&类型的params，表示为特定格式保存的参数编码，它有默认值vector<int>()，所以一般情况下不需要填写。
bool imwrite( const String& filename, InputArray img, const std::vector<int>& params = std::vector<int>());
第三个参数：
1. 对于JPEG格式的图片，这个参数表示从0到100的图片质量（CV_IMWRITE_JPEG_QUALITY），默认值是95.
2.对于PNG格式的图片，这个参数表示压缩级别（CV_IMWRITE_PNG_COMPRESSION）从0到9。较高的值意味着更小的尺寸和更长的压缩时间，而默认值是3
3. 对于PPM，PGM，或PBM格式的图片，这个参数表示一个二进制格式标志（CV_IMWRITE_PXM_BINARY），取值为0或1，而默认值是1。