diff --git a/modules/gpu/perf/perf_filters.cpp b/modules/gpu/perf/perf_filters.cpp
index 9322557283..4975033239 100644
--- a/modules/gpu/perf/perf_filters.cpp
+++ b/modules/gpu/perf/perf_filters.cpp
@@ -2,18 +2,20 @@
 
 #ifdef HAVE_CUDA
 
+IMPLEMENT_PARAM_CLASS(KernelSize, int)
+
 //////////////////////////////////////////////////////////////////////
-// BoxFilter
+// Blur
 
-GPU_PERF_TEST(BoxFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, int)
+GPU_PERF_TEST(Blur, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)
 {
     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
+
     cv::Size size = GET_PARAM(1);
     int type = GET_PARAM(2);
     int ksize = GET_PARAM(3);
 
-    cv::gpu::setDevice(devInfo.deviceID());
-
     cv::Mat src_host(size, type);
 
     declare.in(src_host, WARMUP_RNG);
@@ -21,67 +23,124 @@ GPU_PERF_TEST(BoxFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, int)
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
 
-    cv::Ptr<cv::gpu::FilterEngine_GPU> filter = cv::gpu::createBoxFilter_GPU(type, type, cv::Size(ksize, ksize));
-
     TEST_CYCLE()
     {
-        filter->apply(src, dst);
+        cv::gpu::blur(src, dst, cv::Size(ksize, ksize));
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Filter, BoxFilter, testing::Combine(
-                        ALL_DEVICES, 
-                        GPU_TYPICAL_MAT_SIZES, 
-                        testing::Values(CV_8UC1, CV_8UC4),
-                        testing::Values(3, 5)));
+INSTANTIATE_TEST_CASE_P(Filter, Blur, testing::Combine(
+    ALL_DEVICES,
+    GPU_TYPICAL_MAT_SIZES,
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),
+    testing::Values(KernelSize(3), KernelSize(5), KernelSize(7))));
 
 //////////////////////////////////////////////////////////////////////
-// MorphologyFilter
+// Sobel
 
-GPU_PERF_TEST(MorphologyFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, MorphOp, int)
+GPU_PERF_TEST(Sobel, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)
 {
     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
+
     cv::Size size = GET_PARAM(1);
     int type = GET_PARAM(2);
-    int op = GET_PARAM(3);
-    int ksize = GET_PARAM(4);
+    int ksize = GET_PARAM(3);
+
+    cv::Mat src_host(size, type);
+
+    declare.in(src_host, WARMUP_RNG);
+
+    cv::gpu::GpuMat src(src_host);
+    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat buf;
+
+    TEST_CYCLE()
+    {
+        cv::gpu::Sobel(src, dst, -1, 1, 1, buf, ksize);
+    }
+}
 
+INSTANTIATE_TEST_CASE_P(Filter, Sobel, testing::Combine(
+    ALL_DEVICES,
+    GPU_TYPICAL_MAT_SIZES,
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1)),
+    testing::Values(KernelSize(3), KernelSize(5), KernelSize(7), KernelSize(9), KernelSize(11), KernelSize(13), KernelSize(15))));
+
+//////////////////////////////////////////////////////////////////////
+// Scharr
+
+GPU_PERF_TEST(Scharr, cv::gpu::DeviceInfo, cv::Size, MatType)
+{
+    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::gpu::setDevice(devInfo.deviceID());
 
+    cv::Size size = GET_PARAM(1);
+    int type = GET_PARAM(2);
+
     cv::Mat src_host(size, type);
 
     declare.in(src_host, WARMUP_RNG);
 
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
-
-    cv::Ptr<cv::gpu::FilterEngine_GPU> filter = cv::gpu::createMorphologyFilter_GPU(op, type, cv::Mat::ones(ksize, ksize, CV_8U));
+    cv::gpu::GpuMat buf;
 
     TEST_CYCLE()
     {
-        filter->apply(src, dst);
+        cv::gpu::Scharr(src, dst, -1, 1, 0, buf);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Filter, MorphologyFilter, testing::Combine(
-                        ALL_DEVICES, 
-                        GPU_TYPICAL_MAT_SIZES, 
-                        testing::Values(CV_8UC1, CV_8UC4),
-                        testing::Values((int) cv::MORPH_ERODE, (int) cv::MORPH_DILATE),
-                        testing::Values(3, 5)));
+INSTANTIATE_TEST_CASE_P(Filter, Scharr, testing::Combine(
+    ALL_DEVICES,
+    GPU_TYPICAL_MAT_SIZES,
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1))));
 
 //////////////////////////////////////////////////////////////////////
