}
template void addMat<uchar, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void addMat<uchar, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
template void addMat<uchar, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
template void addMat<uchar, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void addMat<float, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void addMat<float, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void addMat<float, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+#endif
template void addMat<float, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void addMat<float, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void addMat<double, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void addMat<double, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void addMat<double, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
template void addMat<double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////
}
template void addScalar<uchar, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void addScalar<uchar, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
template void addScalar<uchar, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
template void addScalar<uchar, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void addScalar<float, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void addScalar<float, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void addScalar<float, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+#endif
template void addScalar<float, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void addScalar<float, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void addScalar<double, double, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void addScalar<double, double, int>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void addScalar<double, double, float>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
template void addScalar<double, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////
}
template void subMat<uchar, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void subMat<uchar, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
template void subMat<uchar, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
template void subMat<uchar, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void subMat<float, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void subMat<float, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void subMat<float, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+#endif
template void subMat<float, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void subMat<float, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void subMat<double, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void subMat<double, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void subMat<double, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
template void subMat<double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////
}
template void subScalar<uchar, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void subScalar<uchar, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
template void subScalar<uchar, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
template void subScalar<uchar, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void subScalar<float, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void subScalar<float, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void subScalar<float, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+#endif
template void subScalar<float, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void subScalar<float, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void subScalar<double, double, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void subScalar<double, double, int>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
//template void subScalar<double, double, float>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
template void subScalar<double, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////
}
template void mulMat<uchar, float, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void mulMat<uchar, float, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
template void mulMat<uchar, float, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
template void mulMat<uchar, float, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
//template void mulMat<float, float, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
//template void mulMat<float, float, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
//template void mulMat<float, float, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+#endif
template void mulMat<float, float, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void mulMat<float, double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
//template void mulMat<double, double, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
//template void mulMat<double, double, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
//template void mulMat<double, double, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
template void mulMat<double, double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////
}
template void mulScalar<uchar, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void mulScalar<uchar, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
template void mulScalar<uchar, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
template void mulScalar<uchar, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
//template void mulScalar<float, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
//template void mulScalar<float, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
//template void mulScalar<float, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void mulScalar<float, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void mulScalar<float, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
//template void mulScalar<double, double, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
//template void mulScalar<double, double, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
//template void mulScalar<double, double, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
template void mulScalar<double, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////
}
template void divMat<uchar, float, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void divMat<uchar, float, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
template void divMat<uchar, float, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
template void divMat<uchar, float, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
//template void divMat<float, float, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
//template void divMat<float, float, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
//template void divMat<float, float, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+#endif
template void divMat<float, float, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void divMat<float, double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
//template void divMat<double, double, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
//template void divMat<double, double, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
//template void divMat<double, double, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
template void divMat<double, double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////
}
template void divScalar<uchar, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void divScalar<uchar, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
template void divScalar<uchar, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
template void divScalar<uchar, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
//template void divScalar<float, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
//template void divScalar<float, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
//template void divScalar<float, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void divScalar<float, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void divScalar<float, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
//template void divScalar<double, double, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
//template void divScalar<double, double, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
//template void divScalar<double, double, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
template void divScalar<double, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////
}
template void divInv<uchar, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void divInv<uchar, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
template void divInv<uchar, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
template void divInv<uchar, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
//template void divInv<float, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
//template void divInv<float, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
//template void divInv<float, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void divInv<float, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void divInv<float, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
//template void divInv<double, double, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
//template void divInv<double, double, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
//template void divInv<double, double, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
template void divInv<double, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////
}
template void absDiffMat<uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void absDiffMat<schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void absDiffMat<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void absDiffMat<short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void absDiffMat<int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void absDiffMat<float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void absDiffMat<double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////
}
template void absDiffScalar<uchar, float>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void absDiffScalar<schar, float>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
template void absDiffScalar<ushort, float>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
template void absDiffScalar<short, float>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
template void absDiffScalar<int, float>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void absDiffScalar<float, float>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void absDiffScalar<double, double>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////
transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, abs_func<T>(), WithOutMask(), stream);
}
+#ifndef OPENCV_TINY_GPU_MODULE
template void absMat<uchar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void absMat<schar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void absMat<ushort>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void absMat<short>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void absMat<int>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void absMat<float>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void absMat<double>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////
transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, Sqr<T>(), WithOutMask(), stream);
}
+#ifndef OPENCV_TINY_GPU_MODULE
template void sqrMat<uchar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void sqrMat<schar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void sqrMat<ushort>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void sqrMat<short>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void sqrMat<int>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void sqrMat<float>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void sqrMat<double>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////
transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, sqrt_func<T>(), WithOutMask(), stream);
}
+#ifndef OPENCV_TINY_GPU_MODULE
template void sqrtMat<uchar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void sqrtMat<schar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void sqrtMat<ushort>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void sqrtMat<short>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void sqrtMat<int>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void sqrtMat<float>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void sqrtMat<double>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////
transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, log_func<T>(), WithOutMask(), stream);
}
+#ifndef OPENCV_TINY_GPU_MODULE
template void logMat<uchar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void logMat<schar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void logMat<ushort>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void logMat<short>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void logMat<int>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void logMat<float>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void logMat<double>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////
transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, Exp<T>(), WithOutMask(), stream);
}
+#ifndef OPENCV_TINY_GPU_MODULE
template void expMat<uchar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void expMat<schar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void expMat<ushort>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void expMat<short>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
template void expMat<int>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void expMat<float>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void expMat<double>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////////////////
}
template void cmpMatEq<uchar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void cmpMatEq<schar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void cmpMatEq<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void cmpMatEq<short >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void cmpMatEq<int >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void cmpMatEq<float >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void cmpMatEq<double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void cmpMatNe<uchar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void cmpMatNe<schar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void cmpMatNe<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void cmpMatNe<short >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void cmpMatNe<int >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void cmpMatNe<float >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void cmpMatNe<double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void cmpMatLt<uchar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void cmpMatLt<schar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void cmpMatLt<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void cmpMatLt<short >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void cmpMatLt<int >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void cmpMatLt<float >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void cmpMatLt<double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void cmpMatLe<uchar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void cmpMatLe<schar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void cmpMatLe<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void cmpMatLe<short >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void cmpMatLe<int >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void cmpMatLe<float >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void cmpMatLe<double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////////////////
}
template void cmpScalarEq<uchar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void cmpScalarEq<schar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
template void cmpScalarEq<ushort>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
template void cmpScalarEq<short >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
template void cmpScalarEq<int >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#endif
template void cmpScalarEq<float >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void cmpScalarEq<double>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#endif
template void cmpScalarNe<uchar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void cmpScalarNe<schar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
template void cmpScalarNe<ushort>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
template void cmpScalarNe<short >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
template void cmpScalarNe<int >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#endif
template void cmpScalarNe<float >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void cmpScalarNe<double>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#endif
template void cmpScalarLt<uchar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void cmpScalarLt<schar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
template void cmpScalarLt<ushort>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
template void cmpScalarLt<short >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
template void cmpScalarLt<int >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#endif
template void cmpScalarLt<float >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void cmpScalarLt<double>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#endif
template void cmpScalarLe<uchar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void cmpScalarLe<schar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
template void cmpScalarLe<ushort>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
template void cmpScalarLe<short >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
template void cmpScalarLe<int >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#endif
template void cmpScalarLe<float >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void cmpScalarLe<double>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#endif
template void cmpScalarGt<uchar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void cmpScalarGt<schar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
template void cmpScalarGt<ushort>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
template void cmpScalarGt<short >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
template void cmpScalarGt<int >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#endif
template void cmpScalarGt<float >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void cmpScalarGt<double>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#endif
template void cmpScalarGe<uchar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void cmpScalarGe<schar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
template void cmpScalarGe<ushort>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
template void cmpScalarGe<short >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
template void cmpScalarGe<int >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#endif
template void cmpScalarGe<float >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void cmpScalarGe<double>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////////////////
}
template void bitScalarAnd<uchar>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void bitScalarAnd<ushort>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
template void bitScalarAnd<int>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
template void bitScalarAnd<unsigned int>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void bitScalarOr<uchar>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void bitScalarOr<ushort>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
template void bitScalarOr<int>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
template void bitScalarOr<unsigned int>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void bitScalarXor<uchar>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void bitScalarXor<ushort>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
template void bitScalarXor<int>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
template void bitScalarXor<unsigned int>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////
}
template void minMat<uchar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void minMat<schar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void minMat<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void minMat<short >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void minMat<int >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void minMat<float >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void minMat<double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
template <typename T> void minScalar(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream)
{
}
template void minScalar<uchar >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void minScalar<schar >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
template void minScalar<ushort>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
template void minScalar<short >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
template void minScalar<int >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void minScalar<float >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void minScalar<double>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////
}
template void maxMat<uchar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void maxMat<schar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void maxMat<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void maxMat<short >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
template void maxMat<int >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void maxMat<float >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void maxMat<double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
template <typename T> void maxScalar(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream)
{
}
template void maxScalar<uchar >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void maxScalar<schar >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
template void maxScalar<ushort>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
template void maxScalar<short >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
template void maxScalar<int >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void maxScalar<float >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void maxScalar<double>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////
}
template void threshold<uchar>(PtrStepSzb src, PtrStepSzb dst, double thresh, double maxVal, int type, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void threshold<schar>(PtrStepSzb src, PtrStepSzb dst, double thresh, double maxVal, int type, cudaStream_t stream);
template void threshold<ushort>(PtrStepSzb src, PtrStepSzb dst, double thresh, double maxVal, int type, cudaStream_t stream);
template void threshold<short>(PtrStepSzb src, PtrStepSzb dst, double thresh, double maxVal, int type, cudaStream_t stream);
template void threshold<int>(PtrStepSzb src, PtrStepSzb dst, double thresh, double maxVal, int type, cudaStream_t stream);
+#endif
template void threshold<float>(PtrStepSzb src, PtrStepSzb dst, double thresh, double maxVal, int type, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void threshold<double>(PtrStepSzb src, PtrStepSzb dst, double thresh, double maxVal, int type, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////
transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, PowOp<T>(power), WithOutMask(), stream);
}
+#ifndef OPENCV_TINY_GPU_MODULE
template void pow<uchar>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
template void pow<schar>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
template void pow<short>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
template void pow<ushort>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
template void pow<int>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
+#endif
template void pow<float>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
+#ifndef OPENCV_TINY_GPU_MODULE
template void pow<double>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
+#endif
}
//////////////////////////////////////////////////////////////////////////
using namespace arithm;
typedef void (*func_t)(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[7][7] =
+ {
+ {
+ addMat<unsigned char, unsigned char>,
+ 0/*addMat<unsigned char, signed char>*/,
+ 0/*addMat<unsigned char, unsigned short>*/,
+ 0/*addMat<unsigned char, short>*/,
+ 0/*addMat<unsigned char, int>*/,
+ 0/*addMat<unsigned char, float>*/,
+ 0/*addMat<unsigned char, double>*/,
+ },
+ {
+ 0/*addMat<signed char, unsigned char>*/,
+ 0/*addMat<signed char, signed char>*/,
+ 0/*addMat<signed char, unsigned short>*/,
+ 0/*addMat<signed char, short>*/,
+ 0/*addMat<signed char, int>*/,
+ 0/*addMat<signed char, float>*/,
+ 0/*addMat<signed char, double>*/,
+ },
+ {
+ 0 /*addMat<unsigned short, unsigned char>*/,
+ 0 /*addMat<unsigned short, signed char>*/,
+ 0/*addMat<unsigned short, unsigned short>*/,
+ 0/*addMat<unsigned short, short>*/,
+ 0/*addMat<unsigned short, int>*/,
+ 0/*addMat<unsigned short, float>*/,
+ 0/*addMat<unsigned short, double>*/,
+ },
+ {
+ 0 /*addMat<short, unsigned char>*/,
+ 0 /*addMat<short, signed char>*/,
+ 0/*addMat<short, unsigned short>*/,
+ 0/*addMat<short, short>*/,
+ 0/*addMat<short, int>*/,
+ 0/*addMat<short, float>*/,
+ 0/*addMat<short, double>*/,
+ },
+ {
+ 0 /*addMat<int, unsigned char>*/,
+ 0 /*addMat<int, signed char>*/,
+ 0 /*addMat<int, unsigned short>*/,
+ 0 /*addMat<int, short>*/,
+ 0/*addMat<int, int>*/,
+ 0/*addMat<int, float>*/,
+ 0/*addMat<int, double>*/,
+ },
+ {
+ 0 /*addMat<float, unsigned char>*/,
+ 0 /*addMat<float, signed char>*/,
+ 0 /*addMat<float, unsigned short>*/,
+ 0 /*addMat<float, short>*/,
+ 0 /*addMat<float, int>*/,
+ addMat<float, float>,
+ 0/*addMat<float, double>*/,
+ },
+ {
+ 0 /*addMat<double, unsigned char>*/,
+ 0 /*addMat<double, signed char>*/,
+ 0 /*addMat<double, unsigned short>*/,
+ 0 /*addMat<double, short>*/,
+ 0 /*addMat<double, int>*/,
+ 0 /*addMat<double, float>*/,
+ 0/*addMat<double, double>*/,
+ }
+ };
+#else
static const func_t funcs[7][7] =
{
{
addMat<unsigned char, short>,
addMat<unsigned char, int>,
addMat<unsigned char, float>,
- addMat<unsigned char, double>
+ addMat<unsigned char, double>,
},
{
addMat<signed char, unsigned char>,
addMat<signed char, short>,
addMat<signed char, int>,
addMat<signed char, float>,
- addMat<signed char, double>
+ addMat<signed char, double>,
},
{
0 /*addMat<unsigned short, unsigned char>*/,
addMat<unsigned short, short>,
addMat<unsigned short, int>,
addMat<unsigned short, float>,
- addMat<unsigned short, double>
+ addMat<unsigned short, double>,
},
{
0 /*addMat<short, unsigned char>*/,
addMat<short, short>,
addMat<short, int>,
addMat<short, float>,
- addMat<short, double>
+ addMat<short, double>,
},
{
0 /*addMat<int, unsigned char>*/,
0 /*addMat<int, short>*/,
addMat<int, int>,
addMat<int, float>,
- addMat<int, double>
+ addMat<int, double>,
},
{
0 /*addMat<float, unsigned char>*/,
0 /*addMat<float, short>*/,
0 /*addMat<float, int>*/,
addMat<float, float>,
- addMat<float, double>
+ addMat<float, double>,
},
{
0 /*addMat<double, unsigned char>*/,
0 /*addMat<double, short>*/,
0 /*addMat<double, int>*/,
0 /*addMat<double, float>*/,
- addMat<double, double>
+ addMat<double, double>,
}
};
+#endif
if (dtype < 0)
dtype = src1.depth();
using namespace arithm;
typedef void (*func_t)(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[7][7] =
+ {
+ {
+ addScalar<unsigned char, float, unsigned char>,
+ 0/*addScalar<unsigned char, float, signed char>*/,
+ 0/*addScalar<unsigned char, float, unsigned short>*/,
+ 0/*addScalar<unsigned char, float, short>*/,
+ 0/*addScalar<unsigned char, float, int>*/,
+ 0/*addScalar<unsigned char, float, float>*/,
+ 0/*addScalar<unsigned char, double, double>*/,
+ },
+ {
+ 0/*addScalar<signed char, float, unsigned char>*/,
+ 0/*addScalar<signed char, float, signed char>*/,
+ 0/*addScalar<signed char, float, unsigned short>*/,
+ 0/*addScalar<signed char, float, short>*/,
+ 0/*addScalar<signed char, float, int>*/,
+ 0/*addScalar<signed char, float, float>*/,
+ 0/*addScalar<signed char, double, double>*/,
+ },
+ {
+ 0 /*addScalar<unsigned short, float, unsigned char>*/,
+ 0 /*addScalar<unsigned short, float, signed char>*/,
+ 0/*addScalar<unsigned short, float, unsigned short>*/,
+ 0/*addScalar<unsigned short, float, short>*/,
+ 0/*addScalar<unsigned short, float, int>*/,
+ 0/*addScalar<unsigned short, float, float>*/,
+ 0/*addScalar<unsigned short, double, double>*/,
+ },
+ {
+ 0 /*addScalar<short, float, unsigned char>*/,
+ 0 /*addScalar<short, float, signed char>*/,
+ 0/*addScalar<short, float, unsigned short>*/,
+ 0/*addScalar<short, float, short>*/,
+ 0/*addScalar<short, float, int>*/,
+ 0/*addScalar<short, float, float>*/,
+ 0/*addScalar<short, double, double>*/,
+ },
+ {
+ 0 /*addScalar<int, float, unsigned char>*/,
+ 0 /*addScalar<int, float, signed char>*/,
+ 0 /*addScalar<int, float, unsigned short>*/,
+ 0 /*addScalar<int, float, short>*/,
+ 0/*addScalar<int, float, int>*/,
+ 0/*addScalar<int, float, float>*/,
+ 0/*addScalar<int, double, double>*/,
+ },
+ {
+ 0 /*addScalar<float, float, unsigned char>*/,
+ 0 /*addScalar<float, float, signed char>*/,
+ 0 /*addScalar<float, float, unsigned short>*/,
+ 0 /*addScalar<float, float, short>*/,
+ 0 /*addScalar<float, float, int>*/,
+ addScalar<float, float, float>,
+ 0/*addScalar<float, double, double>*/,
+ },
+ {
+ 0 /*addScalar<double, double, unsigned char>*/,
+ 0 /*addScalar<double, double, signed char>*/,
+ 0 /*addScalar<double, double, unsigned short>*/,
+ 0 /*addScalar<double, double, short>*/,
+ 0 /*addScalar<double, double, int>*/,
+ 0 /*addScalar<double, double, float>*/,
+ 0/*addScalar<double, double, double>*/,
+ }
+ };
+#else
static const func_t funcs[7][7] =
{
{
addScalar<unsigned char, float, short>,
addScalar<unsigned char, float, int>,
addScalar<unsigned char, float, float>,
- addScalar<unsigned char, double, double>
+ addScalar<unsigned char, double, double>,
},
{
addScalar<signed char, float, unsigned char>,
addScalar<signed char, float, short>,
addScalar<signed char, float, int>,
addScalar<signed char, float, float>,
- addScalar<signed char, double, double>
+ addScalar<signed char, double, double>,
},
{
0 /*addScalar<unsigned short, float, unsigned char>*/,
addScalar<unsigned short, float, short>,
addScalar<unsigned short, float, int>,
addScalar<unsigned short, float, float>,
- addScalar<unsigned short, double, double>
+ addScalar<unsigned short, double, double>,
},
{
0 /*addScalar<short, float, unsigned char>*/,
addScalar<short, float, short>,
addScalar<short, float, int>,
addScalar<short, float, float>,
- addScalar<short, double, double>
+ addScalar<short, double, double>,
},
{
0 /*addScalar<int, float, unsigned char>*/,
0 /*addScalar<int, float, short>*/,
addScalar<int, float, int>,
addScalar<int, float, float>,
- addScalar<int, double, double>
+ addScalar<int, double, double>,
},
{
0 /*addScalar<float, float, unsigned char>*/,
0 /*addScalar<float, float, short>*/,
0 /*addScalar<float, float, int>*/,
addScalar<float, float, float>,
- addScalar<float, double, double>
+ addScalar<float, double, double>,
},
{
0 /*addScalar<double, double, unsigned char>*/,
0 /*addScalar<double, double, short>*/,
0 /*addScalar<double, double, int>*/,
0 /*addScalar<double, double, float>*/,
- addScalar<double, double, double>
+ addScalar<double, double, double>,
}
};
+#endif
typedef void (*npp_func_t)(const PtrStepSzb src, Scalar sc, PtrStepb dst, cudaStream_t stream);
static const npp_func_t npp_funcs[7][4] =
using namespace arithm;
typedef void (*func_t)(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[7][7] =
+ {
+ {
+ subMat<unsigned char, unsigned char>,
+ 0/*subMat<unsigned char, signed char>*/,
+ 0/*subMat<unsigned char, unsigned short>*/,
+ 0/*subMat<unsigned char, short>*/,
+ 0/*subMat<unsigned char, int>*/,
+ 0/*subMat<unsigned char, float>*/,
+ 0/*subMat<unsigned char, double>*/,
+ },
+ {
+ 0/*subMat<signed char, unsigned char>*/,
+ 0/*subMat<signed char, signed char>*/,
+ 0/*subMat<signed char, unsigned short>*/,
+ 0/*subMat<signed char, short>*/,
+ 0/*subMat<signed char, int>*/,
+ 0/*subMat<signed char, float>*/,
+ 0/*subMat<signed char, double>*/,
+ },
+ {
+ 0 /*subMat<unsigned short, unsigned char>*/,
+ 0 /*subMat<unsigned short, signed char>*/,
+ 0/*subMat<unsigned short, unsigned short>*/,
+ 0/*subMat<unsigned short, short>*/,
+ 0/*subMat<unsigned short, int>*/,
+ 0/*subMat<unsigned short, float>*/,
+ 0/*subMat<unsigned short, double>*/,
+ },
+ {
+ 0 /*subMat<short, unsigned char>*/,
+ 0 /*subMat<short, signed char>*/,
+ 0/*subMat<short, unsigned short>*/,
+ 0/*subMat<short, short>*/,
+ 0/*subMat<short, int>*/,
+ 0/*subMat<short, float>*/,
+ 0/*subMat<short, double>*/,
+ },
+ {
+ 0 /*subMat<int, unsigned char>*/,
+ 0 /*subMat<int, signed char>*/,
+ 0 /*subMat<int, unsigned short>*/,
+ 0 /*subMat<int, short>*/,
+ 0/*subMat<int, int>*/,
+ 0/*subMat<int, float>*/,
+ 0/*subMat<int, double>*/,
+ },
+ {
+ 0 /*subMat<float, unsigned char>*/,
+ 0 /*subMat<float, signed char>*/,
+ 0 /*subMat<float, unsigned short>*/,
+ 0 /*subMat<float, short>*/,
+ 0 /*subMat<float, int>*/,
+ subMat<float, float>,
+ 0/*subMat<float, double>*/,
+ },
+ {
+ 0 /*subMat<double, unsigned char>*/,
+ 0 /*subMat<double, signed char>*/,
+ 0 /*subMat<double, unsigned short>*/,
+ 0 /*subMat<double, short>*/,
+ 0 /*subMat<double, int>*/,
+ 0 /*subMat<double, float>*/,
+ 0/*subMat<double, double>*/,
+ }
+ };
+#else
static const func_t funcs[7][7] =
{
{
subMat<unsigned char, short>,
subMat<unsigned char, int>,
subMat<unsigned char, float>,
- subMat<unsigned char, double>
+ subMat<unsigned char, double>,
},
{
subMat<signed char, unsigned char>,
subMat<signed char, short>,
subMat<signed char, int>,
subMat<signed char, float>,
- subMat<signed char, double>
+ subMat<signed char, double>,
},
{
0 /*subMat<unsigned short, unsigned char>*/,
subMat<unsigned short, short>,
subMat<unsigned short, int>,
subMat<unsigned short, float>,
- subMat<unsigned short, double>
+ subMat<unsigned short, double>,
},
{
0 /*subMat<short, unsigned char>*/,
subMat<short, short>,
subMat<short, int>,
subMat<short, float>,
- subMat<short, double>
+ subMat<short, double>,
},
{
0 /*subMat<int, unsigned char>*/,
0 /*subMat<int, short>*/,
subMat<int, int>,
subMat<int, float>,
- subMat<int, double>
+ subMat<int, double>,
},
{
0 /*subMat<float, unsigned char>*/,
0 /*subMat<float, short>*/,
0 /*subMat<float, int>*/,
subMat<float, float>,
- subMat<float, double>
+ subMat<float, double>,
},
{
0 /*subMat<double, unsigned char>*/,
0 /*subMat<double, short>*/,
0 /*subMat<double, int>*/,
0 /*subMat<double, float>*/,
- subMat<double, double>
+ subMat<double, double>,
}
};
+#endif
if (dtype < 0)
dtype = src1.depth();
using namespace arithm;
typedef void (*func_t)(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[7][7] =
+ {
+ {
+ subScalar<unsigned char, float, unsigned char>,
+ 0/*subScalar<unsigned char, float, signed char>*/,
+ 0/*subScalar<unsigned char, float, unsigned short>*/,
+ 0/*subScalar<unsigned char, float, short>*/,
+ 0/*subScalar<unsigned char, float, int>*/,
+ 0/*subScalar<unsigned char, float, float>*/,
+ 0/*subScalar<unsigned char, double, double>*/,
+ },
+ {
+ 0/*subScalar<signed char, float, unsigned char>*/,
+ 0/*subScalar<signed char, float, signed char>*/,
+ 0/*subScalar<signed char, float, unsigned short>*/,
+ 0/*subScalar<signed char, float, short>*/,
+ 0/*subScalar<signed char, float, int>*/,
+ 0/*subScalar<signed char, float, float>*/,
+ 0/*subScalar<signed char, double, double>*/,
+ },
+ {
+ 0 /*subScalar<unsigned short, float, unsigned char>*/,
+ 0 /*subScalar<unsigned short, float, signed char>*/,
+ 0/*subScalar<unsigned short, float, unsigned short>*/,
+ 0/*subScalar<unsigned short, float, short>*/,
+ 0/*subScalar<unsigned short, float, int>*/,
+ 0/*subScalar<unsigned short, float, float>*/,
+ 0/*subScalar<unsigned short, double, double>*/,
+ },
+ {
+ 0 /*subScalar<short, float, unsigned char>*/,
+ 0 /*subScalar<short, float, signed char>*/,
+ 0/*subScalar<short, float, unsigned short>*/,
+ 0/*subScalar<short, float, short>*/,
+ 0/*subScalar<short, float, int>*/,
+ 0/*subScalar<short, float, float>*/,
+ 0/*subScalar<short, double, double>*/,
+ },
+ {
+ 0 /*subScalar<int, float, unsigned char>*/,
+ 0 /*subScalar<int, float, signed char>*/,
+ 0 /*subScalar<int, float, unsigned short>*/,
+ 0 /*subScalar<int, float, short>*/,
+ 0/*subScalar<int, float, int>*/,
+ 0/*subScalar<int, float, float>*/,
+ 0/*subScalar<int, double, double>*/,
+ },
+ {
+ 0 /*subScalar<float, float, unsigned char>*/,
+ 0 /*subScalar<float, float, signed char>*/,
+ 0 /*subScalar<float, float, unsigned short>*/,
+ 0 /*subScalar<float, float, short>*/,
+ 0 /*subScalar<float, float, int>*/,
+ subScalar<float, float, float>,
+ 0/*subScalar<float, double, double>*/,
+ },
+ {
+ 0 /*subScalar<double, double, unsigned char>*/,
+ 0 /*subScalar<double, double, signed char>*/,
+ 0 /*subScalar<double, double, unsigned short>*/,
+ 0 /*subScalar<double, double, short>*/,
+ 0 /*subScalar<double, double, int>*/,
+ 0 /*subScalar<double, double, float>*/,
+ 0/*subScalar<double, double, double>*/,
+ }
+ };
+#else
static const func_t funcs[7][7] =
{
{
subScalar<unsigned char, float, short>,
subScalar<unsigned char, float, int>,
subScalar<unsigned char, float, float>,
- subScalar<unsigned char, double, double>
+ subScalar<unsigned char, double, double>,
},
{
subScalar<signed char, float, unsigned char>,
subScalar<signed char, float, short>,
subScalar<signed char, float, int>,
subScalar<signed char, float, float>,
- subScalar<signed char, double, double>
+ subScalar<signed char, double, double>,
},
{
0 /*subScalar<unsigned short, float, unsigned char>*/,
subScalar<unsigned short, float, short>,
subScalar<unsigned short, float, int>,
subScalar<unsigned short, float, float>,
- subScalar<unsigned short, double, double>
+ subScalar<unsigned short, double, double>,
},
{
0 /*subScalar<short, float, unsigned char>*/,
subScalar<short, float, short>,
subScalar<short, float, int>,
subScalar<short, float, float>,
- subScalar<short, double, double>
+ subScalar<short, double, double>,
},
{
0 /*subScalar<int, float, unsigned char>*/,
0 /*subScalar<int, float, short>*/,
subScalar<int, float, int>,
subScalar<int, float, float>,
- subScalar<int, double, double>
+ subScalar<int, double, double>,
},
{
0 /*subScalar<float, float, unsigned char>*/,
0 /*subScalar<float, float, short>*/,
0 /*subScalar<float, float, int>*/,
subScalar<float, float, float>,
- subScalar<float, double, double>
+ subScalar<float, double, double>,
},
{
0 /*subScalar<double, double, unsigned char>*/,
0 /*subScalar<double, double, short>*/,
0 /*subScalar<double, double, int>*/,
0 /*subScalar<double, double, float>*/,
- subScalar<double, double, double>
+ subScalar<double, double, double>,
}
};
+#endif
typedef void (*npp_func_t)(const PtrStepSzb src, Scalar sc, PtrStepb dst, cudaStream_t stream);
static const npp_func_t npp_funcs[7][4] =
else
{
typedef void (*func_t)(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[7][7] =
+ {
+ {
+ mulMat<unsigned char, float, unsigned char>,
+ 0/*mulMat<unsigned char, float, signed char>*/,
+ 0/*mulMat<unsigned char, float, unsigned short>*/,
+ 0/*mulMat<unsigned char, float, short>*/,
+ 0/*mulMat<unsigned char, float, int>*/,
+ 0/*mulMat<unsigned char, float, float>*/,
+ 0/*mulMat<unsigned char, double, double>*/,
+ },
+ {
+ 0/*mulMat<signed char, float, unsigned char>*/,
+ 0/*mulMat<signed char, float, signed char>*/,
+ 0/*mulMat<signed char, float, unsigned short>*/,
+ 0/*mulMat<signed char, float, short>*/,
+ 0/*mulMat<signed char, float, int>*/,
+ 0/*mulMat<signed char, float, float>*/,
+ 0/*mulMat<signed char, double, double>*/,
+ },
+ {
+ 0 /*mulMat<unsigned short, float, unsigned char>*/,
+ 0 /*mulMat<unsigned short, float, signed char>*/,
+ 0/*mulMat<unsigned short, float, unsigned short>*/,
+ 0/*mulMat<unsigned short, float, short>*/,
+ 0/*mulMat<unsigned short, float, int>*/,
+ 0/*mulMat<unsigned short, float, float>*/,
+ 0/*mulMat<unsigned short, double, double>*/,
+ },
+ {
+ 0 /*mulMat<short, float, unsigned char>*/,
+ 0 /*mulMat<short, float, signed char>*/,
+ 0/*mulMat<short, float, unsigned short>*/,
+ 0/*mulMat<short, float, short>*/,
+ 0/*mulMat<short, float, int>*/,
+ 0/*mulMat<short, float, float>*/,
+ 0/*mulMat<short, double, double>*/,
+ },
+ {
+ 0 /*mulMat<int, float, unsigned char>*/,
+ 0 /*mulMat<int, float, signed char>*/,
+ 0 /*mulMat<int, float, unsigned short>*/,
+ 0 /*mulMat<int, float, short>*/,
+ 0/*mulMat<int, float, int>*/,
+ 0/*mulMat<int, float, float>*/,
+ 0/*mulMat<int, double, double>*/,
+ },
+ {
+ 0 /*mulMat<float, float, unsigned char>*/,
+ 0 /*mulMat<float, float, signed char>*/,
+ 0 /*mulMat<float, float, unsigned short>*/,
+ 0 /*mulMat<float, float, short>*/,
+ 0 /*mulMat<float, float, int>*/,
+ mulMat<float, float, float>,
+ 0/*mulMat<float, double, double>*/,
+ },
+ {
+ 0 /*mulMat<double, double, unsigned char>*/,
+ 0 /*mulMat<double, double, signed char>*/,
+ 0 /*mulMat<double, double, unsigned short>*/,
+ 0 /*mulMat<double, double, short>*/,
+ 0 /*mulMat<double, double, int>*/,
+ 0 /*mulMat<double, double, float>*/,
+ 0/*mulMat<double, double, double>*/,
+ }
+ };
+#else
static const func_t funcs[7][7] =
{
{
mulMat<unsigned char, float, short>,
mulMat<unsigned char, float, int>,
mulMat<unsigned char, float, float>,
- mulMat<unsigned char, double, double>
+ mulMat<unsigned char, double, double>,
},
{
mulMat<signed char, float, unsigned char>,
mulMat<signed char, float, short>,
mulMat<signed char, float, int>,
mulMat<signed char, float, float>,
- mulMat<signed char, double, double>
+ mulMat<signed char, double, double>,
},
{
0 /*mulMat<unsigned short, float, unsigned char>*/,
mulMat<unsigned short, float, short>,
mulMat<unsigned short, float, int>,
mulMat<unsigned short, float, float>,
- mulMat<unsigned short, double, double>
+ mulMat<unsigned short, double, double>,
},
{
0 /*mulMat<short, float, unsigned char>*/,
mulMat<short, float, short>,
mulMat<short, float, int>,
mulMat<short, float, float>,
- mulMat<short, double, double>
+ mulMat<short, double, double>,
},
{
0 /*mulMat<int, float, unsigned char>*/,
0 /*mulMat<int, float, short>*/,
mulMat<int, float, int>,
mulMat<int, float, float>,
- mulMat<int, double, double>
+ mulMat<int, double, double>,
},
{
0 /*mulMat<float, float, unsigned char>*/,
0 /*mulMat<float, float, short>*/,
0 /*mulMat<float, float, int>*/,
mulMat<float, float, float>,
- mulMat<float, double, double>
+ mulMat<float, double, double>,
},
{
0 /*mulMat<double, double, unsigned char>*/,
0 /*mulMat<double, double, short>*/,
0 /*mulMat<double, double, int>*/,
0 /*mulMat<double, double, float>*/,
- mulMat<double, double, double>
+ mulMat<double, double, double>,
}
};
+#endif
if (dtype < 0)
dtype = src1.depth();
using namespace arithm;
typedef void (*func_t)(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[7][7] =
+ {
+ {
+ mulScalar<unsigned char, float, unsigned char>,
+ 0/*mulScalar<unsigned char, float, signed char>*/,
+ 0/*mulScalar<unsigned char, float, unsigned short>*/,
+ 0/*mulScalar<unsigned char, float, short>*/,
+ 0/*mulScalar<unsigned char, float, int>*/,
+ 0/*mulScalar<unsigned char, float, float>*/,
+ 0/*mulScalar<unsigned char, double, double>*/,
+ },
+ {
+ 0/*mulScalar<signed char, float, unsigned char>*/,
+ 0/*mulScalar<signed char, float, signed char>*/,
+ 0/*mulScalar<signed char, float, unsigned short>*/,
+ 0/*mulScalar<signed char, float, short>*/,
+ 0/*mulScalar<signed char, float, int>*/,
+ 0/*mulScalar<signed char, float, float>*/,
+ 0/*mulScalar<signed char, double, double>*/,
+ },
+ {
+ 0 /*mulScalar<unsigned short, float, unsigned char>*/,
+ 0 /*mulScalar<unsigned short, float, signed char>*/,
+ 0/*mulScalar<unsigned short, float, unsigned short>*/,
+ 0/*mulScalar<unsigned short, float, short>*/,
+ 0/*mulScalar<unsigned short, float, int>*/,
+ 0/*mulScalar<unsigned short, float, float>*/,
+ 0/*mulScalar<unsigned short, double, double>*/,
+ },
+ {
+ 0 /*mulScalar<short, float, unsigned char>*/,
+ 0 /*mulScalar<short, float, signed char>*/,
+ 0/*mulScalar<short, float, unsigned short>*/,
+ 0/*mulScalar<short, float, short>*/,
+ 0/*mulScalar<short, float, int>*/,
+ 0/*mulScalar<short, float, float>*/,
+ 0/*mulScalar<short, double, double>*/,
+ },
+ {
+ 0 /*mulScalar<int, float, unsigned char>*/,
+ 0 /*mulScalar<int, float, signed char>*/,
+ 0 /*mulScalar<int, float, unsigned short>*/,
+ 0 /*mulScalar<int, float, short>*/,
+ 0/*mulScalar<int, float, int>*/,
+ 0/*mulScalar<int, float, float>*/,
+ 0/*mulScalar<int, double, double>*/,
+ },
+ {
+ 0 /*mulScalar<float, float, unsigned char>*/,
+ 0 /*mulScalar<float, float, signed char>*/,
+ 0 /*mulScalar<float, float, unsigned short>*/,
+ 0 /*mulScalar<float, float, short>*/,
+ 0 /*mulScalar<float, float, int>*/,
+ mulScalar<float, float, float>,
+ 0/*mulScalar<float, double, double>*/,
+ },
+ {
+ 0 /*mulScalar<double, double, unsigned char>*/,
+ 0 /*mulScalar<double, double, signed char>*/,
+ 0 /*mulScalar<double, double, unsigned short>*/,
+ 0 /*mulScalar<double, double, short>*/,
+ 0 /*mulScalar<double, double, int>*/,
+ 0 /*mulScalar<double, double, float>*/,
+ 0/*mulScalar<double, double, double>*/,
+ }
+ };
+#else
static const func_t funcs[7][7] =
{
{
mulScalar<unsigned char, float, short>,
mulScalar<unsigned char, float, int>,
mulScalar<unsigned char, float, float>,
- mulScalar<unsigned char, double, double>
+ mulScalar<unsigned char, double, double>,
},
{
mulScalar<signed char, float, unsigned char>,
mulScalar<signed char, float, short>,
mulScalar<signed char, float, int>,
mulScalar<signed char, float, float>,
- mulScalar<signed char, double, double>
+ mulScalar<signed char, double, double>,
},
{
0 /*mulScalar<unsigned short, float, unsigned char>*/,
mulScalar<unsigned short, float, short>,
mulScalar<unsigned short, float, int>,
mulScalar<unsigned short, float, float>,
- mulScalar<unsigned short, double, double>
+ mulScalar<unsigned short, double, double>,
},
{
0 /*mulScalar<short, float, unsigned char>*/,
mulScalar<short, float, short>,
mulScalar<short, float, int>,
mulScalar<short, float, float>,
- mulScalar<short, double, double>
+ mulScalar<short, double, double>,
},
{
0 /*mulScalar<int, float, unsigned char>*/,
0 /*mulScalar<int, float, short>*/,
mulScalar<int, float, int>,
mulScalar<int, float, float>,
- mulScalar<int, double, double>
+ mulScalar<int, double, double>,
},
{
0 /*mulScalar<float, float, unsigned char>*/,
0 /*mulScalar<float, float, short>*/,
0 /*mulScalar<float, float, int>*/,
mulScalar<float, float, float>,
- mulScalar<float, double, double>
+ mulScalar<float, double, double>,
},
{
0 /*mulScalar<double, double, unsigned char>*/,
0 /*mulScalar<double, double, short>*/,
0 /*mulScalar<double, double, int>*/,
0 /*mulScalar<double, double, float>*/,
- mulScalar<double, double, double>
+ mulScalar<double, double, double>,
}
};
+#endif
typedef void (*npp_func_t)(const PtrStepSzb src, Scalar sc, PtrStepb dst, cudaStream_t stream);
static const npp_func_t npp_funcs[7][4] =
else
{
typedef void (*func_t)(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[7][7] =
+ {
+ {
+ divMat<unsigned char, float, unsigned char>,
+ 0/*divMat<unsigned char, float, signed char>*/,
+ 0/*divMat<unsigned char, float, unsigned short>*/,
+ 0/*divMat<unsigned char, float, short>*/,
+ 0/*divMat<unsigned char, float, int>*/,
+ 0/*divMat<unsigned char, float, float>*/,
+ 0/*divMat<unsigned char, double, double>*/,
+ },
+ {
+ 0/*divMat<signed char, float, unsigned char>*/,
+ 0/*divMat<signed char, float, signed char>*/,
+ 0/*divMat<signed char, float, unsigned short>*/,
+ 0/*divMat<signed char, float, short>*/,
+ 0/*divMat<signed char, float, int>*/,
+ 0/*divMat<signed char, float, float>*/,
+ 0/*divMat<signed char, double, double>*/,
+ },
+ {
+ 0 /*divMat<unsigned short, float, unsigned char>*/,
+ 0 /*divMat<unsigned short, float, signed char>*/,
+ 0/*divMat<unsigned short, float, unsigned short>*/,
+ 0/*divMat<unsigned short, float, short>*/,
+ 0/*divMat<unsigned short, float, int>*/,
+ 0/*divMat<unsigned short, float, float>*/,
+ 0/*divMat<unsigned short, double, double>*/,
+ },
+ {
+ 0 /*divMat<short, float, unsigned char>*/,
+ 0 /*divMat<short, float, signed char>*/,
+ 0/*divMat<short, float, unsigned short>*/,
+ 0/*divMat<short, float, short>*/,
+ 0/*divMat<short, float, int>*/,
+ 0/*divMat<short, float, float>*/,
+ 0/*divMat<short, double, double>*/,
+ },
+ {
+ 0 /*divMat<int, float, unsigned char>*/,
+ 0 /*divMat<int, float, signed char>*/,
+ 0 /*divMat<int, float, unsigned short>*/,
+ 0 /*divMat<int, float, short>*/,
+ 0/*divMat<int, float, int>*/,
+ 0/*divMat<int, float, float>*/,
+ 0/*divMat<int, double, double>*/,
+ },
+ {
+ 0 /*divMat<float, float, unsigned char>*/,
+ 0 /*divMat<float, float, signed char>*/,
+ 0 /*divMat<float, float, unsigned short>*/,
+ 0 /*divMat<float, float, short>*/,
+ 0 /*divMat<float, float, int>*/,
+ divMat<float, float, float>,
+ 0/*divMat<float, double, double>*/,
+ },
+ {
+ 0 /*divMat<double, double, unsigned char>*/,
+ 0 /*divMat<double, double, signed char>*/,
+ 0 /*divMat<double, double, unsigned short>*/,
+ 0 /*divMat<double, double, short>*/,
+ 0 /*divMat<double, double, int>*/,
+ 0 /*divMat<double, double, float>*/,
+ 0/*divMat<double, double, double>*/,
+ }
+ };
+#else
static const func_t funcs[7][7] =
{
{
divMat<unsigned char, float, short>,
divMat<unsigned char, float, int>,
divMat<unsigned char, float, float>,
- divMat<unsigned char, double, double>
+ divMat<unsigned char, double, double>,
},
{
divMat<signed char, float, unsigned char>,
divMat<signed char, float, short>,
divMat<signed char, float, int>,
divMat<signed char, float, float>,
- divMat<signed char, double, double>
+ divMat<signed char, double, double>,
},
{
0 /*divMat<unsigned short, float, unsigned char>*/,
divMat<unsigned short, float, short>,
divMat<unsigned short, float, int>,
divMat<unsigned short, float, float>,
- divMat<unsigned short, double, double>
+ divMat<unsigned short, double, double>,
},
{
0 /*divMat<short, float, unsigned char>*/,
divMat<short, float, short>,
divMat<short, float, int>,
divMat<short, float, float>,
- divMat<short, double, double>
+ divMat<short, double, double>,
},
{
0 /*divMat<int, float, unsigned char>*/,
0 /*divMat<int, float, short>*/,
divMat<int, float, int>,
divMat<int, float, float>,
- divMat<int, double, double>
+ divMat<int, double, double>,
},
{
0 /*divMat<float, float, unsigned char>*/,
0 /*divMat<float, float, short>*/,
0 /*divMat<float, float, int>*/,
divMat<float, float, float>,
- divMat<float, double, double>
+ divMat<float, double, double>,
},
{
0 /*divMat<double, double, unsigned char>*/,
0 /*divMat<double, double, short>*/,
0 /*divMat<double, double, int>*/,
0 /*divMat<double, double, float>*/,
- divMat<double, double, double>
+ divMat<double, double, double>,
}
};
+#endif
if (dtype < 0)
dtype = src1.depth();
using namespace arithm;
typedef void (*func_t)(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[7][7] =
+ {
+ {
+ divScalar<unsigned char, float, unsigned char>,
+ 0/*divScalar<unsigned char, float, signed char>*/,
+ 0/*divScalar<unsigned char, float, unsigned short>*/,
+ 0/*divScalar<unsigned char, float, short>*/,
+ 0/*divScalar<unsigned char, float, int>*/,
+ 0/*divScalar<unsigned char, float, float>*/,
+ 0/*divScalar<unsigned char, double, double>*/,
+ },
+ {
+ 0/*divScalar<signed char, float, unsigned char>*/,
+ 0/*divScalar<signed char, float, signed char>*/,
+ 0/*divScalar<signed char, float, unsigned short>*/,
+ 0/*divScalar<signed char, float, short>*/,
+ 0/*divScalar<signed char, float, int>*/,
+ 0/*divScalar<signed char, float, float>*/,
+ 0/*divScalar<signed char, double, double>*/,
+ },
+ {
+ 0 /*divScalar<unsigned short, float, unsigned char>*/,
+ 0 /*divScalar<unsigned short, float, signed char>*/,
+ 0/*divScalar<unsigned short, float, unsigned short>*/,
+ 0/*divScalar<unsigned short, float, short>*/,
+ 0/*divScalar<unsigned short, float, int>*/,
+ 0/*divScalar<unsigned short, float, float>*/,
+ 0/*divScalar<unsigned short, double, double>*/,
+ },
+ {
+ 0 /*divScalar<short, float, unsigned char>*/,
+ 0 /*divScalar<short, float, signed char>*/,
+ 0/*divScalar<short, float, unsigned short>*/,
+ 0/*divScalar<short, float, short>*/,
+ 0/*divScalar<short, float, int>*/,
+ 0/*divScalar<short, float, float>*/,
+ 0/*divScalar<short, double, double>*/,
+ },
+ {
+ 0 /*divScalar<int, float, unsigned char>*/,
+ 0 /*divScalar<int, float, signed char>*/,
+ 0 /*divScalar<int, float, unsigned short>*/,
+ 0 /*divScalar<int, float, short>*/,
+ 0/*divScalar<int, float, int>*/,
+ 0/*divScalar<int, float, float>*/,
+ 0/*divScalar<int, double, double>*/,
+ },
+ {
+ 0 /*divScalar<float, float, unsigned char>*/,
+ 0 /*divScalar<float, float, signed char>*/,
+ 0 /*divScalar<float, float, unsigned short>*/,
+ 0 /*divScalar<float, float, short>*/,
+ 0 /*divScalar<float, float, int>*/,
+ divScalar<float, float, float>,
+ 0/*divScalar<float, double, double>*/,
+ },
+ {
+ 0 /*divScalar<double, double, unsigned char>*/,
+ 0 /*divScalar<double, double, signed char>*/,
+ 0 /*divScalar<double, double, unsigned short>*/,
+ 0 /*divScalar<double, double, short>*/,
+ 0 /*divScalar<double, double, int>*/,
+ 0 /*divScalar<double, double, float>*/,
+ 0/*divScalar<double, double, double>*/,
+ }
+ };
+#else
static const func_t funcs[7][7] =
{
{
divScalar<unsigned char, float, short>,
divScalar<unsigned char, float, int>,
divScalar<unsigned char, float, float>,
- divScalar<unsigned char, double, double>
+ divScalar<unsigned char, double, double>,
},
{
divScalar<signed char, float, unsigned char>,
divScalar<signed char, float, short>,
divScalar<signed char, float, int>,
divScalar<signed char, float, float>,
- divScalar<signed char, double, double>
+ divScalar<signed char, double, double>,
},
{
0 /*divScalar<unsigned short, float, unsigned char>*/,
divScalar<unsigned short, float, short>,
divScalar<unsigned short, float, int>,
divScalar<unsigned short, float, float>,
- divScalar<unsigned short, double, double>
+ divScalar<unsigned short, double, double>,
},
{
0 /*divScalar<short, float, unsigned char>*/,
divScalar<short, float, short>,
divScalar<short, float, int>,
divScalar<short, float, float>,
- divScalar<short, double, double>
+ divScalar<short, double, double>,
},
{
0 /*divScalar<int, float, unsigned char>*/,
0 /*divScalar<int, float, short>*/,
divScalar<int, float, int>,
divScalar<int, float, float>,
- divScalar<int, double, double>
+ divScalar<int, double, double>,
},
{
0 /*divScalar<float, float, unsigned char>*/,
0 /*divScalar<float, float, short>*/,
0 /*divScalar<float, float, int>*/,
divScalar<float, float, float>,
- divScalar<float, double, double>
+ divScalar<float, double, double>,
},
{
0 /*divScalar<double, double, unsigned char>*/,
0 /*divScalar<double, double, short>*/,
0 /*divScalar<double, double, int>*/,
0 /*divScalar<double, double, float>*/,
- divScalar<double, double, double>
+ divScalar<double, double, double>,
}
};
+#endif
typedef void (*npp_func_t)(const PtrStepSzb src, Scalar sc, PtrStepb dst, cudaStream_t stream);
static const npp_func_t npp_funcs[7][4] =
using namespace arithm;
typedef void (*func_t)(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[7][7] =
+ {
+ {
+ divInv<unsigned char, float, unsigned char>,
+ 0/*divInv<unsigned char, float, signed char>*/,
+ 0/*divInv<unsigned char, float, unsigned short>*/,
+ 0/*divInv<unsigned char, float, short>*/,
+ 0/*divInv<unsigned char, float, int>*/,
+ 0/*divInv<unsigned char, float, float>*/,
+ 0/*divInv<unsigned char, double, double>*/,
+ },
+ {
+ 0/*divInv<signed char, float, unsigned char>*/,
+ 0/*divInv<signed char, float, signed char>*/,
+ 0/*divInv<signed char, float, unsigned short>*/,
+ 0/*divInv<signed char, float, short>*/,
+ 0/*divInv<signed char, float, int>*/,
+ 0/*divInv<signed char, float, float>*/,
+ 0/*divInv<signed char, double, double>*/,
+ },
+ {
+ 0 /*divInv<unsigned short, float, unsigned char>*/,
+ 0 /*divInv<unsigned short, float, signed char>*/,
+ 0/*divInv<unsigned short, float, unsigned short>*/,
+ 0/*divInv<unsigned short, float, short>*/,
+ 0/*divInv<unsigned short, float, int>*/,
+ 0/*divInv<unsigned short, float, float>*/,
+ 0/*divInv<unsigned short, double, double>*/,
+ },
+ {
+ 0 /*divInv<short, float, unsigned char>*/,
+ 0 /*divInv<short, float, signed char>*/,
+ 0/*divInv<short, float, unsigned short>*/,
+ 0/*divInv<short, float, short>*/,
+ 0/*divInv<short, float, int>*/,
+ 0/*divInv<short, float, float>*/,
+ 0/*divInv<short, double, double>*/,
+ },
+ {
+ 0 /*divInv<int, float, unsigned char>*/,
+ 0 /*divInv<int, float, signed char>*/,
+ 0 /*divInv<int, float, unsigned short>*/,
+ 0 /*divInv<int, float, short>*/,
+ 0/*divInv<int, float, int>*/,
+ 0/*divInv<int, float, float>*/,
+ 0/*divInv<int, double, double>*/,
+ },
+ {
+ 0 /*divInv<float, float, unsigned char>*/,
+ 0 /*divInv<float, float, signed char>*/,
+ 0 /*divInv<float, float, unsigned short>*/,
+ 0 /*divInv<float, float, short>*/,
+ 0 /*divInv<float, float, int>*/,
+ divInv<float, float, float>,
+ 0/*divInv<float, double, double>*/,
+ },
+ {
+ 0 /*divInv<double, double, unsigned char>*/,
+ 0 /*divInv<double, double, signed char>*/,
+ 0 /*divInv<double, double, unsigned short>*/,
+ 0 /*divInv<double, double, short>*/,
+ 0 /*divInv<double, double, int>*/,
+ 0 /*divInv<double, double, float>*/,
+ 0/*divInv<double, double, double>*/,
+ }
+ };
+#else
static const func_t funcs[7][7] =
{
{
divInv<unsigned char, float, short>,
divInv<unsigned char, float, int>,
divInv<unsigned char, float, float>,
- divInv<unsigned char, double, double>
+ divInv<unsigned char, double, double>,
},
{
divInv<signed char, float, unsigned char>,
divInv<signed char, float, short>,
divInv<signed char, float, int>,
divInv<signed char, float, float>,
- divInv<signed char, double, double>
+ divInv<signed char, double, double>,
},
{
0 /*divInv<unsigned short, float, unsigned char>*/,
divInv<unsigned short, float, short>,
divInv<unsigned short, float, int>,
divInv<unsigned short, float, float>,
- divInv<unsigned short, double, double>
+ divInv<unsigned short, double, double>,
},
{
0 /*divInv<short, float, unsigned char>*/,
divInv<short, float, short>,
divInv<short, float, int>,
divInv<short, float, float>,
- divInv<short, double, double>
+ divInv<short, double, double>,
},
{
0 /*divInv<int, float, unsigned char>*/,
0 /*divInv<int, float, short>*/,
divInv<int, float, int>,
divInv<int, float, float>,
- divInv<int, double, double>
+ divInv<int, double, double>,
},
{
0 /*divInv<float, float, unsigned char>*/,
0 /*divInv<float, float, short>*/,
0 /*divInv<float, float, int>*/,
divInv<float, float, float>,
- divInv<float, double, double>
+ divInv<float, double, double>,
},
{
0 /*divInv<double, double, unsigned char>*/,
0 /*divInv<double, double, short>*/,
0 /*divInv<double, double, int>*/,
0 /*divInv<double, double, float>*/,
- divInv<double, double, double>
+ divInv<double, double, double>,
}
};
+#endif
if (dtype < 0)
dtype = src.depth();
using namespace arithm;
typedef void (*func_t)(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[] =
+ {
+ absDiffMat<unsigned char>,
+ 0/*absDiffMat<signed char>*/,
+ 0/*absDiffMat<unsigned short>*/,
+ 0/*absDiffMat<short>*/,
+ 0/*absDiffMat<int>*/,
+ absDiffMat<float>,
+ 0/*absDiffMat<double>*/,
+ };
+#else
static const func_t funcs[] =
{
absDiffMat<unsigned char>,
absDiffMat<short>,
absDiffMat<int>,
absDiffMat<float>,
- absDiffMat<double>
+ absDiffMat<double>,
};
+#endif
const int depth = src1.depth();
const int cn = src1.channels();
using namespace arithm;
typedef void (*func_t)(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[] =
+ {
+ absDiffScalar<unsigned char, float>,
+ 0/*absDiffScalar<signed char, float>*/,
+ 0/*absDiffScalar<unsigned short, float>*/,
+ 0/*absDiffScalar<short, float>*/,
+ 0/*absDiffScalar<int, float>*/,
+ absDiffScalar<float, float>,
+ 0/*absDiffScalar<double, double>*/,
+ };
+#else
static const func_t funcs[] =
{
absDiffScalar<unsigned char, float>,
absDiffScalar<short, float>,
absDiffScalar<int, float>,
absDiffScalar<float, float>,
- absDiffScalar<double, double>
+ absDiffScalar<double, double>,
};
+#endif
const int depth = src1.depth();
CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
}
+ const func_t func = funcs[depth];
+ if (!func)
+ CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
+
dst.create(src1.size(), src1.type());
- funcs[depth](src1, src2.val[0], dst, StreamAccessor::getStream(stream));
+ func(src1, src2.val[0], dst, StreamAccessor::getStream(stream));
}
//////////////////////////////////////////////////////////////////////////////
using namespace arithm;
typedef void (*func_t)(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[] =
+ {
+ 0/*absMat<unsigned char>*/,
+ 0/*absMat<signed char>*/,
+ 0/*absMat<unsigned short>*/,
+ 0/*absMat<short>*/,
+ 0/*absMat<int>*/,
+ absMat<float>,
+ 0/*absMat<double>*/,
+ };
+#else
static const func_t funcs[] =
{
absMat<unsigned char>,
absMat<short>,
absMat<int>,
absMat<float>,
- absMat<double>
+ absMat<double>,
};
+#endif
const int depth = src.depth();
CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
}
+ const func_t func = funcs[depth];
+ if (!func)
+ CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
+
dst.create(src.size(), src.type());
- funcs[depth](src, dst, StreamAccessor::getStream(stream));
+ func(src, dst, StreamAccessor::getStream(stream));
}
//////////////////////////////////////////////////////////////////////////////
using namespace arithm;
typedef void (*func_t)(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[] =
+ {
+ 0/*sqrMat<unsigned char>*/,
+ 0/*sqrMat<signed char>*/,
+ 0/*sqrMat<unsigned short>*/,
+ 0/*sqrMat<short>*/,
+ 0/*sqrMat<int>*/,
+ sqrMat<float>,
+ 0/*sqrMat<double>*/,
+ };
+#else
static const func_t funcs[] =
{
sqrMat<unsigned char>,
sqrMat<short>,
sqrMat<int>,
sqrMat<float>,
- sqrMat<double>
+ sqrMat<double>,
};
+#endif
const int depth = src.depth();
CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
}
+ const func_t func = funcs[depth];
+ if (!func)
+ CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
+
dst.create(src.size(), src.type());
- funcs[depth](src, dst, StreamAccessor::getStream(stream));
+ func(src, dst, StreamAccessor::getStream(stream));
}
//////////////////////////////////////////////////////////////////////////////
using namespace arithm;
typedef void (*func_t)(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[] =
+ {
+ 0/*sqrtMat<unsigned char>*/,
+ 0/*sqrtMat<signed char>*/,
+ 0/*sqrtMat<unsigned short>*/,
+ 0/*sqrtMat<short>*/,
+ 0/*sqrtMat<int>*/,
+ sqrtMat<float>,
+ 0/*sqrtMat<double>*/,
+ };
+#else
static const func_t funcs[] =
{
sqrtMat<unsigned char>,
sqrtMat<short>,
sqrtMat<int>,
sqrtMat<float>,
- sqrtMat<double>
+ sqrtMat<double>,
};
+#endif
const int depth = src.depth();
CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
}
+ const func_t func = funcs[depth];
+ if (!func)
+ CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
+
dst.create(src.size(), src.type());
- funcs[depth](src, dst, StreamAccessor::getStream(stream));
+ func(src, dst, StreamAccessor::getStream(stream));
}
////////////////////////////////////////////////////////////////////////
using namespace arithm;
typedef void (*func_t)(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[] =
+ {
+ 0/*logMat<unsigned char>*/,
+ 0/*logMat<signed char>*/,
+ 0/*logMat<unsigned short>*/,
+ 0/*logMat<short>*/,
+ 0/*logMat<int>*/,
+ logMat<float>,
+ 0/*logMat<double>*/,
+ };
+#else
static const func_t funcs[] =
{
logMat<unsigned char>,
logMat<short>,
logMat<int>,
logMat<float>,
- logMat<double>
+ logMat<double>,
};
+#endif
const int depth = src.depth();
CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
}
+ const func_t func = funcs[depth];
+ if (!func)
+ CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
+
dst.create(src.size(), src.type());
- funcs[depth](src, dst, StreamAccessor::getStream(stream));
+ func(src, dst, StreamAccessor::getStream(stream));
}
////////////////////////////////////////////////////////////////////////
using namespace arithm;
typedef void (*func_t)(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[] =
+ {
+ 0/*expMat<unsigned char>*/,
+ 0/*expMat<signed char>*/,
+ 0/*expMat<unsigned short>*/,
+ 0/*expMat<short>*/,
+ 0/*expMat<int>*/,
+ expMat<float>,
+ 0/*expMat<double>*/,
+ };
+#else
static const func_t funcs[] =
{
expMat<unsigned char>,
expMat<short>,
expMat<int>,
expMat<float>,
- expMat<double>
+ expMat<double>,
};
+#endif
const int depth = src.depth();
CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
}
+ const func_t func = funcs[depth];
+ if (!func)
+ CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
+
dst.create(src.size(), src.type());
- funcs[depth](src, dst, StreamAccessor::getStream(stream));
+ func(src, dst, StreamAccessor::getStream(stream));
}
//////////////////////////////////////////////////////////////////////////////
using namespace arithm;
typedef void (*func_t)(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[7][4] =
+ {
+ {cmpMatEq<unsigned char> , cmpMatNe<unsigned char> , cmpMatLt<unsigned char> , cmpMatLe<unsigned char> },
+ {0, 0, 0, 0},
+ {0, 0, 0, 0},
+ {0, 0, 0, 0},
+ {0, 0, 0, 0},
+ {cmpMatEq<float> , cmpMatNe<float> , cmpMatLt<float> , cmpMatLe<float> },
+ {0, 0, 0, 0},
+ };
+#else
static const func_t funcs[7][4] =
{
{cmpMatEq<unsigned char> , cmpMatNe<unsigned char> , cmpMatLt<unsigned char> , cmpMatLe<unsigned char> },
{cmpMatEq<float> , cmpMatNe<float> , cmpMatLt<float> , cmpMatLe<float> },
{cmpMatEq<double> , cmpMatNe<double> , cmpMatLt<double> , cmpMatLe<double> }
};
+#endif
typedef void (*func_v4_t)(PtrStepSz<unsigned int> src1, PtrStepSz<unsigned int> src2, PtrStepSz<unsigned int> dst, cudaStream_t stream);
static const func_v4_t funcs_v4[] =
CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
}
- dst.create(src1.size(), CV_MAKE_TYPE(CV_8U, cn));
-
- cudaStream_t stream = StreamAccessor::getStream(s);
-
static const int codes[] =
{
0, 2, 3, 2, 3, 1
};
const int code = codes[cmpop];
+
+ const func_t func = funcs[depth][code];
+ if (!func)
+ CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
+
+ dst.create(src1.size(), CV_MAKE_TYPE(CV_8U, cn));
+
+ cudaStream_t stream = StreamAccessor::getStream(s);
+
PtrStepSzb src1_(src1.rows, src1.cols * cn, psrc1[cmpop]->data, psrc1[cmpop]->step);
PtrStepSzb src2_(src1.rows, src1.cols * cn, psrc2[cmpop]->data, psrc2[cmpop]->step);
PtrStepSzb dst_(src1.rows, src1.cols * cn, dst.data, dst.step);
}
}
- const func_t func = funcs[depth][code];
-
func(src1_, src2_, dst_, stream);
}
using namespace arithm;
typedef void (*func_t)(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+ typedef void (*cast_func_t)(Scalar& sc);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[7][6] =
+ {
+ {cmpScalarEq<unsigned char> , cmpScalarGt<unsigned char> , cmpScalarGe<unsigned char> , cmpScalarLt<unsigned char> , cmpScalarLe<unsigned char> , cmpScalarNe<unsigned char> },
+ {0, 0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0, 0},
+ {cmpScalarEq<float> , cmpScalarGt<float> , cmpScalarGe<float> , cmpScalarLt<float> , cmpScalarLe<float> , cmpScalarNe<float> },
+ {0, 0, 0, 0, 0, 0},
+ };
+
+ static const cast_func_t cast_func[] =
+ {
+ castScalar<unsigned char>,
+ 0/*castScalar<signed char>*/,
+ 0/*castScalar<unsigned short>*/,
+ 0/*castScalar<short>*/,
+ 0/*castScalar<int>*/,
+ castScalar<float>,
+ 0/*castScalar<double>*/,
+ };
+#else
static const func_t funcs[7][6] =
{
{cmpScalarEq<unsigned char> , cmpScalarGt<unsigned char> , cmpScalarGe<unsigned char> , cmpScalarLt<unsigned char> , cmpScalarLe<unsigned char> , cmpScalarNe<unsigned char> },
{cmpScalarEq<double> , cmpScalarGt<double> , cmpScalarGe<double> , cmpScalarLt<double> , cmpScalarLe<double> , cmpScalarNe<double> }
};
- typedef void (*cast_func_t)(Scalar& sc);
static const cast_func_t cast_func[] =
{
castScalar<unsigned char>, castScalar<signed char>, castScalar<unsigned short>, castScalar<short>, castScalar<int>, castScalar<float>, castScalar<double>
};
+#endif
const int depth = src.depth();
const int cn = src.channels();
CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
}
+ const func_t func = funcs[depth][cmpop];
+ if (!func)
+ CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
+
dst.create(src.size(), CV_MAKE_TYPE(CV_8U, cn));
cast_func[depth](sc);
- funcs[depth][cmpop](src, cn, sc.val, dst, StreamAccessor::getStream(stream));
+ func(src, cn, sc.val, dst, StreamAccessor::getStream(stream));
}
//////////////////////////////////////////////////////////////////////////////
using namespace arithm;
typedef void (*func_t)(const GpuMat& src, Scalar sc, GpuMat& dst, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[5][4] =
+ {
+ {
+ BitScalar<unsigned char, bitScalarAnd<unsigned char> >::call,
+ 0,
+ 0/*NppBitwiseC<CV_8U , 3, nppiAndC_8u_C3R >::call*/,
+ 0/*NppBitwiseC<CV_8U , 4, nppiAndC_8u_C4R >::call*/,
+ },
+ {0,0,0,0},
+ {
+ 0/*BitScalar<unsigned short, bitScalarAnd<unsigned short> >::call*/,
+ 0,
+ 0/*NppBitwiseC<CV_16U, 3, nppiAndC_16u_C3R>::call*/,
+ 0/*NppBitwiseC<CV_16U, 4, nppiAndC_16u_C4R>::call*/,
+ },
+ {0,0,0,0},
+ {
+ 0/*BitScalar<int, bitScalarAnd<int> >::call*/,
+ 0,
+ 0/*NppBitwiseC<CV_32S, 3, nppiAndC_32s_C3R>::call*/,
+ 0/*NppBitwiseC<CV_32S, 4, nppiAndC_32s_C4R>::call*/,
+ }
+ };
+#else
static const func_t funcs[5][4] =
{
- {BitScalar<unsigned char, bitScalarAnd<unsigned char> >::call , 0, NppBitwiseC<CV_8U , 3, nppiAndC_8u_C3R >::call, BitScalar4< bitScalarAnd<unsigned int> >::call},
+ {
+ BitScalar<unsigned char, bitScalarAnd<unsigned char> >::call,
+ 0,
+ NppBitwiseC<CV_8U , 3, nppiAndC_8u_C3R >::call,
+ BitScalar4< bitScalarAnd<unsigned int> >::call
+ },
{0,0,0,0},
- {BitScalar<unsigned short, bitScalarAnd<unsigned short> >::call, 0, NppBitwiseC<CV_16U, 3, nppiAndC_16u_C3R>::call, NppBitwiseC<CV_16U, 4, nppiAndC_16u_C4R>::call},
+ {
+ BitScalar<unsigned short, bitScalarAnd<unsigned short> >::call,
+ 0,
+ NppBitwiseC<CV_16U, 3, nppiAndC_16u_C3R>::call,
+ NppBitwiseC<CV_16U, 4, nppiAndC_16u_C4R>::call
+ },
{0,0,0,0},
- {BitScalar<int, bitScalarAnd<int> >::call , 0, NppBitwiseC<CV_32S, 3, nppiAndC_32s_C3R>::call, NppBitwiseC<CV_32S, 4, nppiAndC_32s_C4R>::call}
+ {
+ BitScalar<int, bitScalarAnd<int> >::call,
+ 0,
+ NppBitwiseC<CV_32S, 3, nppiAndC_32s_C3R>::call,
+ NppBitwiseC<CV_32S, 4, nppiAndC_32s_C4R>::call
+ }
};
+#endif
const int depth = src.depth();
const int cn = src.channels();
CV_Assert( depth == CV_8U || depth == CV_16U || depth == CV_32S );
CV_Assert( cn == 1 || cn == 3 || cn == 4 );
+ const func_t func = funcs[depth][cn - 1];
+ if (!func)
+ CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
+
dst.create(src.size(), src.type());
- funcs[depth][cn - 1](src, sc, dst, StreamAccessor::getStream(stream));
+ func(src, sc, dst, StreamAccessor::getStream(stream));
}
void cv::gpu::bitwise_or(const GpuMat& src, const Scalar& sc, GpuMat& dst, Stream& stream)
using namespace arithm;
typedef void (*func_t)(const GpuMat& src, Scalar sc, GpuMat& dst, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[5][4] =
+ {
+ {
+ BitScalar<unsigned char, bitScalarOr<unsigned char> >::call,
+ 0,
+ 0/*NppBitwiseC<CV_8U , 3, nppiOrC_8u_C3R >::call*/,
+ 0/*NppBitwiseC<CV_8U , 4, nppiOrC_8u_C4R >::call*/,
+ },
+ {0,0,0,0},
+ {
+ 0/*BitScalar<unsigned short, bitScalarOr<unsigned short> >::call*/,
+ 0,
+ 0/*NppBitwiseC<CV_16U, 3, nppiOrC_16u_C3R>::call*/,
+ 0/*NppBitwiseC<CV_16U, 4, nppiOrC_16u_C4R>::call*/,
+ },
+ {0,0,0,0},
+ {
+ 0/*BitScalar<int, bitScalarOr<int> >::call*/,
+ 0,
+ 0/*NppBitwiseC<CV_32S, 3, nppiOrC_32s_C3R>::call*/,
+ 0/*NppBitwiseC<CV_32S, 4, nppiOrC_32s_C4R>::call*/,
+ }
+ };
+#else
static const func_t funcs[5][4] =
{
- {BitScalar<unsigned char, bitScalarOr<unsigned char> >::call , 0, NppBitwiseC<CV_8U , 3, nppiOrC_8u_C3R >::call, BitScalar4< bitScalarOr<unsigned int> >::call},
+ {
+ BitScalar<unsigned char, bitScalarOr<unsigned char> >::call,
+ 0,
+ NppBitwiseC<CV_8U , 3, nppiOrC_8u_C3R >::call,
+ BitScalar4< bitScalarOr<unsigned int> >::call
+ },
{0,0,0,0},
- {BitScalar<unsigned short, bitScalarOr<unsigned short> >::call, 0, NppBitwiseC<CV_16U, 3, nppiOrC_16u_C3R>::call, NppBitwiseC<CV_16U, 4, nppiOrC_16u_C4R>::call},
+ {
+ BitScalar<unsigned short, bitScalarOr<unsigned short> >::call,
+ 0,
+ NppBitwiseC<CV_16U, 3, nppiOrC_16u_C3R>::call,
+ NppBitwiseC<CV_16U, 4, nppiOrC_16u_C4R>::call
+ },
{0,0,0,0},
- {BitScalar<int, bitScalarOr<int> >::call , 0, NppBitwiseC<CV_32S, 3, nppiOrC_32s_C3R>::call, NppBitwiseC<CV_32S, 4, nppiOrC_32s_C4R>::call}
+ {
+ BitScalar<int, bitScalarOr<int> >::call,
+ 0,
+ NppBitwiseC<CV_32S, 3, nppiOrC_32s_C3R>::call,
+ NppBitwiseC<CV_32S, 4, nppiOrC_32s_C4R>::call
+ }
};
+#endif
const int depth = src.depth();
const int cn = src.channels();
CV_Assert( depth == CV_8U || depth == CV_16U || depth == CV_32S );
CV_Assert( cn == 1 || cn == 3 || cn == 4 );
+ const func_t func = funcs[depth][cn - 1];
+ if (!func)
+ CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
+
dst.create(src.size(), src.type());
- funcs[depth][cn - 1](src, sc, dst, StreamAccessor::getStream(stream));
+ func(src, sc, dst, StreamAccessor::getStream(stream));
}
void cv::gpu::bitwise_xor(const GpuMat& src, const Scalar& sc, GpuMat& dst, Stream& stream)
using namespace arithm;
typedef void (*func_t)(const GpuMat& src, Scalar sc, GpuMat& dst, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[5][4] =
+ {
+ {
+ BitScalar<unsigned char, bitScalarXor<unsigned char> >::call,
+ 0,
+ 0/*NppBitwiseC<CV_8U , 3, nppiXorC_8u_C3R >::call*/,
+ 0/*NppBitwiseC<CV_8U , 4, nppiXorC_8u_C4R >::call*/,
+ },
+ {0,0,0,0},
+ {
+ 0/*BitScalar<unsigned short, bitScalarXor<unsigned short> >::call*/,
+ 0,
+ 0/*NppBitwiseC<CV_16U, 3, nppiXorC_16u_C3R>::call*/,
+ 0/*NppBitwiseC<CV_16U, 4, nppiXorC_16u_C4R>::call*/,
+ },
+ {0,0,0,0},
+ {
+ 0/*BitScalar<int, bitScalarXor<int> >::call*/,
+ 0,
+ 0/*NppBitwiseC<CV_32S, 3, nppiXorC_32s_C3R>::call*/,
+ 0/*NppBitwiseC<CV_32S, 4, nppiXorC_32s_C4R>::call*/,
+ }
+ };
+#else
static const func_t funcs[5][4] =
{
- {BitScalar<unsigned char, bitScalarXor<unsigned char> >::call , 0, NppBitwiseC<CV_8U , 3, nppiXorC_8u_C3R >::call, BitScalar4< bitScalarXor<unsigned int> >::call},
+ {
+ BitScalar<unsigned char, bitScalarXor<unsigned char> >::call,
+ 0,
+ NppBitwiseC<CV_8U , 3, nppiXorC_8u_C3R >::call,
+ BitScalar4< bitScalarXor<unsigned int> >::call
+ },
{0,0,0,0},
- {BitScalar<unsigned short, bitScalarXor<unsigned short> >::call, 0, NppBitwiseC<CV_16U, 3, nppiXorC_16u_C3R>::call, NppBitwiseC<CV_16U, 4, nppiXorC_16u_C4R>::call},
+ {
+ BitScalar<unsigned short, bitScalarXor<unsigned short> >::call,
+ 0,
+ NppBitwiseC<CV_16U, 3, nppiXorC_16u_C3R>::call,
+ NppBitwiseC<CV_16U, 4, nppiXorC_16u_C4R>::call
+ },
{0,0,0,0},
- {BitScalar<int, bitScalarXor<int> >::call , 0, NppBitwiseC<CV_32S, 3, nppiXorC_32s_C3R>::call, NppBitwiseC<CV_32S, 4, nppiXorC_32s_C4R>::call}
+ {
+ BitScalar<int, bitScalarXor<int> >::call,
+ 0,
+ NppBitwiseC<CV_32S, 3, nppiXorC_32s_C3R>::call,
+ NppBitwiseC<CV_32S, 4, nppiXorC_32s_C4R>::call
+ }
};
+#endif
const int depth = src.depth();
const int cn = src.channels();
CV_Assert( depth == CV_8U || depth == CV_16U || depth == CV_32S );
CV_Assert( cn == 1 || cn == 3 || cn == 4 );
+ const func_t func = funcs[depth][cn - 1];
+ if (!func)
+ CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
+
dst.create(src.size(), src.type());
- funcs[depth][cn - 1](src, sc, dst, StreamAccessor::getStream(stream));
+ func(src, sc, dst, StreamAccessor::getStream(stream));
}
//////////////////////////////////////////////////////////////////////////////
using namespace arithm;
typedef void (*func_t)(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[] =
+ {
+ minMat<unsigned char>,
+ 0/*minMat<signed char>*/,
+ 0/*minMat<unsigned short>*/,
+ 0/*minMat<short>*/,
+ 0/*minMat<int>*/,
+ minMat<float>,
+ 0/*minMat<double>*/,
+ };
+#else
static const func_t funcs[] =
{
minMat<unsigned char>,
minMat<short>,
minMat<int>,
minMat<float>,
- minMat<double>
+ minMat<double>,
};
+#endif
const int depth = src1.depth();
const int cn = src1.channels();
using namespace arithm;
typedef void (*func_t)(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[] =
+ {
+ maxMat<unsigned char>,
+ 0/*maxMat<signed char>*/,
+ 0/*maxMat<unsigned short>*/,
+ 0/*maxMat<short>*/,
+ 0/*maxMat<int>*/,
+ maxMat<float>,
+ 0/*maxMat<double>*/,
+ };
+#else
static const func_t funcs[] =
{
maxMat<unsigned char>,
maxMat<short>,
maxMat<int>,
maxMat<float>,
- maxMat<double>
+ maxMat<double>,
};
+#endif
const int depth = src1.depth();
const int cn = src1.channels();
using namespace arithm;
typedef void (*func_t)(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+ typedef double (*cast_func_t)(double sc);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[] =
+ {
+ minScalar<unsigned char>,
+ 0/*minScalar<signed char>*/,
+ 0/*minScalar<unsigned short>*/,
+ 0/*minScalar<short>*/,
+ 0/*minScalar<int>*/,
+ minScalar<float>,
+ 0/*minScalar<double>*/,
+ };
+
+ static const cast_func_t cast_func[] =
+ {
+ castScalar<unsigned char>,
+ 0/*castScalar<signed char>*/,
+ 0/*castScalar<unsigned short>*/,
+ 0/*castScalar<short>*/,
+ 0/*castScalar<int>*/,
+ castScalar<float>,
+ 0/*castScalar<double>*/,
+ };
+#else
static const func_t funcs[] =
{
minScalar<unsigned char>,
minScalar<short>,
minScalar<int>,
minScalar<float>,
- minScalar<double>
+ minScalar<double>,
};
- typedef double (*cast_func_t)(double sc);
static const cast_func_t cast_func[] =
{
- castScalar<unsigned char>, castScalar<signed char>, castScalar<unsigned short>, castScalar<short>, castScalar<int>, castScalar<float>, castScalar<double>
+ castScalar<unsigned char>,
+ castScalar<signed char>,
+ castScalar<unsigned short>,
+ castScalar<short>,
+ castScalar<int>,
+ castScalar<float>,
+ castScalar<double>,
};
+#endif
const int depth = src.depth();
CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
}
+ const func_t func = funcs[depth];
+ if (!func)
+ CV_Error(CV_StsNotImplemented, "not available in tiny build");
+
dst.create(src.size(), src.type());
- funcs[depth](src, cast_func[depth](val), dst, StreamAccessor::getStream(stream));
+ func(src, cast_func[depth](val), dst, StreamAccessor::getStream(stream));
}
void cv::gpu::max(const GpuMat& src, double val, GpuMat& dst, Stream& stream)
using namespace arithm;
typedef void (*func_t)(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+ typedef double (*cast_func_t)(double sc);
+
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[] =
+ {
+ maxScalar<unsigned char>,
+ 0/*maxScalar<signed char>*/,
+ 0/*maxScalar<unsigned short>*/,
+ 0/*maxScalar<short>*/,
+ 0/*maxScalar<int>*/,
+ maxScalar<float>,
+ 0/*maxScalar<double>*/,
+ };
+
+ static const cast_func_t cast_func[] =
+ {
+ castScalar<unsigned char>,
+ 0/*castScalar<signed char>*/,
+ 0/*castScalar<unsigned short>*/,
+ 0/*castScalar<short>*/,
+ 0/*castScalar<int>*/,
+ castScalar<float>,
+ 0/*castScalar<double>*/
+ };
+#else
static const func_t funcs[] =
{
maxScalar<unsigned char>,
maxScalar<short>,
maxScalar<int>,
maxScalar<float>,
- maxScalar<double>
+ maxScalar<double>,
};
- typedef double (*cast_func_t)(double sc);
static const cast_func_t cast_func[] =
{
- castScalar<unsigned char>, castScalar<signed char>, castScalar<unsigned short>, castScalar<short>, castScalar<int>, castScalar<float>, castScalar<double>
+ castScalar<unsigned char>,
+ castScalar<signed char>,
+ castScalar<unsigned short>,
+ castScalar<short>,
+ castScalar<int>,
+ castScalar<float>,
+ castScalar<double>,
};
+#endif
const int depth = src.depth();
CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
}
+ const func_t func = funcs[depth];
+ if (!func)
+ CV_Error(CV_StsNotImplemented, "not available in tiny build");
+
dst.create(src.size(), src.type());
- funcs[depth](src, cast_func[depth](val), dst, StreamAccessor::getStream(stream));
+ func(src, cast_func[depth](val), dst, StreamAccessor::getStream(stream));
}
////////////////////////////////////////////////////////////////////////
else
{
typedef void (*func_t)(PtrStepSzb src, PtrStepSzb dst, double thresh, double maxVal, int type, cudaStream_t stream);
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[] =
+ {
+ arithm::threshold<unsigned char>,
+ 0/*arithm::threshold<signed char>*/,
+ 0/*arithm::threshold<unsigned short>*/,
+ 0/*arithm::threshold<short>*/,
+ 0/*arithm::threshold<int>*/,
+ arithm::threshold<float>,
+ 0/*arithm::threshold<double>*/
+ };
+#else
static const func_t funcs[] =
{
arithm::threshold<unsigned char>,
arithm::threshold<float>,
arithm::threshold<double>
};
+#endif
+
+ const func_t func = funcs[depth];
+ if (!func)
+ CV_Error(CV_StsNotImplemented, "not available in tiny build");
if (depth != CV_32F && depth != CV_64F)
{
maxVal = cvRound(maxVal);
}
- funcs[depth](src, dst, thresh, maxVal, type, stream);
+ func(src, dst, thresh, maxVal, type, stream);
}
return thresh;
void cv::gpu::pow(const GpuMat& src, double power, GpuMat& dst, Stream& stream)
{
typedef void (*func_t)(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
+#ifdef OPENCV_TINY_GPU_MODULE
+ static const func_t funcs[] =
+ {
+ 0/*arithm::pow<unsigned char>*/,
+ 0/*arithm::pow<signed char>*/,
+ 0/*arithm::pow<unsigned short>*/,
+ 0/*arithm::pow<short>*/,
+ 0/*arithm::pow<int>*/,
+ arithm::pow<float>,
+ 0/*arithm::pow<double>*/,
+ };
+#else
static const func_t funcs[] =
{
arithm::pow<unsigned char>,
arithm::pow<float>,
arithm::pow<double>
};
+#endif
const int depth = src.depth();
const int cn = src.channels();
CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
}
+ const func_t func = funcs[depth];
+ if (!func)
+ CV_Error(CV_StsNotImplemented, "not available in tiny build");
+
dst.create(src.size(), src.type());
PtrStepSzb src_(src.rows, src.cols * cn, src.data, src.step);
PtrStepSzb dst_(src.rows, src.cols * cn, dst.data, dst.step);
- funcs[depth](src_, power, dst_, StreamAccessor::getStream(stream));
+ func(src_, power, dst_, StreamAccessor::getStream(stream));
}
////////////////////////////////////////////////////////////////////////
projects / platform / upstream / opencv.git / commitdiff