问题
主函数中第一次执行GaussianBlur()非常耗时，执行过一次之后就恢复正常。
原因分析
分析底层源码
GaussianBlur函数定义（位于sources\modules\imgproc\src\smooth.cpp）
void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize,
double sigma1, double sigma2,
int borderType ) createGaussianKernels(kx, ky, type, ksize, sigma1, sigma2);
sepFilter2D(_src, _dst, CV_MAT_DEPTH(type), kx, ky, Point(-1,-1), 0, borderType );
sepFilter2D函数定义（位于sources\modules\imgproc\src\filter.cpp）
void cv::sepFilter2D( InputArray _src, OutputArray _dst, int ddepth,
InputArray _kernelX, InputArray _kernelY, Point anchor,
double delta, int borderType ) Ptr<FilterEngine> f = createSeparableLinearFilter(src.type(),
dst.type(), kernelX, kernelY, anchor, delta, borderType & ~BORDER_ISOLATED );
f->apply(src, dst, Rect(0,0,-1,-1), Point(), (borderType & BORDER_ISOLATED) != 0 );这是官方论坛对3.0取消FilterEngine的提问，但并没有提供解决办法：
http://answers.opencv.org/question/56498/opencv-30-beta-no-filterengine-class/
http://answers.opencv.org/question/69111/opencv-30-filters-missing/
为了继续深入，这里将FilterEngine添加进我的代码，具体方法见本文最后的“附：opencv 3.0添加FilterEngine类”
继续追查FilterEngine的来源
createSeparableLinearFilter函数的定义：
cv::Ptr<cv::FilterEngine> cv::createSeparableLinearFilter(
int _srcType, int _dstType,
InputArray __rowKernel, InputArray __columnKernel,
Point _anchor, double _delta,
int _rowBorderType, int _columnBorderType,
const Scalar& _borderValue ) Ptr<BaseRowFilter> _rowFilter = getLinearRowFilter(
_srcType, _bufType, rowKernel, _anchor.x, rtype);
Ptr<BaseColumnFilter> _columnFilter = getLinearColumnFilter(
_bufType, _dstType, columnKernel, _anchor.y, ctype, _delta, bits );
return Ptr<FilterEngine>( new FilterEngine(Ptr<BaseFilter>(), _rowFilter, _columnFilter,
_srcType, _dstType, _bufType, _rowBorderType, _columnBorderType, _borderValue ));可见，这里终于真正意义上创建了滤波引擎，通过new一个Ptr<FilterEngine>对象
FilterEngine类（声明位于sources\modules\imgproc\src\filterengine.hpp，实现位于opencv\sources\modules\imgproc\src\filter.cpp）
class FilterEngine
{
public:
//! the default constructor
FilterEngine();
//! the full constructor. Either _filter2D or both _rowFilter and _columnFilter must be non-empty.
FilterEngine(const Ptr<BaseFilter>& _filter2D,
const Ptr<BaseRowFilter>& _rowFilter,
const Ptr<BaseColumnFilter>& _columnFilter,
int srcType, int dstType, int bufType,
int _rowBorderType = BORDER_REPLICATE,
int _columnBorderType = -1,
const Scalar& _borderValue = Scalar());
//! the destructor
virtual ~FilterEngine();
//! reinitializes the engine. The previously assigned filters are released.
void init(const Ptr<BaseFilter>& _filter2D,
const Ptr<BaseRowFilter>& _rowFilter,
const Ptr<BaseColumnFilter>& _columnFilter,
int srcType, int dstType, int bufType,
int _rowBorderType = BORDER_REPLICATE,
int _columnBorderType = -1,
const Scalar& _borderValue = Scalar());
//! starts filtering of the specified ROI of an image of size wholeSize.
virtual int start(Size wholeSize, Rect roi, int maxBufRows = -1);
//! starts filtering of the specified ROI of the specified image.
virtual int start(const Mat& src, const Rect& srcRoi = Rect(0,0,-1,-1),
bool isolated = false, int maxBufRows = -1);
//! processes the next srcCount rows of the image.
virtual int proceed(const uchar* src, int srcStep, int srcCount,
uchar* dst, int dstStep);
//! applies filter to the specified ROI of the image. if srcRoi=(0,0,-1,-1), the whole image is filtered.
virtual void apply( const Mat& src, Mat& dst,
const Rect& srcRoi = Rect(0,0,-1,-1),
Point dstOfs = Point(0,0),
bool isolated = false);
//! returns true if the filter is separable
bool isSeparable() const { return !filter2D; }
//! returns the number
int remainingInputRows() const;
int remainingOutputRows() const;
int srcType;
int dstType;
int bufType;
Size ksize;
Point anchor;
int maxWidth;
Size wholeSize;
Rect roi;
int dx1;
int dx2;
int rowBorderType;
int columnBorderType;
std::vector<int> borderTab;
int borderElemSize;
std::vector<uchar> ringBuf;
std::vector<uchar> srcRow;
std::vector<uchar> constBorderValue;
std::vector<uchar> constBorderRow;
int bufStep;
int startY;
int startY0;
int endY;
int rowCount;
int dstY;
std::vector<uchar*> rows;
Ptr<BaseFilter> filter2D;
Ptr<BaseRowFilter> rowFilter;
Ptr<BaseColumnFilter> columnFilter;
};
推测可能原因：创建FilterEngine耗费时间
实验：
方式一：
//变量定义
Mat &src = input(); //输入源数据
Mat &dst; //输出数据
Mat kx, ky; //x和y方向的滤波核
//方式一：sepFilter2D
kx = cv::getGaussianKernel(5,1.0,6);ky = kx;
sepFilter2D(src, dst, CV_MAT_DEPTH(CV_32F), kx, ky, cv::Point(-1,-1), 0, cv::BORDER_REFLECT);
方式二：
//方式二：GaussianBlur
cv::GaussianBlur(src, dst, Size(5, 5), 1.0, 1.0, cv::BORDER_REFLECT); //方式三：调用FilterEngine类
cv::Ptr<cv::FilterEngine> gauss = cv::createGaussianFilter(CV_32F,Size(5,5),1.0,1.0,cv::BORDER_REFLECT);
gauss->apply(src,dst,cv::Rect(0,0,-1,-1),cv::Point(0,0),false);结果：
三种方式的耗时都相近，因为GaussianBlur的底层实现就是sepFilter2D，而sepFilter2D的底层实现则是FilterEngine中的apply方法（见源码分析中的代码）
对于CV_32F的数据处理速度最快，CV_64F次之，最慢是处理CV_16U的数据，所以不要直接对整型数据进行滤波。
每次执行sepFilter2D，都会重新定义一个Ptr<FilterEngine> f，故不存在创建耗费时间的问题，否则就不仅仅是第一次运行GaussianBlur耗时了。
三种方式都存在一个问题， 就是在第一次调用时非常耗时（平时的几十倍）往后恢复正常。所以GaussianBlur第一次调用耗时的问题，其原因并非FilterEngine创建耗时
但如果不是这个原因，就显得无法解释了，到底问题的根源在哪里？
参考其它讨论GaussianBlur的博文：
http://blog.csdn.net/hachirou/article/details/6280200
总结：解决第一次执行GaussianBlur()非常耗时的问题，只能通过在程序开始时执行一遍（经过测试，首次运行GaussianBlur可以是任意大小的输入数据和滤波核，也就是不必跟后面的一致），FilterEngine和sepFilter2D同理。而且，调用函数前先初始化输入变量Mat的值，将加快运行速度。如：
Mat t0 = Mat::zeros(Size(1000,1000),CV_32F);
Mat t1 = Mat::zeros(Size(1000,1000),CV_32F);
Mat kx = cv::getGaussianKernel(5,1.0,6);Mat ky = kx;
cv::sepFilter2D(t0,t1, CV_MAT_DEPTH(CV_32F), kx, ky, cv::Point(-1,-1), 0, cv::BORDER_REFLECT); Mat t0 = Mat(Size(1000,1000),CV_32F);
Mat t1 = Mat(Size(1000,1000),CV_32F);
Mat kx = cv::getGaussianKernel(5,1.0,6);Mat ky = kx;
cv::sepFilter2D(t0,t1, CV_MAT_DEPTH(CV_32F), kx, ky, cv::Point(-1,-1), 0, cv::BORDER_REFLECT);
进一步发现，首次调用涉及运算的opencv函数，其耗时都非常长，也就是说，不仅是滤波函数，连cv::multiply之类的函数也存在该问题。然而，Mat::convertTo、Mat::zeros等矩阵赋值操作则不存在该问题。
最后发现，只有opencv 3.0才存在该问题，2.4.9没有该问题！
推测：opencv3.0第一次执行这些函数（multiply、GaussianBlur等）时进行了一些初始化操作，导致第一次调用某些函数非常耗时，但具体进行了哪些操作无法得知，官方文档也没有就此问题进行解释
解决该问题的办法：程序开始时调用一次multiply函数。
经过测试，执行1000次multiply和GaussianBlur，处理Mat(Size(1000,1000),CV_32F)的数据，opencv3.0并没有什么优势，然而其官方声称IPP大幅提高了其性能，intel这……
附：opencv 3.0添加（重新开放）FilterEngine类
首先说明，为什么要往opencv 3.0中重新开放FilterEngine类？
就运行效率而言，其实上层封装好的各类滤波函数，如GaussianBlur，均是基于FilterEngine类的，所以无论是使用FilterEngine还是使用上层函数，其效率没有差别。因此官方才会封闭该类。
添加FilterEngine类，主要为了兼容旧代码，因为opencv 2.x有的代码中习惯使用FilterEngine的方式。
以下是具体方法：
1、编译opencv源码，必须自行编译一次，因为有一个用到的文件要编译后才能生成（假设编译opencv的project所在目录为D:\opencv\build_pure）
2、新建一个自己的应用程序的project，向其中添加以下文件并作相应修改（假设opencv源码解压目录为D:\opencv），往“文件所在目录”中找到相应的文件并复制到自己的project文件夹，然后再修改
（1）precomp.hpp
文件所在目录：D:\opencv\sources\modules\imgproc\src\precomp.hpp
共1项修改：
△ 删除语句，因为编译时会产生较多冲突
#include "opencv2/core/private.hpp" （2）opencl_kernels_imgproc.hpp和opencl_kernels_imgproc.cpp
文件所在目录：D:\opencv\build_pure\modules\imgproc\，注：这两个文件需要编译opencv源码之后才会生成
共1项修改：
△在D:\opencv\build_pure\install\include\opencv2\core下新建文件夹“opencl”，把位于D:\opencv\sources\modules\core\include\opencv2\core\opencl的ocl_defs.hpp拷贝至D:\opencv\build_pure\install\include\opencv2\core\opencl
（3）filterengine.hpp
文件所在目录：D:\opencv\sources\modules\imgproc\src\filterengine.hpp
共3项修改：
（说明：smooth.cpp位于D:\opencv\sources\modules\imgproc\src\smooth.cpp；templmatch.cpp位于D:\opencv\sources\modules\imgproc\src\templmatch.cpp）
△在smooth.cpp中找到createGaussianKernels函数，在filterengine.hpp中声明该函数，注意要在namespace cv中声明
void createGaussianKernels( Mat & kx, Mat & ky, int type, Size ksize,
double sigma1, double sigma2 );△在smooth.cpp中找到createGaussianFilter函数，在filterengine.hpp中声明该函数
Ptr<cv::FilterEngine> createGaussianFilter( int type, Size ksize,
double sigma1, double sigma2,
int borderType );△在templmatch.cpp中找到crossCorr函数，在filterengine.hpp中声明该函数
void crossCorr( const Mat& src, const Mat& templ, Mat& dst,
Size corrsize, int ctype,
Point anchor=Point(0,0), double delta=0,
int borderType=BORDER_REFLECT_101 );注：以上仅仅包括了高斯滤波相关的函数，如果是其它滤波算法，则自行在opencv源码目录中查找该滤波算法所需的模块（可以通过debug单步跟踪了解某个函数涉及的底层代码）；再次声明，这些函数均是filterengine中用到的底层代码，opencv3.0没有暴露给用户，所以需要手动添加，如果查找过程中发现某个函数是开放给用户的，即前面带有CV_EXPORTS关键字的则无需手动添加
（4）filter.cpp
文件所在目录：D:\opencv\sources\modules\imgproc\src\filter.cpp
共4项修改：
（说明：private.hpp位于D:\opencv\sources\modules\core\include\opencv2\core\private.hpp）
△承接（3），把在smooth.cpp中找到的createGaussianKernels函数，其实现拷贝至filter.cpp中
void cv::createGaussianKernels( Mat & kx, Mat & ky, int type, Size ksize,
double sigma1, double sigma2 )
{
...
}△承接（3），把在smooth.cpp中找到的createGaussianFilter函数，其实现拷贝至filter.cpp中
cv::Ptr<cv::FilterEngine> cv::createGaussianFilter( int type, Size ksize,
double sigma1, double sigma2,
int borderType )
{
...
}△承接（3），把在templmatch.cpp中找到的crossCorr函数，其实现拷贝至filter.cpp中
void crossCorr( const Mat& img, const Mat& _templ, Mat& corr,
Size corrsize, int ctype,
Point anchor, double delta, int borderType )
{
...
}void scalarToRawData(const Scalar& s, void* _buf, int type, int unroll_to)
{
...
}3、在程序中引用头文件即可使用FilterEngine类
#include "filterengine.hpp"这是改好之后的5个文件，添加进去项目就可以使用FilterEngine类，基于VS2012：http://download.csdn.net/detail/kelvin_yan/9203965
----------------------END----------------------------
245
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