-// LinearFilter
+// GaussianBlur
 
-GPU_PERF_TEST(LinearFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, int)
+GPU_PERF_TEST(GaussianBlur, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)
 {
     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
+
     cv::Size size = GET_PARAM(1);
     int type = GET_PARAM(2);
     int ksize = GET_PARAM(3);
 
+    cv::Mat src_host(size, type);
+
+    declare.in(src_host, WARMUP_RNG);
+
+    cv::gpu::GpuMat src(src_host);
+    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat buf;
+
+    TEST_CYCLE()
+    {
+        cv::gpu::GaussianBlur(src, dst, cv::Size(ksize, ksize), buf, 0.5);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(Filter, GaussianBlur, testing::Combine(
+    ALL_DEVICES,
+    GPU_TYPICAL_MAT_SIZES,
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1)),
+    testing::Values(KernelSize(3), KernelSize(5), KernelSize(7), KernelSize(9), KernelSize(11), KernelSize(13), KernelSize(15))));
+
+//////////////////////////////////////////////////////////////////////
+// Laplacian
+
+GPU_PERF_TEST(Laplacian, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)
+{
+    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::gpu::setDevice(devInfo.deviceID());
 
+    cv::Size size = GET_PARAM(1);
+    int type = GET_PARAM(2);
+    int ksize = GET_PARAM(3);
+
     cv::Mat src_host(size, type);
 
     declare.in(src_host, WARMUP_RNG);
@@ -89,56 +148,150 @@ GPU_PERF_TEST(LinearFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, int)
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
 
-    cv::Ptr<cv::gpu::FilterEngine_GPU> filter = cv::gpu::createLinearFilter_GPU(type, type, cv::Mat::ones(ksize, ksize, CV_8U));
+    TEST_CYCLE()
+    {
+        cv::gpu::Laplacian(src, dst, -1, ksize);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(Filter, Laplacian, testing::Combine(
+    ALL_DEVICES,
+    GPU_TYPICAL_MAT_SIZES,
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC4)),
+    testing::Values(KernelSize(1), KernelSize(3))));
+
+//////////////////////////////////////////////////////////////////////
+// Erode
+
+GPU_PERF_TEST(Erode, cv::gpu::DeviceInfo, cv::Size, MatType)
+{
+    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
+
+    cv::Size size = GET_PARAM(1);
+    int type = GET_PARAM(2);
 
-    declare.time(1.0);
+    cv::Mat src_host(size, type);
+
+    declare.in(src_host, WARMUP_RNG);
+
+    cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
+
+    cv::gpu::GpuMat src(src_host);
+    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat buf;
 
     TEST_CYCLE()
     {
-        filter->apply(src, dst);
+        cv::gpu::erode(src, dst, ker, buf);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Filter, LinearFilter, testing::Combine(
-                        ALL_DEVICES, 
-                        GPU_TYPICAL_MAT_SIZES, 
-                        testing::Values(CV_8UC1, CV_8UC4, CV_32FC1),
-                        testing::Values(3, 5, 7, 9)));
+INSTANTIATE_TEST_CASE_P(Filter, Erode, testing::Combine(
+    ALL_DEVICES,
+    GPU_TYPICAL_MAT_SIZES,
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4))));
 
 //////////////////////////////////////////////////////////////////////
-// SeparableLinearFilter
+// Dilate
 
