InputArray和OutputArray

源码路径：~/opencv-2.4.9/modules/core/include/opencv2/core/core.hpp

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.

 typedef const _InputArray& InputArray;
 typedef InputArray InputArrayOfArrays;
 typedef const _OutputArray& OutputArray;
 typedef OutputArray OutputArrayOfArrays;
 typedef OutputArray InputOutputArray;
 typedef OutputArray InputOutputArrayOfArrays;

 /*!
  Proxy datatype for passing Mat's and vector<>'s as input parameters
  */
 class CV_EXPORTS _InputArray
 {
 public:
     enum {
         KIND_SHIFT = ,
         FIXED_TYPE = 0x8000 << KIND_SHIFT,
         FIXED_SIZE = 0x4000 << KIND_SHIFT,
         KIND_MASK = ~(FIXED_TYPE|FIXED_SIZE) - ( << KIND_SHIFT) + ,

         NONE              =  << KIND_SHIFT,
         MAT               =  << KIND_SHIFT,
         MATX              =  << KIND_SHIFT,
         STD_VECTOR        =  << KIND_SHIFT,
         STD_VECTOR_VECTOR =  << KIND_SHIFT,
         STD_VECTOR_MAT    =  << KIND_SHIFT,
         EXPR              =  << KIND_SHIFT,
         OPENGL_BUFFER     =  << KIND_SHIFT,
         OPENGL_TEXTURE    =  << KIND_SHIFT,
         GPU_MAT           =  << KIND_SHIFT,
         OCL_MAT           = << KIND_SHIFT
     };
     _InputArray();

     _InputArray(const Mat& m);
     _InputArray(const MatExpr& expr);
     template<typename _Tp> _InputArray(const _Tp* vec, int n);
     template<typename _Tp> _InputArray(const vector<_Tp>& vec);
     template<typename _Tp> _InputArray(const vector<vector<_Tp> >& vec);
     _InputArray(const vector<Mat>& vec);
     template<typename _Tp> _InputArray(const vector<Mat_<_Tp> >& vec);
     template<typename _Tp> _InputArray(const Mat_<_Tp>& m);
     template<typename _Tp, int m, int n> _InputArray(const Matx<_Tp, m, n>& matx);
     _InputArray(const Scalar& s);
     _InputArray(const double& val);
     // < Deprecated
     _InputArray(const GlBuffer& buf);
     _InputArray(const GlTexture& tex);
     // >
     _InputArray(const gpu::GpuMat& d_mat);
     _InputArray(const ogl::Buffer& buf);
     _InputArray(const ogl::Texture2D& tex);

     virtual Mat getMat(int i=-) const;
     virtual void getMatVector(vector<Mat>& mv) const;
     // < Deprecated
     virtual GlBuffer getGlBuffer() const;
     virtual GlTexture getGlTexture() const;
     // >
     virtual gpu::GpuMat getGpuMat() const;
     /*virtual*/ ogl::Buffer getOGlBuffer() const;
     /*virtual*/ ogl::Texture2D getOGlTexture2D() const;

     virtual int kind() const;
     virtual Size size(int i=-) const;
     virtual size_t total(int i=-) const;
     virtual int type(int i=-) const;
     virtual int depth(int i=-) const;
     virtual int channels(int i=-) const;
     virtual bool empty() const;

 #ifdef OPENCV_CAN_BREAK_BINARY_COMPATIBILITY
     virtual ~_InputArray();
 #endif

     int flags;
     void* obj;
     Size sz;
 };

 /*!
  Proxy datatype for passing Mat's and vector<>'s as input parameters
  */
 class CV_EXPORTS _OutputArray : public _InputArray
 {
 public:
     _OutputArray();

     _OutputArray(Mat& m);
     template<typename _Tp> _OutputArray(vector<_Tp>& vec);
     template<typename _Tp> _OutputArray(vector<vector<_Tp> >& vec);
     _OutputArray(vector<Mat>& vec);
     template<typename _Tp> _OutputArray(vector<Mat_<_Tp> >& vec);
     template<typename _Tp> _OutputArray(Mat_<_Tp>& m);
     template<typename _Tp, int m, int n> _OutputArray(Matx<_Tp, m, n>& matx);
     template<typename _Tp> _OutputArray(_Tp* vec, int n);
     _OutputArray(gpu::GpuMat& d_mat);
     _OutputArray(ogl::Buffer& buf);
     _OutputArray(ogl::Texture2D& tex);

     _OutputArray(const Mat& m);
     template<typename _Tp> _OutputArray(const vector<_Tp>& vec);
     template<typename _Tp> _OutputArray(const vector<vector<_Tp> >& vec);
     _OutputArray(const vector<Mat>& vec);
     template<typename _Tp> _OutputArray(const vector<Mat_<_Tp> >& vec);
     template<typename _Tp> _OutputArray(const Mat_<_Tp>& m);
     template<typename _Tp, int m, int n> _OutputArray(const Matx<_Tp, m, n>& matx);
     template<typename _Tp> _OutputArray(const _Tp* vec, int n);
     _OutputArray(const gpu::GpuMat& d_mat);
     _OutputArray(const ogl::Buffer& buf);
     _OutputArray(const ogl::Texture2D& tex);

     virtual bool fixedSize() const;
     virtual bool fixedType() const;
     virtual bool needed() const;
     virtual Mat& getMatRef(int i=-) const;
     /*virtual*/ gpu::GpuMat& getGpuMatRef() const;
     /*virtual*/ ogl::Buffer& getOGlBufferRef() const;
     /*virtual*/ ogl::Texture2D& getOGlTexture2DRef() const;
     virtual void create(Size sz, int type, int i=-, bool allowTransposed=false, int fixedDepthMask=) const;
     virtual void create(int rows, int cols, int type, int i=-, bool allowTransposed=false, int fixedDepthMask=) const;
     virtual void create(int dims, const int* size, int type, int i=-, bool allowTransposed=false, int fixedDepthMask=) const;
     virtual void release() const;
     virtual void clear() const;

 #ifdef OPENCV_CAN_BREAK_BINARY_COMPATIBILITY
     virtual ~_OutputArray();
 #endif
 };