build: migrate to traits::Type / traits::Depth

alalek · alalek · commit b556c2a7c363 · 2017-08-25T19:07:05.000+03:00
diff --git a/modules/optflow/src/simpleflow.cpp b/modules/optflow/src/simpleflow.cpp
@@ -131,7 +131,7 @@ class CrossBilateralFilter : public ParallelLoopBody {
             flag(flag_),
             spaceWeights(spaceWeights_),
             expLut(expLut_) {
-      CV_DbgAssert(joint.type() == JointVec::type && confidence.type() == CV_32F && src.type() == dst.type() && src.type() == SrcVec::type);
+      CV_DbgAssert(joint.type() == traits::Type<JointVec>::value && confidence.type() == CV_32F && src.type() == dst.type() && src.type() == traits::Type<SrcVec>::value);
       CV_DbgAssert(joint.rows == src.rows && confidence.rows == src.rows && src.rows == dst.rows + 2 * radius);
       CV_DbgAssert(joint.cols == src.cols && confidence.cols == src.cols && src.cols == dst.cols + 2 * radius);
     }
diff --git a/modules/ximgproc/src/dtfilter_cpu.inl.hpp b/modules/ximgproc/src/dtfilter_cpu.inl.hpp
@@ -69,7 +69,7 @@ DTFilterCPU* DTFilterCPU::create_p_(const Mat& guide, double sigmaSpatial, doubl
 template<typename GuideVec>
 void DTFilterCPU::init_(Mat& guide, double sigmaSpatial_, double sigmaColor_, int mode_, int numIters_)
 {
-    CV_Assert(guide.type() == cv::DataType<GuideVec>::type);
+    CV_Assert(guide.type() == traits::Type<GuideVec>::value);
 
     this->release();
 
@@ -123,7 +123,7 @@ template <typename SrcVec>
 void DTFilterCPU::filter_(const Mat& src, Mat& dst, int dDepth)
 {
     typedef typename DataType<Vec<WorkType, SrcVec::channels> >::vec_type WorkVec;
-    CV_Assert( src.type() == SrcVec::type );
+    CV_Assert( src.type() == traits::Type<SrcVec>::value );
     if ( src.cols != w || src.rows != h )
     {
         CV_Error(Error::StsBadSize, "Size of filtering image must be equal to size of guide image");
@@ -139,17 +139,17 @@ void DTFilterCPU::filter_(const Mat& src, Mat& dst, int dDepth)
     if (dDepth == -1) dDepth = src.depth();
     
     //small optimization to avoid extra copying of data
-    bool useDstAsRes = (dDepth == WorkVec::depth && (mode == DTF_NC || mode == DTF_RF));
+    bool useDstAsRes = (dDepth == traits::Depth<WorkVec>::value && (mode == DTF_NC || mode == DTF_RF));
     if (useDstAsRes)
     {
-        dst.create(h, w, WorkVec::type);
+        dst.create(h, w, traits::Type<WorkVec>::value);
         res = dst;
     }
 
     if (mode == DTF_NC)
     {
-        Mat resT(src.cols, src.rows, WorkVec::type);
-        src.convertTo(res, WorkVec::type);
+        Mat resT(src.cols, src.rows, traits::Type<WorkVec>::value);
+        src.convertTo(res, traits::Type<WorkVec>::value);
 
         FilterNC_horPass<WorkVec> horParBody(res, idistHor, resT);
         FilterNC_horPass<WorkVec> vertParBody(resT, idistVert, res);
@@ -180,7 +180,7 @@ void DTFilterCPU::filter_(const Mat& src, Mat& dst, int dDepth)
     }
     else if (mode == DTF_RF)
     {
-        src.convertTo(res, WorkVec::type);
+        src.convertTo(res, traits::Type<WorkVec>::value);
 
         for (int iter = 1; iter <= numIters; iter++)
         {
@@ -237,13 +237,13 @@ void DTFilterCPU::integrateSparseRow(const SrcVec *src, const float *dist, SrcWo
 template<typename WorkVec>
 void DTFilterCPU::prepareSrcImg_IC(const Mat& src, Mat& dst, Mat& dstT)
 {
-    Mat dstOut(src.rows, src.cols + 2, WorkVec::type);
-    Mat dstOutT(src.cols, src.rows + 2, WorkVec::type);
+    Mat dstOut(src.rows, src.cols + 2, traits::Type<WorkVec>::value);
+    Mat dstOutT(src.cols, src.rows + 2, traits::Type<WorkVec>::value);
 
     dst = dstOut(Range::all(), Range(1, src.cols+1));
     dstT = dstOutT(Range::all(), Range(1, src.rows+1));
 
-    src.convertTo(dst, WorkVec::type);
+    src.convertTo(dst, traits::Type<WorkVec>::value);
 
     WorkVec *line;
     int ri = dstOut.cols - 1;
@@ -270,7 +270,7 @@ template <typename WorkVec>
 DTFilterCPU::FilterNC_horPass<WorkVec>::FilterNC_horPass(Mat& src_, Mat& idist_, Mat& dst_)
 : src(src_), idist(idist_), dst(dst_), radius(1.0f)
 {
-    CV_DbgAssert(src.type() == WorkVec::type && dst.type() == WorkVec::type && dst.rows == src.cols && dst.cols == src.rows);
+    CV_DbgAssert(src.type() == traits::Type<WorkVec>::value && dst.type() == traits::Type<WorkVec>::value && dst.rows == src.cols && dst.cols == src.rows);
 }
 
 template <typename WorkVec>
@@ -324,12 +324,12 @@ template <typename WorkVec>
 DTFilterCPU::FilterIC_horPass<WorkVec>::FilterIC_horPass(Mat& src_, Mat& idist_, Mat& dist_, Mat& dst_)
 : src(src_), idist(idist_), dist(dist_), dst(dst_), radius(1.0f)
 {
-    CV_DbgAssert(src.type() == WorkVec::type && dst.type() == WorkVec::type && dst.rows == src.cols && dst.cols == src.rows);
+    CV_DbgAssert(src.type() == traits::Type<WorkVec>::value && dst.type() == traits::Type<WorkVec>::value && dst.rows == src.cols && dst.cols == src.rows);
 
     #ifdef CV_GET_NUM_THREAD_WORKS_PROPERLY
-    isrcBuf.create(cv::getNumThreads(), src.cols + 1, WorkVec::type);
+    isrcBuf.create(cv::getNumThreads(), src.cols + 1, traits::Type<WorkVec>::value);
     #else
-    isrcBuf.create(src.rows, src.cols + 1, WorkVec::type);
+    isrcBuf.create(src.rows, src.cols + 1, traits::Type<WorkVec>::value);
     #endif
 }
 
@@ -384,8 +384,8 @@ template <typename WorkVec>
 DTFilterCPU::FilterRF_horPass<WorkVec>::FilterRF_horPass(Mat& res_, Mat& alphaD_, int iteration_)
 : res(res_), alphaD(alphaD_), iteration(iteration_)
 {
-    CV_DbgAssert(res.type() == WorkVec::type);
-    CV_DbgAssert(res.type() == WorkVec::type && res.size() == res.size());
+    CV_DbgAssert(res.type() == traits::Type<WorkVec>::value);
+    CV_DbgAssert(res.type() == traits::Type<WorkVec>::value && res.size() == res.size());
 }
 
 
@@ -421,8 +421,8 @@ template <typename WorkVec>
 DTFilterCPU::FilterRF_vertPass<WorkVec>::FilterRF_vertPass(Mat& res_, Mat& alphaD_, int iteration_)
 : res(res_), alphaD(alphaD_), iteration(iteration_)
 {
-    CV_DbgAssert(res.type() == WorkVec::type);
-    CV_DbgAssert(res.type() == WorkVec::type && res.size() == res.size());
+    CV_DbgAssert(res.type() == traits::Type<WorkVec>::value);
+    CV_DbgAssert(res.type() == traits::Type<WorkVec>::value && res.size() == res.size());
 }
 
 
@@ -470,7 +470,7 @@ template <typename GuideVec>
 DTFilterCPU::ComputeIDTHor_ParBody<GuideVec>::ComputeIDTHor_ParBody(DTFilterCPU& dtf_, Mat& guide_, Mat& dst_)
 : dtf(dtf_), guide(guide_), dst(dst_)
 {
-    dst.create(guide.rows, guide.cols + 1, IDistVec::type);
+    dst.create(guide.rows, guide.cols + 1, traits::Type<IDistVec>::value);
 }
 
 template <typename GuideVec>
@@ -497,8 +497,8 @@ template <typename GuideVec>
 DTFilterCPU::ComputeDTandIDTHor_ParBody<GuideVec>::ComputeDTandIDTHor_ParBody(DTFilterCPU& dtf_, Mat& guide_, Mat& dist_, Mat& idist_)
 : dtf(dtf_), guide(guide_), dist(dist_), idist(idist_)
 {
-    dist = getWExtendedMat(guide.rows, guide.cols, IDistVec::type, 1, 1);
-    idist = getWExtendedMat(guide.rows, guide.cols + 1, IDistVec::type);
+    dist = getWExtendedMat(guide.rows, guide.cols, traits::Type<IDistVec>::value, 1, 1);
+    idist = getWExtendedMat(guide.rows, guide.cols + 1, traits::Type<IDistVec>::value);
     maxRadius = dtf.getIterRadius(1);
 }
 
@@ -535,7 +535,7 @@ template <typename GuideVec>
 DTFilterCPU::ComputeA0DTHor_ParBody<GuideVec>::ComputeA0DTHor_ParBody(DTFilterCPU& dtf_, Mat& guide_)
 : dtf(dtf_), guide(guide_)
 {
-    dtf.a0distHor.create(guide.rows, guide.cols - 1, DistVec::type);
+    dtf.a0distHor.create(guide.rows, guide.cols - 1, traits::Type<DistVec>::value);
     lna = std::log(dtf.getIterAlpha(1));
 }
 
@@ -565,7 +565,7 @@ template <typename GuideVec>
 DTFilterCPU::ComputeA0DTVert_ParBody<GuideVec>::ComputeA0DTVert_ParBody(DTFilterCPU& dtf_, Mat& guide_)
 : dtf(dtf_), guide(guide_)
 {
-    dtf.a0distVert.create(guide.rows - 1, guide.cols, DistVec::type);
+    dtf.a0distVert.create(guide.rows - 1, guide.cols, traits::Type<DistVec>::value);
     lna = std::log(dtf.getIterAlpha(1));
 }
 
diff --git a/modules/ximgproc/src/fgs_filter.cpp b/modules/ximgproc/src/fgs_filter.cpp
@@ -148,16 +148,16 @@ void FastGlobalSmootherFilterImpl::init(InputArray guide,double _lambda,double _
     num_iter = _num_iter;
     num_stripes = getNumThreads();
     int num_levels = 3*256*256;
-    weights_LUT.create(1,num_levels,WorkVec::type);
+    weights_LUT.create(1,num_levels,traits::Type<WorkVec>::value);
 
     WorkType* LUT = (WorkType*)weights_LUT.ptr(0);
     parallel_for_(Range(0,num_stripes),ComputeLUT_ParBody(*this,LUT,num_stripes,num_levels));
 
     w = guide.cols();
     h = guide.rows();
-    Chor.  create(h,w,WorkVec::type);
-    Cvert. create(h,w,WorkVec::type);
-    interD.create(h,w,WorkVec::type);
+    Chor.  create(h,w,traits::Type<WorkVec>::value);
+    Cvert. create(h,w,traits::Type<WorkVec>::value);
+    interD.create(h,w,traits::Type<WorkVec>::value);
     Mat guideMat = guide.getMat();
 
     if(guide.channels() == 1)
@@ -201,8 +201,8 @@ void FastGlobalSmootherFilterImpl::filter(InputArray src, OutputArray dst)
     {
         lambda = lambda_ref;
         Mat cur_res = src_channels[i].clone();
-        if(src.depth()!=WorkVec::type)
-            cur_res.convertTo(cur_res,WorkVec::type);
+        if(src.depth()!=traits::Type<WorkVec>::value)
+            cur_res.convertTo(cur_res,traits::Type<WorkVec>::value);
 
         for(int n=0;n<num_iter;n++)
         {
@@ -212,7 +212,7 @@ void FastGlobalSmootherFilterImpl::filter(InputArray src, OutputArray dst)
         }
 
         Mat dstMat;
-        if(src.depth()!=WorkVec::type)
+        if(src.depth()!=traits::Type<WorkVec>::value)
             cur_res.convertTo(dstMat,src.depth());
         else
             dstMat = cur_res;
diff --git a/modules/ximgproc/src/joint_bilateral_filter.cpp b/modules/ximgproc/src/joint_bilateral_filter.cpp
@@ -77,7 +77,7 @@ class JointBilateralFilter_32f : public ParallelLoopBody
         joint(joint_), src(src_), dst(dst_), radius(radius_), maxk(maxk_), 
         scaleIndex(scaleIndex_), spaceOfs(spaceOfs_), spaceWeights(spaceWeights_), expLUT(expLUT_)
     {
-        CV_DbgAssert(joint.type() == JointVec::type && src.type() == dst.type() && src.type() == SrcVec::type);
+        CV_DbgAssert(joint.type() == traits::Type<JointVec>::value && src.type() == dst.type() && src.type() == traits::Type<SrcVec>::value);
         CV_DbgAssert(joint.rows == src.rows && src.rows == dst.rows + 2*radius);
         CV_DbgAssert(joint.cols == src.cols && src.cols == dst.cols + 2*radius);
     }
@@ -223,7 +223,7 @@ class JointBilateralFilter_8u : public ParallelLoopBody
         joint(joint_), src(src_), dst(dst_), radius(radius_), maxk(maxk_),
         spaceOfs(spaceOfs_), spaceWeights(spaceWeights_), expLUT(expLUT_)
     {
-        CV_DbgAssert(joint.type() == JointVec::type && src.type() == dst.type() && src.type() == SrcVec::type);
+        CV_DbgAssert(joint.type() == traits::Type<JointVec>::value && src.type() == dst.type() && src.type() == traits::Type<SrcVec>::value);
         CV_DbgAssert(joint.rows == src.rows && src.rows == dst.rows + 2 * radius);
         CV_DbgAssert(joint.cols == src.cols && src.cols == dst.cols + 2 * radius);
     }
diff --git a/modules/ximgproc/test/test_domain_transform.cpp b/modules/ximgproc/test/test_domain_transform.cpp
@@ -168,7 +168,7 @@ Mat getChessMat1px(Size sz, double whiteIntensity = 255)
 {
     typedef typename DataType<SrcVec>::channel_type SrcType;
 
-    Mat dst(sz, DataType<SrcVec>::type);
+    Mat dst(sz, traits::Type<SrcVec>::value);
 
     SrcVec black = SrcVec::all(0);
     SrcVec white = SrcVec::all((SrcType)whiteIntensity);
diff --git a/modules/ximgproc/test/test_joint_bilateral_filter.cpp b/modules/ximgproc/test/test_joint_bilateral_filter.cpp
@@ -113,7 +113,7 @@ template<typename JointVec, typename SrcVec>
 void jointBilateralFilterNaive_(InputArray joint_, InputArray src_, OutputArray dst_, int d, double sigmaColor, double sigmaSpace, int borderType)
 {
     CV_Assert(joint_.size() == src_.size());
-    CV_Assert(joint_.type() == JointVec::type && src_.type() == SrcVec::type);
+    CV_Assert(joint_.type() == traits::Type<JointVec>::value && src_.type() == traits::Type<SrcVec>::value);
     typedef Vec<float, SrcVec::channels> SrcVecf;
 
     if (sigmaColor <= 0)
diff --git a/modules/ximgproc/test/test_structured_edge_detection.cpp b/modules/ximgproc/test/test_structured_edge_detection.cpp
@@ -22,9 +22,9 @@ TEST(ximpgroc_StructuredEdgeDetection, regression)
 
         cv::String previousResultName = dir + cv::format( "results/%02d.png", i + 1 );
         cv::Mat previousResult = cv::imread( previousResultName, 0 );
-        previousResult.convertTo( previousResult, cv::DataType<float>::type, 1/255.0 );
+        previousResult.convertTo( previousResult, CV_32F, 1/255.0 );
 
-        src.convertTo( src, cv::DataType<float>::type, 1/255.0 );
+        src.convertTo( src, CV_32F, 1/255.0 );
 
         cv::Mat currentResult( src.size(), src.type() );
         pDollar->detectEdges( src, currentResult );

Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ class CrossBilateralFilter : public ParallelLoopBody {`
`131`	`131`	`flag(flag_),`
`132`	`132`	`spaceWeights(spaceWeights_),`
`133`	`133`	`expLut(expLut_) {`
`134`		`- CV_DbgAssert(joint.type() == JointVec::type && confidence.type() == CV_32F && src.type() == dst.type() && src.type() == SrcVec::type);`
	`134`	`+ CV_DbgAssert(joint.type() == traits::Type<JointVec>::value && confidence.type() == CV_32F && src.type() == dst.type() && src.type() == traits::Type<SrcVec>::value);`
`135`	`135`	`CV_DbgAssert(joint.rows == src.rows && confidence.rows == src.rows && src.rows == dst.rows + 2 * radius);`
`136`	`136`	`CV_DbgAssert(joint.cols == src.cols && confidence.cols == src.cols && src.cols == dst.cols + 2 * radius);`
`137`	`137`	`}`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ DTFilterCPU* DTFilterCPU::create_p_(const Mat& guide, double sigmaSpatial, doubl`
`69`	`69`	`template<typename GuideVec>`
`70`	`70`	`void DTFilterCPU::init_(Mat& guide, double sigmaSpatial_, double sigmaColor_, int mode_, int numIters_)`
`71`	`71`	`{`
`72`		`- CV_Assert(guide.type() == cv::DataType<GuideVec>::type);`
	`72`	`+ CV_Assert(guide.type() == traits::Type<GuideVec>::value);`
`73`	`73`
`74`	`74`	`this->release();`
`75`	`75`
`@@ -123,7 +123,7 @@ template <typename SrcVec>`
`123`	`123`	`void DTFilterCPU::filter_(const Mat& src, Mat& dst, int dDepth)`
`124`	`124`	`{`
`125`	`125`	`typedef typename DataType<Vec<WorkType, SrcVec::channels> >::vec_type WorkVec;`
`126`		`- CV_Assert( src.type() == SrcVec::type );`
	`126`	`+ CV_Assert( src.type() == traits::Type<SrcVec>::value );`
`127`	`127`	`if ( src.cols != w \|\| src.rows != h )`
`128`	`128`	`{`
`129`	`129`	`CV_Error(Error::StsBadSize, "Size of filtering image must be equal to size of guide image");`
`@@ -139,17 +139,17 @@ void DTFilterCPU::filter_(const Mat& src, Mat& dst, int dDepth)`
`139`	`139`	`if (dDepth == -1) dDepth = src.depth();`
`140`	`140`
`141`	`141`	`//small optimization to avoid extra copying of data`
`142`		`- bool useDstAsRes = (dDepth == WorkVec::depth && (mode == DTF_NC \|\| mode == DTF_RF));`
	`142`	`+ bool useDstAsRes = (dDepth == traits::Depth<WorkVec>::value && (mode == DTF_NC \|\| mode == DTF_RF));`
`143`	`143`	`if (useDstAsRes)`
`144`	`144`	`{`
`145`		`- dst.create(h, w, WorkVec::type);`
	`145`	`+ dst.create(h, w, traits::Type<WorkVec>::value);`
`146`	`146`	`res = dst;`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`if (mode == DTF_NC)`
`150`	`150`	`{`
`151`		`- Mat resT(src.cols, src.rows, WorkVec::type);`
`152`		`- src.convertTo(res, WorkVec::type);`
	`151`	`+ Mat resT(src.cols, src.rows, traits::Type<WorkVec>::value);`
	`152`	`+ src.convertTo(res, traits::Type<WorkVec>::value);`
`153`	`153`
`154`	`154`	`FilterNC_horPass<WorkVec> horParBody(res, idistHor, resT);`
`155`	`155`	`FilterNC_horPass<WorkVec> vertParBody(resT, idistVert, res);`
`@@ -180,7 +180,7 @@ void DTFilterCPU::filter_(const Mat& src, Mat& dst, int dDepth)`
`180`	`180`	`}`
`181`	`181`	`else if (mode == DTF_RF)`
`182`	`182`	`{`
`183`		`- src.convertTo(res, WorkVec::type);`
	`183`	`+ src.convertTo(res, traits::Type<WorkVec>::value);`
`184`	`184`
`185`	`185`	`for (int iter = 1; iter <= numIters; iter++)`
`186`	`186`	`{`
`@@ -237,13 +237,13 @@ void DTFilterCPU::integrateSparseRow(const SrcVec src, const float dist, SrcWo`
`237`	`237`	`template<typename WorkVec>`
`238`	`238`	`void DTFilterCPU::prepareSrcImg_IC(const Mat& src, Mat& dst, Mat& dstT)`
`239`	`239`	`{`
`240`		`- Mat dstOut(src.rows, src.cols + 2, WorkVec::type);`
`241`		`- Mat dstOutT(src.cols, src.rows + 2, WorkVec::type);`
	`240`	`+ Mat dstOut(src.rows, src.cols + 2, traits::Type<WorkVec>::value);`
	`241`	`+ Mat dstOutT(src.cols, src.rows + 2, traits::Type<WorkVec>::value);`
`242`	`242`
`243`	`243`	`dst = dstOut(Range::all(), Range(1, src.cols+1));`
`244`	`244`	`dstT = dstOutT(Range::all(), Range(1, src.rows+1));`
`245`	`245`
`246`		`- src.convertTo(dst, WorkVec::type);`
	`246`	`+ src.convertTo(dst, traits::Type<WorkVec>::value);`
`247`	`247`
`248`	`248`	`WorkVec *line;`
`249`	`249`	`int ri = dstOut.cols - 1;`
`@@ -270,7 +270,7 @@ template <typename WorkVec>`
`270`	`270`	`DTFilterCPU::FilterNC_horPass<WorkVec>::FilterNC_horPass(Mat& src_, Mat& idist_, Mat& dst_)`
`271`	`271`	`: src(src_), idist(idist_), dst(dst_), radius(1.0f)`
`272`	`272`	`{`
`273`		`- CV_DbgAssert(src.type() == WorkVec::type && dst.type() == WorkVec::type && dst.rows == src.cols && dst.cols == src.rows);`
	`273`	`+ CV_DbgAssert(src.type() == traits::Type<WorkVec>::value && dst.type() == traits::Type<WorkVec>::value && dst.rows == src.cols && dst.cols == src.rows);`
`274`	`274`	`}`
`275`	`275`
`276`	`276`	`template <typename WorkVec>`
`@@ -324,12 +324,12 @@ template <typename WorkVec>`
`324`	`324`	`DTFilterCPU::FilterIC_horPass<WorkVec>::FilterIC_horPass(Mat& src_, Mat& idist_, Mat& dist_, Mat& dst_)`
`325`	`325`	`: src(src_), idist(idist_), dist(dist_), dst(dst_), radius(1.0f)`
`326`	`326`	`{`
`327`		`- CV_DbgAssert(src.type() == WorkVec::type && dst.type() == WorkVec::type && dst.rows == src.cols && dst.cols == src.rows);`
	`327`	`+ CV_DbgAssert(src.type() == traits::Type<WorkVec>::value && dst.type() == traits::Type<WorkVec>::value && dst.rows == src.cols && dst.cols == src.rows);`
`328`	`328`
`329`	`329`	`#ifdef CV_GET_NUM_THREAD_WORKS_PROPERLY`
`330`		`- isrcBuf.create(cv::getNumThreads(), src.cols + 1, WorkVec::type);`
	`330`	`+ isrcBuf.create(cv::getNumThreads(), src.cols + 1, traits::Type<WorkVec>::value);`
`331`	`331`	`#else`
`332`		`- isrcBuf.create(src.rows, src.cols + 1, WorkVec::type);`
	`332`	`+ isrcBuf.create(src.rows, src.cols + 1, traits::Type<WorkVec>::value);`
`333`	`333`	`#endif`
`334`	`334`	`}`
`335`	`335`
`@@ -384,8 +384,8 @@ template <typename WorkVec>`
`384`	`384`	`DTFilterCPU::FilterRF_horPass<WorkVec>::FilterRF_horPass(Mat& res_, Mat& alphaD_, int iteration_)`
`385`	`385`	`: res(res_), alphaD(alphaD_), iteration(iteration_)`
`386`	`386`	`{`
`387`		`- CV_DbgAssert(res.type() == WorkVec::type);`
`388`		`- CV_DbgAssert(res.type() == WorkVec::type && res.size() == res.size());`
	`387`	`+ CV_DbgAssert(res.type() == traits::Type<WorkVec>::value);`
	`388`	`+ CV_DbgAssert(res.type() == traits::Type<WorkVec>::value && res.size() == res.size());`
`389`	`389`	`}`
`390`	`390`
`391`	`391`
`@@ -421,8 +421,8 @@ template <typename WorkVec>`
`421`	`421`	`DTFilterCPU::FilterRF_vertPass<WorkVec>::FilterRF_vertPass(Mat& res_, Mat& alphaD_, int iteration_)`
`422`	`422`	`: res(res_), alphaD(alphaD_), iteration(iteration_)`
`423`	`423`	`{`
`424`		`- CV_DbgAssert(res.type() == WorkVec::type);`
`425`		`- CV_DbgAssert(res.type() == WorkVec::type && res.size() == res.size());`
	`424`	`+ CV_DbgAssert(res.type() == traits::Type<WorkVec>::value);`
	`425`	`+ CV_DbgAssert(res.type() == traits::Type<WorkVec>::value && res.size() == res.size());`
`426`	`426`	`}`
`427`	`427`
`428`	`428`
`@@ -470,7 +470,7 @@ template <typename GuideVec>`
`470`	`470`	`DTFilterCPU::ComputeIDTHor_ParBody<GuideVec>::ComputeIDTHor_ParBody(DTFilterCPU& dtf_, Mat& guide_, Mat& dst_)`
`471`	`471`	`: dtf(dtf_), guide(guide_), dst(dst_)`
`472`	`472`	`{`
`473`		`- dst.create(guide.rows, guide.cols + 1, IDistVec::type);`
	`473`	`+ dst.create(guide.rows, guide.cols + 1, traits::Type<IDistVec>::value);`
`474`	`474`	`}`
`475`	`475`
`476`	`476`	`template <typename GuideVec>`
`@@ -497,8 +497,8 @@ template <typename GuideVec>`
`497`	`497`	`DTFilterCPU::ComputeDTandIDTHor_ParBody<GuideVec>::ComputeDTandIDTHor_ParBody(DTFilterCPU& dtf_, Mat& guide_, Mat& dist_, Mat& idist_)`
`498`	`498`	`: dtf(dtf_), guide(guide_), dist(dist_), idist(idist_)`
`499`	`499`	`{`
`500`		`- dist = getWExtendedMat(guide.rows, guide.cols, IDistVec::type, 1, 1);`
`501`		`- idist = getWExtendedMat(guide.rows, guide.cols + 1, IDistVec::type);`
	`500`	`+ dist = getWExtendedMat(guide.rows, guide.cols, traits::Type<IDistVec>::value, 1, 1);`
	`501`	`+ idist = getWExtendedMat(guide.rows, guide.cols + 1, traits::Type<IDistVec>::value);`
`502`	`502`	`maxRadius = dtf.getIterRadius(1);`
`503`	`503`	`}`
`504`	`504`
`@@ -535,7 +535,7 @@ template <typename GuideVec>`
`535`	`535`	`DTFilterCPU::ComputeA0DTHor_ParBody<GuideVec>::ComputeA0DTHor_ParBody(DTFilterCPU& dtf_, Mat& guide_)`
`536`	`536`	`: dtf(dtf_), guide(guide_)`
`537`	`537`	`{`
`538`		`- dtf.a0distHor.create(guide.rows, guide.cols - 1, DistVec::type);`
	`538`	`+ dtf.a0distHor.create(guide.rows, guide.cols - 1, traits::Type<DistVec>::value);`
`539`	`539`	`lna = std::log(dtf.getIterAlpha(1));`
`540`	`540`	`}`
`541`	`541`
`@@ -565,7 +565,7 @@ template <typename GuideVec>`
`565`	`565`	`DTFilterCPU::ComputeA0DTVert_ParBody<GuideVec>::ComputeA0DTVert_ParBody(DTFilterCPU& dtf_, Mat& guide_)`
`566`	`566`	`: dtf(dtf_), guide(guide_)`
`567`	`567`	`{`
`568`		`- dtf.a0distVert.create(guide.rows - 1, guide.cols, DistVec::type);`
	`568`	`+ dtf.a0distVert.create(guide.rows - 1, guide.cols, traits::Type<DistVec>::value);`
`569`	`569`	`lna = std::log(dtf.getIterAlpha(1));`
`570`	`570`	`}`
`571`	`571`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ class JointBilateralFilter_32f : public ParallelLoopBody`
`77`	`77`	`joint(joint_), src(src_), dst(dst_), radius(radius_), maxk(maxk_),`
`78`	`78`	`scaleIndex(scaleIndex_), spaceOfs(spaceOfs_), spaceWeights(spaceWeights_), expLUT(expLUT_)`
`79`	`79`	`{`
`80`		`- CV_DbgAssert(joint.type() == JointVec::type && src.type() == dst.type() && src.type() == SrcVec::type);`
	`80`	`+ CV_DbgAssert(joint.type() == traits::Type<JointVec>::value && src.type() == dst.type() && src.type() == traits::Type<SrcVec>::value);`
`81`	`81`	`CV_DbgAssert(joint.rows == src.rows && src.rows == dst.rows + 2*radius);`
`82`	`82`	`CV_DbgAssert(joint.cols == src.cols && src.cols == dst.cols + 2*radius);`
`83`	`83`	`}`
`@@ -223,7 +223,7 @@ class JointBilateralFilter_8u : public ParallelLoopBody`
`223`	`223`	`joint(joint_), src(src_), dst(dst_), radius(radius_), maxk(maxk_),`
`224`	`224`	`spaceOfs(spaceOfs_), spaceWeights(spaceWeights_), expLUT(expLUT_)`
`225`	`225`	`{`
`226`		`- CV_DbgAssert(joint.type() == JointVec::type && src.type() == dst.type() && src.type() == SrcVec::type);`
	`226`	`+ CV_DbgAssert(joint.type() == traits::Type<JointVec>::value && src.type() == dst.type() && src.type() == traits::Type<SrcVec>::value);`
`227`	`227`	`CV_DbgAssert(joint.rows == src.rows && src.rows == dst.rows + 2 * radius);`
`228`	`228`	`CV_DbgAssert(joint.cols == src.cols && src.cols == dst.cols + 2 * radius);`
`229`	`229`	`}`
Original file line number	Diff line number	Diff line change
`@@ -168,7 +168,7 @@ Mat getChessMat1px(Size sz, double whiteIntensity = 255)`
`168`	`168`	`{`
`169`	`169`	`typedef typename DataType<SrcVec>::channel_type SrcType;`
`170`	`170`
`171`		`- Mat dst(sz, DataType<SrcVec>::type);`
	`171`	`+ Mat dst(sz, traits::Type<SrcVec>::value);`
`172`	`172`
`173`	`173`	`SrcVec black = SrcVec::all(0);`
`174`	`174`	`SrcVec white = SrcVec::all((SrcType)whiteIntensity);`
Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,7 @@ template<typename JointVec, typename SrcVec>`
`113`	`113`	`void jointBilateralFilterNaive_(InputArray joint_, InputArray src_, OutputArray dst_, int d, double sigmaColor, double sigmaSpace, int borderType)`
`114`	`114`	`{`
`115`	`115`	`CV_Assert(joint_.size() == src_.size());`
`116`		`- CV_Assert(joint_.type() == JointVec::type && src_.type() == SrcVec::type);`
	`116`	`+ CV_Assert(joint_.type() == traits::Type<JointVec>::value && src_.type() == traits::Type<SrcVec>::value);`
`117`	`117`	`typedef Vec<float, SrcVec::channels> SrcVecf;`
`118`	`118`
`119`	`119`	`if (sigmaColor <= 0)`