-GPU_PERF_TEST(SeparableLinearFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, int)
+GPU_PERF_TEST(Dilate, cv::gpu::DeviceInfo, cv::Size, MatType)
 {
     cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
+
     cv::Size size = GET_PARAM(1);
     int type = GET_PARAM(2);
-    int ksize = GET_PARAM(3);
 
+    cv::Mat src_host(size, type);
+
+    declare.in(src_host, WARMUP_RNG);
+
+    cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
+
+    cv::gpu::GpuMat src(src_host);
+    cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat buf;
+
+    TEST_CYCLE()
+    {
+        cv::gpu::dilate(src, dst, ker, buf);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(Filter, Dilate, testing::Combine(
+    ALL_DEVICES,
+    GPU_TYPICAL_MAT_SIZES,
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4))));
+
+//////////////////////////////////////////////////////////////////////
+// MorphologyEx
+
+CV_ENUM(MorphOp, cv::MORPH_OPEN, cv::MORPH_CLOSE, cv::MORPH_GRADIENT, cv::MORPH_TOPHAT, cv::MORPH_BLACKHAT)
+#define ALL_MORPH_OPS testing::Values(MorphOp(cv::MORPH_OPEN), MorphOp(cv::MORPH_CLOSE), MorphOp(cv::MORPH_GRADIENT), MorphOp(cv::MORPH_TOPHAT), MorphOp(cv::MORPH_BLACKHAT))
+
+GPU_PERF_TEST(MorphologyEx, cv::gpu::DeviceInfo, cv::Size, MatType, MorphOp)
+{
+    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::gpu::setDevice(devInfo.deviceID());
 
+    cv::Size size = GET_PARAM(1);
+    int type = GET_PARAM(2);
+    int morphOp = GET_PARAM(3);
+
     cv::Mat src_host(size, type);
 
     declare.in(src_host, WARMUP_RNG);
 
+    cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
+
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
+    cv::gpu::GpuMat buf1;
+    cv::gpu::GpuMat buf2;
+
+    TEST_CYCLE()
+    {
+        cv::gpu::morphologyEx(src, dst, morphOp, ker, buf1, buf2);
+    }
+}
 
-    cv::Mat kernel = cv::getGaussianKernel(ksize, 0.5, CV_32F);
-    cv::Ptr<cv::gpu::FilterEngine_GPU> filter = cv::gpu::createSeparableLinearFilter_GPU(type, type, kernel, kernel);
+INSTANTIATE_TEST_CASE_P(Filter, MorphologyEx, testing::Combine(
+    ALL_DEVICES,
+    GPU_TYPICAL_MAT_SIZES,
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),
+    ALL_MORPH_OPS));
 
-    declare.time(1.0);
+//////////////////////////////////////////////////////////////////////
+// Filter2D
+
+GPU_PERF_TEST(Filter2D, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)
+{
+    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
+
+    cv::Size size = GET_PARAM(1);
+    int type = GET_PARAM(2);
+    int ksize = GET_PARAM(3);
+
+    cv::Mat src_host(size, type);
+    cv::Mat kernel(ksize, ksize, CV_32FC1);
+
+    declare.in(src_host, kernel, WARMUP_RNG);
+
+    cv::gpu::GpuMat src(src_host);
+    cv::gpu::GpuMat dst;
 
     TEST_CYCLE()
     {
-        filter->apply(src, dst, cv::Rect(0, 0, src.cols, src.rows));
+        cv::gpu::filter2D(src, dst, -1, kernel);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Filter, SeparableLinearFilter, testing::Combine(
-                        ALL_DEVICES, 
-                        GPU_TYPICAL_MAT_SIZES, 
-                        testing::Values(CV_8UC1, CV_8UC4, CV_32FC1),
-                        testing::Values(3, 5, 7, 9, 11, 13, 15)));
+INSTANTIATE_TEST_CASE_P(Filter, Filter2D, testing::Combine(
+    ALL_DEVICES,
+    GPU_TYPICAL_MAT_SIZES,
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC4)),
+    testing::Values(KernelSize(3), KernelSize(5), KernelSize(7), KernelSize(9), KernelSize(11), KernelSize(13), KernelSize(15))));
 
 #endif
diff --git a/modules/gpu/perf/perf_utility.hpp b/modules/gpu/perf/perf_utility.hpp
index f15610b983..f6336c8e20 100644
--- a/modules/gpu/perf/perf_utility.hpp
+++ b/modules/gpu/perf/perf_utility.hpp
@@ -5,7 +5,9 @@ void fill(cv::Mat& m, double a, double b);
 
 enum {HORIZONTAL_AXIS = 0, VERTICAL_AXIS = 1, BOTH_AXIS = -1};
 
-CV_ENUM(MorphOp, cv::MORPH_ERODE, cv::MORPH_DILATE)
+using perf::MatType;
+using perf::MatDepth;
+
 CV_ENUM(BorderMode, cv::BORDER_REFLECT101, cv::BORDER_REPLICATE, cv::BORDER_CONSTANT, cv::BORDER_REFLECT, cv::BORDER_WRAP)
 CV_ENUM(FlipCode, HORIZONTAL_AXIS, VERTICAL_AXIS, BOTH_AXIS)
 CV_ENUM(Interpolation, cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_CUBIC)
@@ -13,6 +15,20 @@ CV_ENUM(MatchMethod, cv::TM_SQDIFF, cv::TM_SQDIFF_NORMED, cv::TM_CCORR, cv::TM_C
 CV_ENUM(NormType, cv::NORM_INF, cv::NORM_L1, cv::NORM_L2)
 CV_ENUM(AlphaOp, cv::gpu::ALPHA_OVER, cv::gpu::ALPHA_IN, cv::gpu::ALPHA_OUT, cv::gpu::ALPHA_ATOP, cv::gpu::ALPHA_XOR, cv::gpu::ALPHA_PLUS, cv::gpu::ALPHA_OVER_PREMUL, cv::gpu::ALPHA_IN_PREMUL, cv::gpu::ALPHA_OUT_PREMUL, cv::gpu::ALPHA_ATOP_PREMUL, cv::gpu::ALPHA_XOR_PREMUL, cv::gpu::ALPHA_PLUS_PREMUL, cv::gpu::ALPHA_PREMUL)
 
+#define IMPLEMENT_PARAM_CLASS(name, type) \
+    class name \
+    { \
+    public: \
+        name ( type arg = type ()) : val_(arg) {} \
+        operator type () const {return val_;} \
+    private: \
+        type val_; \
+    }; \
+    inline void PrintTo( name param, std::ostream* os) \
+    { \
+        *os << #name <<  "(" << testing::PrintToString(static_cast< type >(param)) << ")"; \
+    }
+
 struct CvtColorInfo
 {
     int scn;
diff --git a/modules/gpu/perf_cpu/perf_filters.cpp b/modules/gpu/perf_cpu/perf_filters.cpp
index 08c441a045..d2c19c3fcf 100644
--- a/modules/gpu/perf_cpu/perf_filters.cpp
+++ b/modules/gpu/perf_cpu/perf_filters.cpp
@@ -2,10 +2,12 @@
 
 #ifdef HAVE_CUDA
 
+IMPLEMENT_PARAM_CLASS(KernelSize, int)
+
 //////////////////////////////////////////////////////////////////////
-// BoxFilter
+// Blur
 
-GPU_PERF_TEST(BoxFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, int)
+GPU_PERF_TEST(Blur, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)
 {
     cv::Size size = GET_PARAM(1);
     int type = GET_PARAM(2);
@@ -15,88 +17,111 @@ GPU_PERF_TEST(BoxFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, int)
 
     declare.in(src, WARMUP_RNG);
 
-    cv::Mat dst(src.size(), src.type());
+    cv::Mat dst;
 
-    cv::Ptr<cv::FilterEngine> filter = cv::createBoxFilter(type, type, cv::Size(ksize, ksize));
+    declare.time(20.0);
 
     TEST_CYCLE()
     {
-        filter->apply(src, dst);
+        cv::blur(src, dst, cv::Size(ksize, ksize));
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Filter, BoxFilter, testing::Combine(
-                        ALL_DEVICES,
-                        GPU_TYPICAL_MAT_SIZES,
-                        testing::Values(CV_8UC1, CV_8UC4),
-                        testing::Values(3, 5)));
+INSTANTIATE_TEST_CASE_P(Filter, Blur, testing::Combine(
+    ALL_DEVICES,
+    GPU_TYPICAL_MAT_SIZES,
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),
+    testing::Values(KernelSize(3), KernelSize(5), KernelSize(7))));
 
 //////////////////////////////////////////////////////////////////////
-// MorphologyFilter
+// Sobel
 
-GPU_PERF_TEST(MorphologyFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, MorphOp, int)
+GPU_PERF_TEST(Sobel, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)
 {
     cv::Size size = GET_PARAM(1);
     int type = GET_PARAM(2);
-    int op = GET_PARAM(3);
-    int ksize = GET_PARAM(4);
+    int ksize = GET_PARAM(3);
 
     cv::Mat src(size, type);
 
     declare.in(src, WARMUP_RNG);
 
-    cv::Mat dst(src.size(), src.type());
+    cv::Mat dst;
 
-    cv::Ptr<cv::FilterEngine> filter = cv::createMorphologyFilter(op, type, cv::Mat::ones(ksize, ksize, CV_8U));
+    declare.time(20.0);
 
     TEST_CYCLE()
     {
-        filter->apply(src, dst);
+        cv::Sobel(src, dst, -1, 1, 1, ksize);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Filter, MorphologyFilter, testing::Combine(
-                        ALL_DEVICES,
-                        GPU_TYPICAL_MAT_SIZES,
-                        testing::Values(CV_8UC1, CV_8UC4),
-                        testing::Values((int) cv::MORPH_ERODE, (int) cv::MORPH_DILATE),
-                        testing::Values(3, 5)));
+INSTANTIATE_TEST_CASE_P(Filter, Sobel, testing::Combine(
+    ALL_DEVICES,
+    GPU_TYPICAL_MAT_SIZES,
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1)),
+    testing::Values(KernelSize(3), KernelSize(5), KernelSize(7), KernelSize(9), KernelSize(11), KernelSize(13), KernelSize(15))));
 
 //////////////////////////////////////////////////////////////////////
-// LinearFilter
+// Scharr
 
-GPU_PERF_TEST(LinearFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, int)
+GPU_PERF_TEST(Scharr, cv::gpu::DeviceInfo, cv::Size, MatType)
 {
     cv::Size size = GET_PARAM(1);
     int type = GET_PARAM(2);
-    int ksize = GET_PARAM(3);
 
     cv::Mat src(size, type);
 
     declare.in(src, WARMUP_RNG);
 
-    cv::Mat dst(src.size(), src.type());
+    cv::Mat dst;
+
+    declare.time(20.0);
+
+    TEST_CYCLE()
+    {
+        cv::Scharr(src, dst, -1, 1, 0);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(Filter, Scharr, testing::Combine(
+    ALL_DEVICES,
+    GPU_TYPICAL_MAT_SIZES,
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1))));
+
+//////////////////////////////////////////////////////////////////////
+// GaussianBlur
+
+GPU_PERF_TEST(GaussianBlur, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)
+{
+    cv::Size size = GET_PARAM(1);
+    int type = GET_PARAM(2);
+    int ksize = GET_PARAM(3);
+
+    cv::Mat src(size, type);
+
+    declare.in(src, WARMUP_RNG);
 
-    cv::Ptr<cv::FilterEngine> filter = cv::createLinearFilter(type, type, cv::Mat::ones(ksize, ksize, CV_8U));
+    cv::Mat dst;
 
-    declare.time(10.0);
+    declare.time(20.0);
 
     TEST_CYCLE()
     {
-        filter->apply(src, dst);
+        cv::GaussianBlur(src, dst, cv::Size(ksize, ksize), 0.5);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Filter, LinearFilter, testing::Combine(
-                        ALL_DEVICES,
-                        GPU_TYPICAL_MAT_SIZES,
-                        testing::Values(CV_8UC1, CV_8UC4, CV_32FC1),
-                        testing::Values(3, 5, 7, 9)));
+INSTANTIATE_TEST_CASE_P(Filter, GaussianBlur, testing::Combine(
+    ALL_DEVICES,
+    GPU_TYPICAL_MAT_SIZES,
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1)),
+    testing::Values(KernelSize(3), KernelSize(5), KernelSize(7), KernelSize(9), KernelSize(11), KernelSize(13), KernelSize(15))));
 
 //////////////////////////////////////////////////////////////////////
-// SeparableLinearFilter
+// Laplacian
 
-GPU_PERF_TEST(SeparableLinearFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, int)
+GPU_PERF_TEST(Laplacian, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)
 {
     cv::Size size = GET_PARAM(1);
     int type = GET_PARAM(2);
@@ -106,23 +131,142 @@ GPU_PERF_TEST(SeparableLinearFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatTyp
 
     declare.in(src, WARMUP_RNG);
 
-    cv::Mat dst(src.size(), src.type());
+    cv::Mat dst;
+
+    declare.time(20.0);
+
+    TEST_CYCLE()
+    {
+        cv::Laplacian(src, dst, -1, ksize);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(Filter, Laplacian, testing::Combine(
+    ALL_DEVICES,
+    GPU_TYPICAL_MAT_SIZES,
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC4)),
+    testing::Values(KernelSize(1), KernelSize(3))));
+
+//////////////////////////////////////////////////////////////////////
+// Erode
+
+GPU_PERF_TEST(Erode, cv::gpu::DeviceInfo, cv::Size, MatType)
+{
+    cv::Size size = GET_PARAM(1);
+    int type = GET_PARAM(2);
+
+    cv::Mat src(size, type);
+
+    declare.in(src, WARMUP_RNG);
+
+    cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
+
+    cv::Mat dst;
+
+    declare.time(20.0);
+
+    TEST_CYCLE()
+    {
+        cv::erode(src, dst, ker);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(Filter, Erode, testing::Combine(
+    ALL_DEVICES,
+    GPU_TYPICAL_MAT_SIZES,
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4))));
+
+//////////////////////////////////////////////////////////////////////
+// Dilate
+
+GPU_PERF_TEST(Dilate, cv::gpu::DeviceInfo, cv::Size, MatType)
+{
+    cv::Size size = GET_PARAM(1);
+    int type = GET_PARAM(2);
+
+    cv::Mat src(size, type);
+
+    declare.in(src, WARMUP_RNG);
+
+    cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
+
+    cv::Mat dst;
+
+    declare.time(20.0);
+
+    TEST_CYCLE()
+    {
+        cv::dilate(src, dst, ker);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(Filter, Dilate, testing::Combine(
+    ALL_DEVICES,
+    GPU_TYPICAL_MAT_SIZES,
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4))));
+
+//////////////////////////////////////////////////////////////////////
+// MorphologyEx
+
+CV_ENUM(MorphOp, cv::MORPH_OPEN, cv::MORPH_CLOSE, cv::MORPH_GRADIENT, cv::MORPH_TOPHAT, cv::MORPH_BLACKHAT)
+#define ALL_MORPH_OPS testing::Values(MorphOp(cv::MORPH_OPEN), MorphOp(cv::MORPH_CLOSE), MorphOp(cv::MORPH_GRADIENT), MorphOp(cv::MORPH_TOPHAT), MorphOp(cv::MORPH_BLACKHAT))
+
+GPU_PERF_TEST(MorphologyEx, cv::gpu::DeviceInfo, cv::Size, MatType, MorphOp)
+{
+    cv::Size size = GET_PARAM(1);
+    int type = GET_PARAM(2);
+    int morphOp = GET_PARAM(3);
+
+    cv::Mat src(size, type);
+
+    declare.in(src, WARMUP_RNG);
+
+    cv::Mat dst;
+
+    cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
+
+    declare.time(20.0);
+
+    TEST_CYCLE()
+    {
+        cv::morphologyEx(src, dst, morphOp, ker);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(Filter, MorphologyEx, testing::Combine(
+    ALL_DEVICES,
+    GPU_TYPICAL_MAT_SIZES,
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),
+    ALL_MORPH_OPS));
+
+//////////////////////////////////////////////////////////////////////
+// Filter2D
+
+GPU_PERF_TEST(Filter2D, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)
+{
+    cv::Size size = GET_PARAM(1);
+    int type = GET_PARAM(2);
+    int ksize = GET_PARAM(3);
+
+    cv::Mat src(size, type);
+    cv::Mat kernel(ksize, ksize, CV_32FC1);
+
+    declare.in(src, kernel, WARMUP_RNG);
 
-    cv::Mat kernel = cv::getGaussianKernel(ksize, 0.5, CV_32F);
-    cv::Ptr<cv::FilterEngine> filter = cv::createSeparableLinearFilter(type, type, kernel, kernel);
+    cv::Mat dst;
 
-    declare.time(10.0);
+    declare.time(20.0);
 
     TEST_CYCLE()
     {
-        filter->apply(src, dst);
+        cv::filter2D(src, dst, -1, kernel);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Filter, SeparableLinearFilter, testing::Combine(
-                        ALL_DEVICES,
-                        GPU_TYPICAL_MAT_SIZES,
-                        testing::Values(CV_8UC1, CV_8UC4, CV_32FC1),
-                        testing::Values(3, 5, 7, 9, 11, 13, 15)));
+INSTANTIATE_TEST_CASE_P(Filter, Filter2D, testing::Combine(
+    ALL_DEVICES,
+    GPU_TYPICAL_MAT_SIZES,
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC4)),
+    testing::Values(KernelSize(3), KernelSize(5), KernelSize(7), KernelSize(9), KernelSize(11), KernelSize(13), KernelSize(15))));
 
 #endif
diff --git a/modules/gpu/perf_cpu/perf_utility.hpp b/modules/gpu/perf_cpu/perf_utility.hpp
index f15610b983..f6336c8e20 100644
--- a/modules/gpu/perf_cpu/perf_utility.hpp
+++ b/modules/gpu/perf_cpu/perf_utility.hpp
@@ -5,7 +5,9 @@ void fill(cv::Mat& m, double a, double b);
 
 enum {HORIZONTAL_AXIS = 0, VERTICAL_AXIS = 1, BOTH_AXIS = -1};
 
-CV_ENUM(MorphOp, cv::MORPH_ERODE, cv::MORPH_DILATE)
+using perf::MatType;
+using perf::MatDepth;
+
 CV_ENUM(BorderMode, cv::BORDER_REFLECT101, cv::BORDER_REPLICATE, cv::BORDER_CONSTANT, cv::BORDER_REFLECT, cv::BORDER_WRAP)
 CV_ENUM(FlipCode, HORIZONTAL_AXIS, VERTICAL_AXIS, BOTH_AXIS)
 CV_ENUM(Interpolation, cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_CUBIC)
@@ -13,6 +15,20 @@ CV_ENUM(MatchMethod, cv::TM_SQDIFF, cv::TM_SQDIFF_NORMED, cv::TM_CCORR, cv::TM_C
 CV_ENUM(NormType, cv::NORM_INF, cv::NORM_L1, cv::NORM_L2)
 CV_ENUM(AlphaOp, cv::gpu::ALPHA_OVER, cv::gpu::ALPHA_IN, cv::gpu::ALPHA_OUT, cv::gpu::ALPHA_ATOP, cv::gpu::ALPHA_XOR, cv::gpu::ALPHA_PLUS, cv::gpu::ALPHA_OVER_PREMUL, cv::gpu::ALPHA_IN_PREMUL, cv::gpu::ALPHA_OUT_PREMUL, cv::gpu::ALPHA_ATOP_PREMUL, cv::gpu::ALPHA_XOR_PREMUL, cv::gpu::ALPHA_PLUS_PREMUL, cv::gpu::ALPHA_PREMUL)
 
+#define IMPLEMENT_PARAM_CLASS(name, type) \
+    class name \
+    { \
+    public: \
+        name ( type arg = type ()) : val_(arg) {} \
+        operator type () const {return val_;} \
+    private: \
+        type val_; \
+    }; \
+    inline void PrintTo( name param, std::ostream* os) \
+    { \
+        *os << #name <<  "(" << testing::PrintToString(static_cast< type >(param)) << ")"; \
+    }
+
 struct CvtColorInfo
 {
     int scn;