开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 波变换 > 查看源码
cxmat.hpp
资源名称：gabor.rar　[点击查看]
上传用户：soukeisyuu
上传日期：2022-07-03
资源大小：5943k
文件大小：148k
源码类别：

波变换

开发平台：

Visual C++

cxmat.hpp：源码内容
  1. }
  3. static inline Mat& operator *= (const Mat& a, double alpha)
  4. {
  5.     a.convertTo((Mat&)a, -1, alpha);
  6.     return (Mat&)a;
  7. }
  9. static inline Mat& operator += (const Mat& a, const Scalar& s)
  10. {
  11.     add(a, s, (Mat&)a);
  12.     return (Mat&)a;
  13. }
  15. static inline Mat& operator -= (const Mat& a, const Scalar& s)
  16. { return (a += -s); }
  18. template<typename _Tp> static inline
  19. Mat_<_Tp>& operator += (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
  20. {
  21.     (Mat&)a += (const Mat&)b;
  22.     return (Mat_<_Tp>&)a;
  23. }
  25. template<typename _Tp> static inline
  26. Mat_<_Tp>& operator -= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
  27. {
  28.     (Mat&)a -= (const Mat&)b;
  29.     return (Mat_<_Tp>&)a;
  30. }
  32. template<typename _Tp> static inline
  33. Mat_<_Tp>& operator *= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
  34. {
  35.     (Mat&)a *= (const Mat&)b;
  36.     return (Mat_<_Tp>&)a;
  37. }
  39. template<typename _Tp> static inline
  40. Mat_<_Tp>& operator += (const Mat_<_Tp>& a, const Scalar& s)
  41. {
  42.     (Mat&)a += s;
  43.     return (Mat_<_Tp>&)a;
  44. }
  46. template<typename _Tp> static inline
  47. Mat_<_Tp>& operator -= (const Mat_<_Tp>& a, const Scalar& s)
  48. {
  49.     (Mat&)a -= s;
  50.     return (Mat_<_Tp>&)a;
  51. }
  53. template<typename A, typename M> static inline
  54. M& operator += (const M& a, const MatExpr_<A, M>& b)
  55. { return (a += (M)b); }
  57. template<typename A, typename M> static inline
  58. M& operator -= (const M& a, const MatExpr_<A, M>& b)
  59. { return (a -= (M)b); }
  61. template<typename A, typename M> static inline
  62. M& operator *= (const M& a, const MatExpr_<A, M>& b)
  63. { return (a *= (M)b); }
  65. template<typename A, typename M> static inline
  66. M& operator += (const M& a,
  67.                 const MatExpr_<MatExpr_Op2_<A, double, M, MatOp_Scale_<Mat> >, M>& b)
  68. {
  69.     M& _a = (M&)a;
  70.     scaleAdd( b.e.a1, Scalar(b.e.a2), _a, _a );
  71.     return _a;
  72. }
  74. template<typename A, typename M> static inline
  75. M& operator -= (const M& a,
  76.                 const MatExpr_<MatExpr_Op2_<A, double, M, MatOp_Scale_<Mat> >, M>& b)
  77. {
  78.     M& _a = (M&)a;
  79.     scaleAdd( b.e.a1, -Scalar(b.e.a2), _a, _a );
  80.     return _a;
  81. }
  83. template<typename A, typename M> static inline
  84. M& operator += (const M& a,
  85.                 const MatExpr_<MatExpr_Op3_<A, double, double, M, MatOp_ScaleAddS_<Mat> >, M>& b)
  86. {
  87.     M& _a = (M&)a;
  88.     MatOp_AddEx_<Mat>::apply( a, 1, (M)b.e.a1, b.e.a2, b.e.a3, _a );
  89.     return _a;
  90. }
  92. template<typename A, typename M> static inline
  93. M& operator -= (const M& a,
  94.                 const MatExpr_<MatExpr_Op3_<A, double, double, M, MatOp_ScaleAddS_<Mat> >, M>& b)
  95. {
  96.     M& _a = (M&)a;
  97.     MatOp_AddEx_<Mat>::apply( a, 1, (M)b.e.a1, -b.e.a2, -b.e.a3, _a );
  98.     return _a;
  99. }
  101. template<typename A, typename B, typename M> static inline
  102. M& operator += (const M& a,
  103.                 const MatExpr_<MatExpr_Op4_<A, B, double, int, M, MatOp_MatMul_<Mat> >, M>& b)
  104. {
  105.     M& _a = (M&)a;
  106.     MatOp_MatMulAdd_<Mat>::apply( (M)b.e.a1, (M)b.e.a2, b.e.a3, a, 1, b.e.a4, _a );
  107.     return _a;
  108. }
  110. template<typename A, typename B, typename M> static inline
  111. M& operator -= (const M& a,
  112.                 const MatExpr_<MatExpr_Op4_<A, B, double, int, M, MatOp_MatMul_<Mat> >, M>& b)
  113. {
  114.     M& _a = (M&)a;
  115.     MatOp_MatMulAdd_<Mat>::apply( (M)b.e.a1, (M)b.e.a2, -b.e.a3, a, 1, b.e.a4, _a );
  116.     return _a;
  117. }
  119. template<typename A, typename M> static inline
  120. M& operator *= (const M& a,
  121.                 const MatExpr_<MatExpr_Op2_<A, double, M, MatOp_Scale_<Mat> >, M>& b)
  122. {
  123.     M& _a = (M&)a;
  124.     MatOp_MatMul_<Mat>::apply( a, (M)b.e.a1, b.e.a2, 0, _a );
  125.     return _a;
  126. }
  128. template<typename A, typename M> static inline
  129. M& operator *= (const M& a,
  130.                 const MatExpr_<MatExpr_Op3_<A, double, double, M, MatOp_ScaleAddS_<Mat> >, M>& b)
  131. {
  132.     M& _a = (M&)a;
  133.     MatOp_MatMulAdd_<Mat>::apply( a, (M)b.e.a1, b.e.a2, a, b.e.a3, 0, _a );
  134.     return _a;
  135. }
  137. template<typename A, typename M> static inline
  138. M& operator *= (const M& a,
  139.                 const MatExpr_<MatExpr_Op2_<A, double, M, MatOp_T_<Mat> >, M>& b)
  140. {
  141.     M& _a = (M&)a;
  142.     MatOp_MatMul_<Mat>::apply( a, (M)b.e.a1, b.e.a2, GEMM_2_T, _a );
  143.     return _a;
  144. }
  146. ////////////////////////////// Logical operations ///////////////////////////////
  148. static inline MatExpr_<MatExpr_Op3_<Mat, Mat, int, Mat, MatOp_Bin_<Mat> >, Mat>
  149. operator & (const Mat& a, const Mat& b)
  150. {
  151.     typedef MatExpr_Op3_<Mat, Mat, int, Mat, MatOp_Bin_<Mat> > MatExpr_Temp;
  152.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, b, '&'));
  153. }
  155. static inline MatExpr_<MatExpr_Op3_<Mat, Mat, int, Mat, MatOp_Bin_<Mat> >, Mat>
  156. operator | (const Mat& a, const Mat& b)
  157. {
  158.     typedef MatExpr_Op3_<Mat, Mat, int, Mat, MatOp_Bin_<Mat> > MatExpr_Temp;
  159.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, b, '|'));
  160. }
  162. static inline MatExpr_<MatExpr_Op3_<Mat, Mat, int, Mat, MatOp_Bin_<Mat> >, Mat>
  163. operator ^ (const Mat& a, const Mat& b)
  164. {
  165.     typedef MatExpr_Op3_<Mat, Mat, int, Mat, MatOp_Bin_<Mat> > MatExpr_Temp;
  166.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, b, '^'));
  167. }
  169. template<typename _Tp> static inline
  170. MatExpr_<MatExpr_Op3_<Mat_<_Tp>, Mat_<_Tp>, int, Mat_<_Tp>,
  171.             MatOp_Bin_<Mat> >, Mat_<_Tp> >
  172. operator & (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
  173. {
  174.     typedef MatExpr_Op3_<Mat_<_Tp>, Mat_<_Tp>, int, Mat_<_Tp>,
  175.         MatOp_Bin_<Mat> > MatExpr_Temp;
  176.     return MatExpr_<MatExpr_Temp, Mat_<_Tp> >(MatExpr_Temp(
  177.         a, b, '&'));
  178. }
  180. template<typename _Tp> static inline
  181. MatExpr_<MatExpr_Op3_<Mat_<_Tp>, Mat_<_Tp>, int, Mat_<_Tp>,
  182.             MatOp_Bin_<Mat> >, Mat_<_Tp> >
  183. operator | (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
  184. {
  185.     typedef MatExpr_Op3_<Mat_<_Tp>, Mat_<_Tp>, int, Mat_<_Tp>,
  186.         MatOp_Bin_<Mat> > MatExpr_Temp;
  187.     return MatExpr_<MatExpr_Temp, Mat_<_Tp> >(MatExpr_Temp(
  188.         a, b, '|'));
  189. }
  191. template<typename _Tp> static inline
  192. MatExpr_<MatExpr_Op3_<Mat_<_Tp>, Mat_<_Tp>, int, Mat_<_Tp>,
  193.             MatOp_Bin_<Mat> >, Mat_<_Tp> >
  194. operator ^ (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
  195. {
  196.     typedef MatExpr_Op3_<Mat_<_Tp>, Mat_<_Tp>, int, Mat_<_Tp>,
  197.         MatOp_Bin_<Mat> > MatExpr_Temp;
  198.     return MatExpr_<MatExpr_Temp, Mat_<_Tp> >(MatExpr_Temp(
  199.         a, b, '^'));
  200. }
  202. template<typename A, typename B, typename M> static inline
  203. MatExpr_<MatExpr_Op3_<M, M, int, M, MatOp_Bin_<Mat> >, M>
  204. operator & (const MatExpr_<A, M>& a, const MatExpr_<B, M>& b)
  205. { return (M)a & (M)b; }
  207. template<typename A, typename M> static inline
  208. MatExpr_<MatExpr_Op3_<M, M, int, M, MatOp_Bin_<Mat> >, M>
  209. operator & (const MatExpr_<A, M>& a, const M& b)
  210. { return (M)a & b; }
  212. template<typename A, typename M> static inline
  213. MatExpr_<MatExpr_Op3_<M, M, int, M, MatOp_Bin_<Mat> >, M>
  214. operator & (const M& a, const MatExpr_<A, M>& b)
  215. { return a & (M)b; }
  217. template<typename A, typename B, typename M> static inline
  218. MatExpr_<MatExpr_Op3_<M, M, int, M, MatOp_Bin_<Mat> >, M>
  219. operator | (const MatExpr_<A, M>& a, const MatExpr_<B, M>& b)
  220. { return (M)a | (M)b; }
  222. template<typename A, typename M> static inline
  223. MatExpr_<MatExpr_Op3_<M, M, int, M, MatOp_Bin_<Mat> >, M>
  224. operator | (const MatExpr_<A, M>& a, const M& b)
  225. { return (M)a | b; }
  227. template<typename A, typename M> static inline
  228. MatExpr_<MatExpr_Op3_<M, M, int, M, MatOp_Bin_<Mat> >, M>
  229. operator | (const M& a, const MatExpr_<A, M>& b)
  230. { return a | (M)b; }
  232. template<typename A, typename B, typename M> static inline
  233. MatExpr_<MatExpr_Op3_<M, M, int, M, MatOp_Bin_<Mat> >, M>
  234. operator ^ (const MatExpr_<A, M>& a, const MatExpr_<B, M>& b)
  235. { return (M)a ^ (M)b; }
  237. template<typename A, typename M> static inline
  238. MatExpr_<MatExpr_Op3_<M, M, int, M, MatOp_Bin_<Mat> >, M>
  239. operator ^ (const MatExpr_<A, M>& a, const M& b)
  240. { return (M)a ^ b; }
  242. template<typename A, typename M> static inline
  243. MatExpr_<MatExpr_Op3_<M, M, int, M, MatOp_Bin_<Mat> >, M>
  244. operator ^ (const M& a, const MatExpr_<A, M>& b)
  245. { return a ^ (M)b; }
  247. static inline Mat& operator &= (const Mat& a, const Mat& b)
  248. {
  249.     MatOp_Bin_<Mat>::apply( a, b, '&', (Mat&)a );
  250.     return (Mat&)a;
  251. }
  253. static inline Mat& operator |= (const Mat& a, const Mat& b)
  254. {
  255.     MatOp_Bin_<Mat>::apply( a, b, '|', (Mat&)a );
  256.     return (Mat&)a;
  257. }
  259. static inline Mat& operator ^= (const Mat& a, const Mat& b)
  260. {
  261.     MatOp_Bin_<Mat>::apply( a, b, '^', (Mat&)a );
  262.     return (Mat&)a;
  263. }
  265. template<typename _Tp> static inline Mat_<_Tp>&
  266. operator &= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
  267. {
  268.     (Mat&)a &= (const Mat&)b;
  269.     return (Mat_<_Tp>&)a;
  270. }
  272. template<typename _Tp> static inline Mat_<_Tp>&
  273. operator |= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
  274. {
  275.     (Mat&)a |= (const Mat&)b;
  276.     return (Mat_<_Tp>&)a;
  277. }
  279. template<typename _Tp> static inline Mat_<_Tp>&
  280. operator ^= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
  281. {
  282.     (Mat&)a ^= (const Mat&)b;
  283.     return (Mat_<_Tp>&)a;
  284. }
  286. template<typename A, typename M> static inline M&
  287. operator &= (const M& a, const MatExpr_<A, M>& b)
  288. { return (a &= (M)b); }
  290. template<typename A, typename M> static inline M&
  291. operator |= (const M& a, const MatExpr_<A, M>& b)
  292. { return (a |= (M)b); }
  294. template<typename A, typename M> static inline M&
  295. operator ^= (const M& a, const MatExpr_<A, M>& b)
  296. { return (a ^= (M)b); }
  298. static inline MatExpr_<MatExpr_Op3_<Mat, Scalar, int, Mat, MatOp_BinS_<Mat> >, Mat>
  299. operator & (const Mat& a, const Scalar& s)
  300. {
  301.     typedef MatExpr_Op3_<Mat, Scalar, int, Mat, MatOp_BinS_<Mat> > MatExpr_Temp;
  302.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, s, '&'));
  303. }
  305. static inline MatExpr_<MatExpr_Op3_<Mat, Scalar, int, Mat, MatOp_BinS_<Mat> >, Mat>
  306. operator & (const Scalar& s, const Mat& a)
  307. { return a & s; }
  309. static inline MatExpr_<MatExpr_Op3_<Mat, Scalar, int, Mat, MatOp_BinS_<Mat> >, Mat>
  310. operator | (const Mat& a, const Scalar& s)
  311. {
  312.     typedef MatExpr_Op3_<Mat, Scalar, int, Mat, MatOp_BinS_<Mat> > MatExpr_Temp;
  313.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, s, '|'));
  314. }
  316. static inline MatExpr_<MatExpr_Op3_<Mat, Scalar, int, Mat, MatOp_BinS_<Mat> >, Mat>
  317. operator | (const Scalar& s, const Mat& a)
  318. { return a | s; }
  320. static inline MatExpr_<MatExpr_Op3_<Mat, Scalar, int, Mat, MatOp_BinS_<Mat> >, Mat>
  321. operator ^ (const Mat& a, const Scalar& s)
  322. {
  323.     typedef MatExpr_Op3_<Mat, Scalar, int, Mat, MatOp_BinS_<Mat> > MatExpr_Temp;
  324.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, s, '^'));
  325. }
  327. static inline MatExpr_<MatExpr_Op3_<Mat, Scalar, int, Mat, MatOp_BinS_<Mat> >, Mat>
  328. operator ^ (const Scalar& s, const Mat& a)
  329. { return a ^ s; }
  331. static inline MatExpr_<MatExpr_Op3_<Mat, Scalar, int, Mat, MatOp_BinS_<Mat> >, Mat>
  332. operator ~ (const Mat& a)
  333. {
  334.     typedef MatExpr_Op3_<Mat, Scalar, int, Mat, MatOp_BinS_<Mat> > MatExpr_Temp;
  335.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, Scalar(), '~'));
  336. }
  338. template<typename _Tp> static inline
  339. MatExpr_<MatExpr_Op3_<Mat_<_Tp>, Scalar, int, Mat_<_Tp>, MatOp_BinS_<Mat> >, Mat_<_Tp> >
  340. operator & (const Mat_<_Tp>& a, const Scalar& s)
  341. {
  342.     typedef MatExpr_Op3_<Mat_<_Tp>, Scalar, int, Mat_<_Tp>, MatOp_BinS_<Mat> > MatExpr_Temp;
  343.     return MatExpr_<MatExpr_Temp, Mat_<_Tp> >(MatExpr_Temp(a, s, '&'));
  344. }
  346. template<typename _Tp> static inline
  347. MatExpr_<MatExpr_Op3_<Mat_<_Tp>, Scalar, int, Mat_<_Tp>, MatOp_BinS_<Mat> >, Mat_<_Tp> >
  348. operator & (const Scalar& s, const Mat_<_Tp>& a)
  349. { return a & s; }
  351. template<typename _Tp> static inline
  352. MatExpr_<MatExpr_Op3_<Mat_<_Tp>, Scalar, int, Mat_<_Tp>, MatOp_BinS_<Mat> >, Mat_<_Tp> >
  353. operator | (const Mat_<_Tp>& a, const Scalar& s)
  354. {
  355.     typedef MatExpr_Op3_<Mat_<_Tp>, Scalar, int, Mat_<_Tp>, MatOp_BinS_<Mat> > MatExpr_Temp;
  356.     return MatExpr_<MatExpr_Temp, Mat_<_Tp> >(MatExpr_Temp(a, s, '|'));
  357. }
  359. template<typename _Tp> static inline
  360. MatExpr_<MatExpr_Op3_<Mat_<_Tp>, Scalar, int, Mat_<_Tp>, MatOp_BinS_<Mat> >, Mat_<_Tp> >
  361. operator | (const Scalar& s, const Mat_<_Tp>& a)
  362. { return a | s; }
  364. template<typename _Tp> static inline
  365. MatExpr_<MatExpr_Op3_<Mat_<_Tp>, Scalar, int, Mat_<_Tp>, MatOp_BinS_<Mat> >, Mat_<_Tp> >
  366. operator ^ (const Mat_<_Tp>& a, const Scalar& s)
  367. {
  368.     typedef MatExpr_Op3_<Mat_<_Tp>, Scalar, int, Mat_<_Tp>, MatOp_BinS_<Mat> > MatExpr_Temp;
  369.     return MatExpr_<MatExpr_Temp, Mat_<_Tp> >(MatExpr_Temp(a, s, '^'));
  370. }
  372. template<typename _Tp> static inline
  373. MatExpr_<MatExpr_Op3_<Mat_<_Tp>, Scalar, int, Mat_<_Tp>, MatOp_BinS_<Mat> >, Mat_<_Tp> >
  374. operator ^ (const Scalar& s, const Mat_<_Tp>& a)
  375. { return a ^ s; }
  377. template<typename _Tp> static inline
  378. MatExpr_<MatExpr_Op3_<Mat_<_Tp>, Scalar, int, Mat_<_Tp>, MatOp_BinS_<Mat> >, Mat_<_Tp> >
  379. operator ~ (const Mat_<_Tp>& a)
  380. {
  381.     typedef MatExpr_Op3_<Mat_<_Tp>, Scalar, int, Mat_<_Tp>, MatOp_BinS_<Mat> > MatExpr_Temp;
  382.     return MatExpr_<MatExpr_Temp, Mat_<_Tp> >(MatExpr_Temp(a, Scalar(), '~'));
  383. }
  385. template<typename A, typename M> static inline
  386. MatExpr_<MatExpr_Op3_<M, Scalar, int, M, MatOp_BinS_<Mat> >, M >
  387. operator & (const MatExpr_<A, M>& a, const Scalar& s)
  388. { return (M)a & s; }
  390. template<typename A, typename M> static inline
  391. MatExpr_<MatExpr_Op3_<M, Scalar, int, M, MatOp_BinS_<Mat> >, M >
  392. operator & (const Scalar& s, const MatExpr_<A, M>& a)
  393. { return (M)a & s; }
  395. template<typename A, typename M> static inline
  396. MatExpr_<MatExpr_Op3_<M, Scalar, int, M, MatOp_BinS_<Mat> >, M >
  397. operator | (const MatExpr_<A, M>& a, const Scalar& s)
  398. { return (M)a | s; }
  400. template<typename A, typename M> static inline
  401. MatExpr_<MatExpr_Op3_<M, Scalar, int, M, MatOp_BinS_<Mat> >, M >
  402. operator | (const Scalar& s, const MatExpr_<A, M>& a)
  403. { return (M)a | s; }
  405. template<typename A, typename M> static inline
  406. MatExpr_<MatExpr_Op3_<M, Scalar, int, M, MatOp_BinS_<Mat> >, M >
  407. operator ^ (const MatExpr_<A, M>& a, const Scalar& s)
  408. { return (M)a ^ s; }
  410. template<typename A, typename M> static inline
  411. MatExpr_<MatExpr_Op3_<M, Scalar, int, M, MatOp_BinS_<Mat> >, M >
  412. operator ^ (const Scalar& s, const MatExpr_<A, M>& a)
  413. { return (M)a ^ s; }
  415. template<typename A, typename M> static inline
  416. MatExpr_<MatExpr_Op3_<M, Scalar, int, M, MatOp_BinS_<Mat> >, M >
  417. operator ~ (const MatExpr_<A, M>& a)
  418. { return ~(M)a; }
  420. static inline Mat& operator &= (const Mat& a, const Scalar& s)
  421. {
  422.     MatOp_BinS_<Mat>::apply( a, s, '&', (Mat&)a );
  423.     return (Mat&)a;
  424. }
  426. static inline Mat& operator |= (const Mat& a, const Scalar& s)
  427. {
  428.     MatOp_BinS_<Mat>::apply( a, s, '|', (Mat&)a );
  429.     return (Mat&)a;
  430. }
  432. static inline Mat& operator ^= (const Mat& a, const Scalar& s)
  433. {
  434.     MatOp_BinS_<Mat>::apply( a, s, '^', (Mat&)a );
  435.     return (Mat&)a;
  436. }
  438. template<typename _Tp> static inline Mat_<_Tp>&
  439. operator &= (const Mat_<_Tp>& a, const Scalar& s)
  440. {
  441.     (Mat&)a &= s;
  442.     return (Mat_<_Tp>&)a;
  443. }
  445. template<typename _Tp> static inline Mat_<_Tp>&
  446. operator |= (const Mat_<_Tp>& a, const Scalar& s)
  447. {
  448.     (Mat&)a |= s;
  449.     return (Mat_<_Tp>&)a;
  450. }
  452. template<typename _Tp> static inline Mat_<_Tp>&
  453. operator ^= (const Mat_<_Tp>& a, const Scalar& s)
  454. {
  455.     (Mat&)a ^= s;
  456.     return (Mat_<_Tp>&)a;
  457. }
  459. ////////////////////////////// Comparison operations ///////////////////////////////
  461. static inline MatExpr_<MatExpr_Op3_<Mat, Mat, int, Mat, MatOp_Cmp_<Mat> >, Mat>
  462. operator == (const Mat& a, const Mat& b)
  463. {
  464.     typedef MatExpr_Op3_<Mat, Mat, int, Mat, MatOp_Cmp_<Mat> > MatExpr_Temp;
  465.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, b, CMP_EQ));
  466. }
  468. static inline MatExpr_<MatExpr_Op3_<Mat, Mat, int, Mat, MatOp_Cmp_<Mat> >, Mat>
  469. operator >= (const Mat& a, const Mat& b)
  470. {
  471.     typedef MatExpr_Op3_<Mat, Mat, int, Mat, MatOp_Cmp_<Mat> > MatExpr_Temp;
  472.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, b, CMP_GE));
  473. }
  475. static inline MatExpr_<MatExpr_Op3_<Mat, Mat, int, Mat, MatOp_Cmp_<Mat> >, Mat>
  476. operator > (const Mat& a, const Mat& b)
  477. {
  478.     typedef MatExpr_Op3_<Mat, Mat, int, Mat, MatOp_Cmp_<Mat> > MatExpr_Temp;
  479.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, b, CMP_GT));
  480. }
  482. static inline MatExpr_<MatExpr_Op3_<Mat, Mat, int, Mat, MatOp_Cmp_<Mat> >, Mat>
  483. operator <= (const Mat& a, const Mat& b)
  484. { return b >= a; }
  486. static inline MatExpr_<MatExpr_Op3_<Mat, Mat, int, Mat, MatOp_Cmp_<Mat> >, Mat>
  487. operator < (const Mat& a, const Mat& b)
  488. { return b > a; }
  490. static inline MatExpr_<MatExpr_Op3_<Mat, Mat, int, Mat, MatOp_Cmp_<Mat> >, Mat>
  491. operator != (const Mat& a, const Mat& b)
  492. {
  493.     typedef MatExpr_Op3_<Mat, Mat, int, Mat, MatOp_Cmp_<Mat> > MatExpr_Temp;
  494.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, b, CMP_NE));
  495. }
  497. static inline MatExpr_<MatExpr_Op3_<Mat, double, int, Mat, MatOp_CmpS_<Mat> >, Mat>
  498. operator == (const Mat& a, double alpha)
  499. {
  500.     typedef MatExpr_Op3_<Mat, double, int, Mat, MatOp_CmpS_<Mat> > MatExpr_Temp;
  501.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, alpha, CMP_EQ));
  502. }
  504. static inline MatExpr_<MatExpr_Op3_<Mat, double, int, Mat, MatOp_CmpS_<Mat> >, Mat>
  505. operator >= (const Mat& a, double alpha)
  506. {
  507.     typedef MatExpr_Op3_<Mat, double, int, Mat, MatOp_CmpS_<Mat> > MatExpr_Temp;
  508.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, alpha, CMP_GE));
  509. }
  511. static inline MatExpr_<MatExpr_Op3_<Mat, double, int, Mat, MatOp_CmpS_<Mat> >, Mat>
  512. operator > (const Mat& a, double alpha)
  513. {
  514.     typedef MatExpr_Op3_<Mat, double, int, Mat, MatOp_CmpS_<Mat> > MatExpr_Temp;
  515.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, alpha, CMP_GT));
  516. }
  518. static inline MatExpr_<MatExpr_Op3_<Mat, double, int, Mat, MatOp_CmpS_<Mat> >, Mat>
  519. operator <= (const Mat& a, double alpha)
  520. {
  521.     typedef MatExpr_Op3_<Mat, double, int, Mat, MatOp_CmpS_<Mat> > MatExpr_Temp;
  522.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, alpha, CMP_LE));
  523. }
  525. static inline MatExpr_<MatExpr_Op3_<Mat, double, int, Mat, MatOp_CmpS_<Mat> >, Mat>
  526. operator < (const Mat& a, double alpha)
  527. {
  528.     typedef MatExpr_Op3_<Mat, double, int, Mat, MatOp_CmpS_<Mat> > MatExpr_Temp;
  529.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, alpha, CMP_LT));
  530. }
  532. static inline MatExpr_<MatExpr_Op3_<Mat, double, int, Mat, MatOp_CmpS_<Mat> >, Mat>
  533. operator != (const Mat& a, double alpha)
  534. {
  535.     typedef MatExpr_Op3_<Mat, double, int, Mat, MatOp_CmpS_<Mat> > MatExpr_Temp;
  536.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, alpha, CMP_NE));
  537. }
  539. static inline MatExpr_<MatExpr_Op3_<Mat, double, int, Mat, MatOp_CmpS_<Mat> >, Mat>
  540. operator == (double alpha, const Mat& a)
  541. { return a == alpha; }
  543. static inline MatExpr_<MatExpr_Op3_<Mat, double, int, Mat, MatOp_CmpS_<Mat> >, Mat>
  544. operator >= (double alpha, const Mat& a)
  545. { return a <= alpha; }
  547. static inline MatExpr_<MatExpr_Op3_<Mat, double, int, Mat, MatOp_CmpS_<Mat> >, Mat>
  548. operator > (double alpha, const Mat& a)
  549. { return a < alpha; }
  551. static inline MatExpr_<MatExpr_Op3_<Mat, double, int, Mat, MatOp_CmpS_<Mat> >, Mat>
  552. operator <= (double alpha, const Mat& a)
  553. { return a >= alpha; }
  555. static inline MatExpr_<MatExpr_Op3_<Mat, double, int, Mat, MatOp_CmpS_<Mat> >, Mat>
  556. operator < (double alpha, const Mat& a)
  557. { return a > alpha; }
  559. static inline MatExpr_<MatExpr_Op3_<Mat, double, int, Mat, MatOp_CmpS_<Mat> >, Mat>
  560. operator != (double alpha, const Mat& a)
  561. { return a != alpha; }
  563. /////////////////////////////// Miscellaneous operations //////////////////////////////
  565. // max(A, B)
  566. static inline MatExpr_<MatExpr_Op3_<Mat, Mat, int, Mat, MatOp_Bin_<Mat> >, Mat>
  567. max(const Mat& a, const Mat& b)
  568. {
  569.     typedef MatExpr_Op3_<Mat, Mat, int, Mat, MatOp_Bin_<Mat> > MatExpr_Temp;
  570.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, b, 'M'));
  571. }
  573. // min(A, B)
  574. static inline MatExpr_<MatExpr_Op3_<Mat, Mat, int, Mat, MatOp_Bin_<Mat> >, Mat>
  575. min(const Mat& a, const Mat& b)
  576. {
  577.     typedef MatExpr_Op3_<Mat, Mat, int, Mat, MatOp_Bin_<Mat> > MatExpr_Temp;
  578.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, b, 'm'));
  579. }
  581. // abs(A)
  582. static inline MatExpr_<MatExpr_Op3_<Mat, Scalar, int, Mat, MatOp_BinS_<Mat> >, Mat>
  583. abs(const Mat& a)
  584. {
  585.     typedef MatExpr_Op3_<Mat, Scalar, int, Mat, MatOp_BinS_<Mat> > MatExpr_Temp;
  586.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, Scalar(0), 'a'));
  587. }
  589. // max(A, B)
  590. template<typename _Tp> static inline
  591. MatExpr_<MatExpr_Op3_<Mat_<_Tp>, Mat_<_Tp>, int, Mat_<_Tp>,
  592.             MatOp_Bin_<Mat> >, Mat_<_Tp> >
  593. max(const Mat_<_Tp>& a, const Mat_<_Tp>& b)
  594. {
  595.     typedef MatExpr_Op3_<Mat_<_Tp>, Mat_<_Tp>, int, Mat_<_Tp>,
  596.         MatOp_Bin_<Mat> > MatExpr_Temp;
  597.     return MatExpr_<MatExpr_Temp, Mat_<_Tp> >(MatExpr_Temp(
  598.         a, b, 'M'));
  599. }
  601. // min(A, B)
  602. template<typename _Tp> static inline
  603. MatExpr_<MatExpr_Op3_<Mat_<_Tp>, Mat_<_Tp>, int, Mat_<_Tp>,
  604.             MatOp_Bin_<Mat> >, Mat_<_Tp> >
  605. min(const Mat_<_Tp>& a, const Mat_<_Tp>& b)
  606. {
  607.     typedef MatExpr_Op3_<Mat_<_Tp>, Mat_<_Tp>, int, Mat_<_Tp>,
  608.         MatOp_Bin_<Mat> > MatExpr_Temp;
  609.     return MatExpr_<MatExpr_Temp, Mat_<_Tp> >(MatExpr_Temp(
  610.         a, b, 'm'));
  611. }
  613. // abs(A)
  614. template<typename _Tp> static inline
  615. MatExpr_<MatExpr_Op3_<Mat_<_Tp>, Scalar, int, Mat_<_Tp>,
  616.             MatOp_BinS_<Mat> >, Mat_<_Tp> >
  617. abs(const Mat_<_Tp>& a, const Mat_<_Tp>& b)
  618. {
  619.     typedef MatExpr_Op3_<Mat_<_Tp>, Scalar, int, Mat_<_Tp>,
  620.         MatOp_Bin_<Mat> > MatExpr_Temp;
  621.     return MatExpr_<MatExpr_Temp, Mat_<_Tp> >(MatExpr_Temp(
  622.         a, Scalar(0), 'a'));
  623. }
  625. // max(A, B)
  626. template<typename A, typename B, typename M> static inline
  627. MatExpr_<MatExpr_Op3_<M, M, int, M, MatOp_Bin_<Mat> >, M>
  628. max(const MatExpr_<A, M>& a, const MatExpr_<B, M>& b)
  629. { return max((M)a, (M)b); }
  631. template<typename A, typename M> static inline
  632. MatExpr_<MatExpr_Op3_<M, M, int, M, MatOp_Bin_<Mat> >, M>
  633. max(const MatExpr_<A, M>& a, const M& b)
  634. { return max((M)a, b); }
  636. template<typename A, typename M> static inline
  637. MatExpr_<MatExpr_Op3_<M, M, int, M, MatOp_Bin_<Mat> >, M>
  638. max(const M& a, const MatExpr_<A, M>& b)
  639. { return max(a, (M)b); }
  641. // min(A, B)
  642. template<typename A, typename B, typename M> static inline
  643. MatExpr_<MatExpr_Op3_<M, M, int, M, MatOp_Bin_<Mat> >, M>
  644. min(const MatExpr_<A, M>& a, const MatExpr_<B, M>& b)
  645. { return min((M)a, (M)b); }
  647. template<typename A, typename M> static inline
  648. MatExpr_<MatExpr_Op3_<M, M, int, M, MatOp_Bin_<Mat> >, M>
  649. min(const MatExpr_<A, M>& a, const M& b)
  650. { return min((M)a, b); }
  652. template<typename A, typename M> static inline
  653. MatExpr_<MatExpr_Op3_<M, M, int, M, MatOp_Bin_<Mat> >, M>
  654. min(const M& a, const MatExpr_<A, M>& b)
  655. { return min(a, (M)b); }
  657. // abs(A)
  658. template<typename A, typename B, typename M> static inline
  659. MatExpr_<MatExpr_Op3_<M, M, int, M, MatOp_Bin_<Mat> >, M>
  660. abs(const MatExpr_<MatExpr_Op2_<A, B, M, MatOp_Sub_<Mat> >, M>& a)
  661. {
  662.     typedef MatExpr_Op3_<M, M, int, M, MatOp_Bin_<Mat> > MatExpr_Temp;
  663.     return MatExpr_<MatExpr_Temp, M>(MatExpr_Temp((M)a.e.a1, (M)a.e.a2, 'a'));
  664. }
  666. template<typename _Tp> void merge(const Mat_<_Tp>* mvbegin, size_t count, Mat& dst)
  667. { merge( (const Mat*)mvbegin, count, dst ); }
  669. static inline void split(const Mat& m, vector<Mat>& mv)
  670. {
  671.     mv.resize(m.channels());
  672.     if(m.channels() > 0)
  673.         split(m, &mv[0]);
  674. }
  675.     
  676. template<typename _Tp> void split(const Mat& src, vector<Mat_<_Tp> >& mv)
  677. { split(src, (vector<Mat>&)mv ); }
  678.     
  679. static inline void merge(const vector<Mat>& mv, Mat& dst)
  680. { merge(&mv[0], mv.size(), dst); }
  682. static inline void mixChannels(const vector<Mat>& src, vector<Mat>& dst,
  683.                                const int* fromTo, int npairs)
  684. {
  685.     mixChannels(&src[0], (int)src.size(), &dst[0], (int)dst.size(), fromTo, npairs);
  686. }
  687.     
  688. ///// Element-wise multiplication
  690. inline MatExpr_<MatExpr_Op4_<Mat, Mat, double, char, Mat, MatOp_MulDiv_<Mat> >, Mat>
  691. Mat::mul(const Mat& m, double scale) const
  692. {
  693.     typedef MatExpr_Op4_<Mat, Mat, double, char, Mat, MatOp_MulDiv_<Mat> > MatExpr_Temp;
  694.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(*this, m, scale, '*'));
  695. }
  697. inline MatExpr_<MatExpr_Op4_<Mat, Mat, double, char, Mat, MatOp_MulDiv_<Mat> >, Mat>
  698. Mat::mul(const MatExpr_<MatExpr_Op2_<Mat, double, Mat, MatOp_Scale_<Mat> >, Mat>& m, double scale) const
  699. {
  700.     typedef MatExpr_Op4_<Mat, Mat, double, char, Mat, MatOp_MulDiv_<Mat> > MatExpr_Temp;
  701.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(*this, m.e.a1, m.e.a2*scale, '*'));
  702. }
  704. inline MatExpr_<MatExpr_Op4_<Mat, Mat, double, char, Mat, MatOp_MulDiv_<Mat> >, Mat>
  705. Mat::mul(const MatExpr_<MatExpr_Op2_<Mat, double, Mat, MatOp_DivRS_<Mat> >, Mat>& m, double scale) const
  706. {
  707.     typedef MatExpr_Op4_<Mat, Mat, double, char, Mat, MatOp_MulDiv_<Mat> > MatExpr_Temp;
  708.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(*this, m.e.a1, scale/m.e.a2, '/'));
  709. }
  711. template<typename _Tp> inline
  712. MatExpr_<MatExpr_Op4_<Mat_<_Tp>, Mat_<_Tp>, double, char, Mat_<_Tp>, MatOp_MulDiv_<Mat> >, Mat_<_Tp> >
  713. Mat_<_Tp>::mul(const Mat_<_Tp>& m, double scale) const
  714. {
  715.     typedef MatExpr_Op4_<Mat_<_Tp>, Mat_<_Tp>, double, char, Mat_<_Tp>, MatOp_MulDiv_<Mat> > MatExpr_Temp;
  716.     return MatExpr_<MatExpr_Temp, Mat_<_Tp> >(MatExpr_Temp(*this, m, scale, '*'));
  717. }
  719. template<typename _Tp> inline
  720. MatExpr_<MatExpr_Op4_<Mat_<_Tp>, Mat_<_Tp>, double, char, Mat_<_Tp>, MatOp_MulDiv_<Mat> >, Mat_<_Tp> >
  721. Mat_<_Tp>::mul(const MatExpr_<MatExpr_Op2_<Mat_<_Tp>, double, Mat_<_Tp>, MatOp_Scale_<Mat> >, Mat_<_Tp> >& m, double scale) const
  722. {
  723.     typedef MatExpr_Op4_<Mat_<_Tp>, Mat_<_Tp>, double, char, Mat_<_Tp>, MatOp_MulDiv_<Mat> > MatExpr_Temp;
  724.     return MatExpr_<MatExpr_Temp, Mat_<_Tp> >(MatExpr_Temp(*this, m.e.a1, m.e.a2*scale, '*'));
  725. }
  727. template<typename _Tp> inline
  728. MatExpr_<MatExpr_Op4_<Mat_<_Tp>, Mat_<_Tp>, double, char, Mat_<_Tp>, MatOp_MulDiv_<Mat> >, Mat_<_Tp> >
  729. Mat_<_Tp>::mul(const MatExpr_<MatExpr_Op2_<Mat_<_Tp>, double, Mat_<_Tp>, MatOp_DivRS_<Mat> >, Mat_<_Tp> >& m, double scale) const
  730. {
  731.     typedef MatExpr_Op4_<Mat_<_Tp>, Mat_<_Tp>, double, char, Mat_<_Tp>, MatOp_MulDiv_<Mat> > MatExpr_Temp;
  732.     return MatExpr_<MatExpr_Temp, Mat_<_Tp> >(MatExpr_Temp(*this, m.e.a1, scale/m.e.a2, '/'));
  733. }
  735. template<typename A, typename B, typename M> static inline
  736. MatExpr_<MatExpr_Op4_<M, M, double, char, M, MatOp_MulDiv_<Mat> >, M>
  737. operator * (const MatExpr_<MatExpr_Op4_<A, B, double, char, M, MatOp_MulDiv_<Mat> >, M>& a,
  738.             double alpha)
  739. {
  740.     typedef MatExpr_Op4_<M, M, double, char, M, MatOp_MulDiv_<Mat> > MatExpr_Temp;
  741.     return MatExpr_<MatExpr_Temp, M>(MatExpr_Temp((M)a.e.a1, (M)a.e.a2, a.e.a3*alpha, a.e.a4));
  742. }
  744. template<typename A, typename B, typename M> static inline
  745. MatExpr_<MatExpr_Op4_<M, M, double, char, M, MatOp_MulDiv_<Mat> >, M>
  746. operator * (double alpha,
  747.             const MatExpr_<MatExpr_Op4_<A, B, double, char, M, MatOp_MulDiv_<Mat> >, M>& a)
  748. { return a*alpha; }
  751. ////// Element-wise division
  753. static inline MatExpr_<MatExpr_Op4_<Mat, Mat, double, char, Mat, MatOp_MulDiv_<Mat> >, Mat>
  754. operator / (const Mat& a, const Mat& b)
  755. {
  756.     typedef MatExpr_Op4_<Mat, Mat, double, char, Mat, MatOp_MulDiv_<Mat> > MatExpr_Temp;
  757.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, b, 1, '/'));
  758. }
  760. template<typename _Tp> static inline
  761. MatExpr_<MatExpr_Op4_<Mat_<_Tp>, Mat_<_Tp>, double,
  762. char, Mat_<_Tp>, MatOp_MulDiv_<Mat> >, Mat_<_Tp> >
  763. operator / (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
  764. {
  765.     typedef MatExpr_Op4_<Mat_<_Tp>, Mat_<_Tp>, double,
  766.         char, Mat_<_Tp>, MatOp_MulDiv_<Mat> > MatExpr_Temp;
  767.     return MatExpr_<MatExpr_Temp, Mat_<_Tp> >(MatExpr_Temp(a, b, 1, '/'));
  768. }
  770. template<typename A, typename B, typename M> static inline
  771. MatExpr_<MatExpr_Op4_<M, M, double, char, M, MatOp_MulDiv_<Mat> >, M>
  772. operator / (const MatExpr_<A, M>& a, const MatExpr_<B, M>& b)
  773. { return (M)a/(M)b; }
  775. template<typename A, typename M> static inline
  776. MatExpr_<MatExpr_Op4_<M, M, double, char, M, MatOp_MulDiv_<Mat> >, M>
  777. operator / (const MatExpr_<A, M>& a, const M& b)
  778. { return (M)a/b; }
  780. template<typename A, typename M> static inline
  781. MatExpr_<MatExpr_Op4_<M, M, double, char, M, MatOp_MulDiv_<Mat> >, M>
  782. operator / (const M& a, const MatExpr_<A, M>& b)
  783. { return a/(M)b; }
  785. template<typename A, typename M> static inline
  786. MatExpr_<MatExpr_Op4_<M, M, double, char, M, MatOp_MulDiv_<Mat> >, M>
  787. operator / (const MatExpr_<MatExpr_Op2_<A, double, M, MatOp_Scale_<Mat> >, M>& a,
  788.             const M& b)
  789. { return ((M)a.e.a1/b)*a.e.a2; }
  791. template<typename A, typename M> static inline
  792. MatExpr_<MatExpr_Op4_<M, M, double, char, M, MatOp_MulDiv_<Mat> >, M>
  793. operator / (const M& a,
  794.             const MatExpr_<MatExpr_Op2_<A, double, M, MatOp_Scale_<Mat> >, M>& b)
  795. { return (a/(M)b.e.a1)*(1./b.e.a2); }
  797. template<typename A, typename B, typename M> static inline
  798. MatExpr_<MatExpr_Op4_<M, M, double, char, M, MatOp_MulDiv_<Mat> >, M>
  799. operator / (const MatExpr_<MatExpr_Op2_<A, double, M, MatOp_Scale_<Mat> >, M>& a,
  800.             const MatExpr_<MatExpr_Op2_<B, double, M, MatOp_Scale_<Mat> >, M>& b)
  801. { return ((M)a.e.a1/(M)b.e.a1)*(a.e.a2/b.e.a2); }
  803. template<typename A, typename M> static inline
  804. MatExpr_<MatExpr_Op4_<M, M, double, char, M, MatOp_MulDiv_<Mat> >, M>
  805. operator / (const M& a,
  806.             const MatExpr_<MatExpr_Op2_<A, double, M, MatOp_DivRS_<Mat> >, M>& b)
  807. { return a.mul((M)b.e.a1, 1./b.e.a2); }
  809. template<typename A, typename B, typename M> static inline
  810. MatExpr_<MatExpr_Op4_<M, M, double, char, M, MatOp_MulDiv_<Mat> >, M>
  811. operator / (const MatExpr_<A, M>& a,
  812.             const MatExpr_<MatExpr_Op2_<B, double, M, MatOp_DivRS_<Mat> >, M>& b)
  813. { return ((M)a).mul((M)b.e.a1, 1./b.e.a2); }
  815. static inline
  816. MatExpr_<MatExpr_Op2_<Mat, double, Mat, MatOp_DivRS_<Mat> >, Mat >
  817. operator / (double alpha, const Mat& a)
  818. {
  819.     typedef MatExpr_Op2_<Mat, double, Mat, MatOp_DivRS_<Mat> > MatExpr_Temp;
  820.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(a, alpha));
  821. }
  823. static inline Mat& operator /= (const Mat& a, double alpha)
  824. {
  825.     MatOp_Scale_<Mat>::apply( a, 1./alpha, (Mat&)a );
  826.     return (Mat&)a;
  827. }
  829. template<typename _Tp>
  830. static inline Mat_<_Tp>& operator /= (const Mat_<_Tp>& a, double alpha)
  831. {
  832.     MatOp_Scale_<Mat>::apply( a, 1./alpha, (Mat&)a );
  833.     return (Mat_<_Tp>&)a;
  834. }
  836. template<typename _Tp> static inline
  837. MatExpr_<MatExpr_Op2_<Mat_<_Tp>, double, Mat_<_Tp>, MatOp_DivRS_<Mat> >, Mat_<_Tp> >
  838. operator / (double alpha, const Mat_<_Tp>& a)
  839. {
  840.     typedef MatExpr_Op2_<Mat_<_Tp>, double, Mat_<_Tp>,
  841.         MatOp_DivRS_<Mat> > MatExpr_Temp;
  842.     return MatExpr_<MatExpr_Temp, Mat_<_Tp> >(MatExpr_Temp(a, alpha));
  843. }
  845. template<typename A, typename M> static inline
  846. MatExpr_<MatExpr_Op2_<M, double, M, MatOp_DivRS_<Mat> >, M>
  847. operator / (double alpha, const MatExpr_<A, M>& a)
  848. { return alpha/(M)a; }
  850. template<typename A, typename M> static inline
  851. MatExpr_<MatExpr_Op2_<M, double, M, MatOp_DivRS_<Mat> >, M>
  852. operator / (double alpha,
  853.             const MatExpr_<MatExpr_Op2_<A, double, M, MatOp_Scale_<Mat> >, M>& a)
  854. { return (alpha/a.e.a2)/(M)a.e.a1; }
  856. template<typename A, typename M> static inline
  857. MatExpr_<MatExpr_Op2_<M, double, M, MatOp_Scale_<Mat> >, M>
  858. operator / (double alpha,
  859.             const MatExpr_<MatExpr_Op2_<A, double, M, MatOp_DivRS_<Mat> >, M>& a)
  860. { return (M)a.e.a1*(alpha/a.e.a2); }
  862. static inline Mat& operator /= (const Mat& a, const Mat& b)
  863. {
  864.     MatOp_MulDiv_<Mat>::apply( a, b, 1, '/', (Mat&)a );
  865.     return (Mat&)a;
  866. }
  868. template<typename A, typename M>
  869. static inline M& operator /= (const M& a, const MatExpr_<MatExpr_Op2_<A, double,
  870.                               M, MatOp_Scale_<Mat> >, M>& b)
  871. {
  872.     MatOp_MulDiv_<Mat>::apply( a, (M)b.e.a1, 1./b.e.a2, '/', (M&)a );
  873.     return (M&)a;
  874. }
  876. template<typename A, typename M>
  877. static inline M& operator /= (const M& a, const MatExpr_<MatExpr_Op2_<A, double,
  878.                               M, MatOp_DivRS_<Mat> >, M>& b)
  879. {
  880.     MatOp_MulDiv_<Mat>::apply( a, (M)b.e.a1, 1./b.e.a2, '*', (M&)a );
  881.     return (M&)a;
  882. }
  884. // Mat Inversion and solving linear systems
  886. inline MatExpr_<MatExpr_Op2_<Mat, int, Mat, MatOp_Inv_<Mat> >, Mat>
  887. Mat::inv(int method) const
  888. {
  889.     typedef MatExpr_Op2_<Mat, int, Mat, MatOp_Inv_<Mat> > MatExpr_Temp;
  890.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(*this, method));
  891. }
  893. template<typename _Tp> inline
  894. MatExpr_<MatExpr_Op2_<Mat_<_Tp>, int, Mat_<_Tp>, MatOp_Inv_<Mat> >, Mat_<_Tp> >
  895. Mat_<_Tp>::inv(int method) const
  896. {
  897.     typedef MatExpr_Op2_<Mat_<_Tp>, int, Mat_<_Tp>, MatOp_Inv_<Mat> > MatExpr_Temp;
  898.     return MatExpr_<MatExpr_Temp, Mat_<_Tp> >(MatExpr_Temp(*this, method));
  899. }
  901. template<typename A, typename M> static inline
  902. MatExpr_<MatExpr_Op3_<M, M, int, M, MatOp_Solve_<Mat> >, M>
  903. operator * (const MatExpr_<MatExpr_Op2_<A, int, M, MatOp_Inv_<Mat> >, M>& a,
  904.             const M& b)
  905. {
  906.     typedef MatExpr_Op3_<M, M, int, M, MatOp_Solve_<Mat> > MatExpr_Temp;
  907.     return MatExpr_<MatExpr_Temp, M>(MatExpr_Temp((M)a.e.a1, b, a.e.a2));
  908. }
  910. template<typename A, typename B, typename M> static inline
  911. MatExpr_<MatExpr_Op3_<M, M, int, M, MatOp_Solve_<Mat> >, M>
  912. operator * (const MatExpr_<MatExpr_Op2_<A, int, M, MatOp_Inv_<Mat> >, M>& a,
  913.             const MatExpr_<B, M>& b)
  914. { return a*(M)b; }
  917. /////////////////////////////// Initialization ////////////////////////////////////////
  919. inline MatExpr_Initializer Mat::zeros(int rows, int cols, int type)
  920. {
  921.     typedef MatExpr_Op4_<Size, int, Scalar, int, Mat, MatOp_Set_<Mat> > MatExpr_Temp;
  922.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(Size(cols, rows), type, 0, 0));
  923. }
  925. inline MatExpr_Initializer Mat::zeros(Size size, int type)
  926. {
  927.     return zeros(size.height, size.width, type);
  928. }
  930. inline MatExpr_Initializer Mat::ones(int rows, int cols, int type)
  931. {
  932.     typedef MatExpr_Op4_<Size, int, Scalar, int, Mat, MatOp_Set_<Mat> > MatExpr_Temp;
  933.     return MatExpr_<MatExpr_Temp, Mat>(MatExpr_Temp(Size(cols, rows), type, 1, 1));
  934. }
  936. inline MatExpr_Initializer Mat::ones(Size size, int type)
  937. {
  938.     return ones(size.height, size.width, type);
  939. }
  941. inline MatExpr_Initializer Mat::eye(int rows, int cols, int type)
  942. {
  943.     typedef MatExpr_Op4_<Size, int, Scalar, int, Mat, MatOp_Set_<Mat> > MatExpr_Temp;
  944.     return MatExpr_Initializer(MatExpr_Temp(Size(cols, rows), type, 1, 2));
  945. }
  947. inline MatExpr_Initializer Mat::eye(Size size, int type)
  948. {
  949.     return eye(size.height, size.width, type);
  950. }
  952. static inline MatExpr_Initializer operator * (const MatExpr_Initializer& a, double alpha)
  953. {
  954.     typedef MatExpr_Op4_<Size, int, Scalar, int, Mat, MatOp_Set_<Mat> > MatExpr_Temp;
  955.     return MatExpr_Initializer(MatExpr_Temp(a.e.a1, a.e.a2, a.e.a3*alpha, a.e.a4));
  956. }
  958. static inline MatExpr_Initializer operator * (double alpha, MatExpr_Initializer& a)
  959. {
  960.     typedef MatExpr_Op4_<Size, int, Scalar, int, Mat, MatOp_Set_<Mat> > MatExpr_Temp;
  961.     return MatExpr_Initializer(MatExpr_Temp(a.e.a1, a.e.a2, a.e.a3*alpha, a.e.a4));
  962. }
  964. template<typename _Tp> inline MatExpr_Initializer Mat_<_Tp>::zeros(int rows, int cols)
  965. { return Mat::zeros(rows, cols, DataType<_Tp>::type); }
  967. template<typename _Tp> inline MatExpr_Initializer Mat_<_Tp>::zeros(Size size)
  968. { return Mat::zeros(size, DataType<_Tp>::type); }
  970. template<typename _Tp> inline MatExpr_Initializer Mat_<_Tp>::ones(int rows, int cols)
  971. { return Mat::ones(rows, cols, DataType<_Tp>::type); }
  973. template<typename _Tp> inline MatExpr_Initializer Mat_<_Tp>::ones(Size size)
  974. { return Mat::ones(size, DataType<_Tp>::type); }
  976. template<typename _Tp> inline MatExpr_Initializer Mat_<_Tp>::eye(int rows, int cols)
  977. { return Mat::eye(rows, cols, DataType<_Tp>::type); }
  979. template<typename _Tp> inline MatExpr_Initializer Mat_<_Tp>::eye(Size size)
  980. { return Mat::eye(size, DataType<_Tp>::type); }
  983. //////////// Iterators & Comma initializers //////////////////
  985. template<typename _Tp> inline MatConstIterator_<_Tp>::MatConstIterator_()
  986.     : m(0), ptr(0), sliceEnd(0) {}
  988. template<typename _Tp> inline MatConstIterator_<_Tp>::MatConstIterator_(const Mat_<_Tp>* _m) : m(_m)
  989. {
  990.     if( !_m )
  991.         ptr = sliceEnd = 0;
  992.     else
  993.     {
  994.         ptr = (_Tp*)_m->data;
  995.         sliceEnd = ptr + (_m->isContinuous() ? _m->rows*_m->cols : _m->cols);
  996.     }
  997. }
  999. template<typename _Tp> inline MatConstIterator_<_Tp>::
  1000.     MatConstIterator_(const Mat_<_Tp>* _m, int _row, int _col) : m(_m)
  1001. {
  1002.     if( !_m )
  1003.         ptr = sliceEnd = 0;
  1004.     else
  1005.     {
  1006.         CV_DbgAssert( (unsigned)_row < _m->rows && (unsigned)_col < _m->cols );
  1007.         ptr = (_Tp*)(_m->data + _m->step*_row);
  1008.         sliceEnd = _m->isContinuous() ? (_Tp*)_m->data + _m->rows*_m->cols : ptr + _m->cols;
  1009.         ptr += _col;
  1010.     }
  1011. }
  1013. template<typename _Tp> inline MatConstIterator_<_Tp>::
  1014.     MatConstIterator_(const Mat_<_Tp>* _m, Point _pt) : m(_m)
  1015. {
  1016.     if( !_m )
  1017.         ptr = sliceEnd = 0;
  1018.     else
  1019.     {
  1020.         CV_DbgAssert( (unsigned)_pt.y < (unsigned)_m->rows && (unsigned)_pt.x < (unsigned)_m->cols );
  1021.         ptr = (_Tp*)(_m->data + _m->step*_pt.y);
  1022.         sliceEnd = _m->isContinuous() ? (_Tp*)_m->data + _m->rows*_m->cols : ptr + _m->cols;
  1023.         ptr += _pt.x;
  1024.     }
  1025. }
  1027. template<typename _Tp> inline MatConstIterator_<_Tp>::
  1028.     MatConstIterator_(const MatConstIterator_& it)
  1029.     : m(it.m), ptr(it.ptr), sliceEnd(it.sliceEnd) {}
  1031. template<typename _Tp> inline MatConstIterator_<_Tp>&
  1032.     MatConstIterator_<_Tp>::operator = (const MatConstIterator_& it )
  1033. {
  1034.     m = it.m; ptr = it.ptr; sliceEnd = it.sliceEnd;
  1035.     return *this;
  1036. }
  1038. template<typename _Tp> inline _Tp MatConstIterator_<_Tp>::operator *() const { return *ptr; }
  1040. template<typename _Tp> inline MatConstIterator_<_Tp>& MatConstIterator_<_Tp>::operator += (int ofs)
  1041. {
  1042.     if( !m || ofs == 0 )
  1043.         return *this;
  1044.     ptr += ofs;
  1045.     if( m->isContinuous() )
  1046.     {
  1047.         if( ptr > sliceEnd )
  1048.             ptr = sliceEnd;
  1049.         else if( ptr < (_Tp*)m->data )
  1050.             ptr = (_Tp*)m->data;
  1051.     }
  1052.     else if( ptr >= sliceEnd || ptr < sliceEnd - m->cols )
  1053.     {
  1054.         ptr -= ofs;
  1055.         Point pt = pos();
  1056.         int cols = m->cols;
  1057.         ofs += pt.y*cols + pt.x;
  1058.         if( ofs > cols*m->rows )
  1059.             ofs = cols*m->rows;
  1060.         else if( ofs < 0 )
  1061.             ofs = 0;
  1062.         pt.y = ofs/cols;
  1063.         pt.x = ofs - pt.y*cols;
  1064.         ptr = (_Tp*)(m->data + m->step*pt.y);
  1065.         sliceEnd = ptr + cols;
  1066.         ptr += pt.x;
  1067.     }
  1068.     return *this;
  1069. }
  1071. template<typename _Tp> inline MatConstIterator_<_Tp>& MatConstIterator_<_Tp>::operator -= (int ofs)
  1072. { return (*this += -ofs); }
  1074. template<typename _Tp> inline MatConstIterator_<_Tp>& MatConstIterator_<_Tp>::operator --()
  1075. { return (*this += -1); }
  1077. template<typename _Tp> inline MatConstIterator_<_Tp> MatConstIterator_<_Tp>::operator --(int)
  1078. {
  1079.     MatConstIterator_ b = *this;
  1080.     *this += -1;
  1081.     return b;
  1082. }
  1084. template<typename _Tp> inline MatConstIterator_<_Tp>& MatConstIterator_<_Tp>::operator ++()
  1085. {
  1086.     if( m && ++ptr >= sliceEnd )
  1087.     {
  1088.         --ptr;
  1089.         *this += 1;
  1090.     }
  1091.     return *this;
  1092. }
  1094. template<typename _Tp> inline MatConstIterator_<_Tp> MatConstIterator_<_Tp>::operator ++(int)
  1095. {
  1096.     MatConstIterator_ b = *this;
  1097.     if( m && ++ptr >= sliceEnd )
  1098.     {
  1099.         --ptr;
  1100.         *this += 1;
  1101.     }
  1102.     return b;
  1103. }
  1105. template<typename _Tp> inline Point MatConstIterator_<_Tp>::pos() const
  1106. {
  1107.     if( !m )
  1108.         return Point();
  1109.     if( m->isContinuous() )
  1110.     {
  1111.         int ofs = ptr - (_Tp*)m->data, y = ofs / m->cols, x = ofs - y*m->cols;
  1112.         return Point(x,y);
  1113.     }
  1114.     else
  1115.     {
  1116.         int stepT = m->stepT(), y = (ptr - (_Tp*)m->data)/stepT, x = (ptr - (_Tp*)m->data) - y*stepT;
  1117.         return Point(x,y);
  1118.     }
  1119. }
  1121. template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_() : MatConstIterator_<_Tp>() {}
  1123. template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_(Mat_<_Tp>* _m)
  1124.     : MatConstIterator_<_Tp>(_m) {}
  1126. template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_(Mat_<_Tp>* _m, int _row, int _col)
  1127.     : MatConstIterator_<_Tp>(_m, _row, _col) {}
  1129. template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_(const Mat_<_Tp>* _m, Point _pt)
  1130.     : MatConstIterator_<_Tp>(_m, _pt) {}
  1132. template<typename _Tp> inline MatIterator_<_Tp>::MatIterator_(const MatIterator_& it)
  1133.     : MatConstIterator_<_Tp>(it) {}
  1135. template<typename _Tp> inline MatIterator_<_Tp>& MatIterator_<_Tp>::operator = (const MatIterator_<_Tp>& it )
  1136. {
  1137.     this->m = it.m; this->ptr = it.ptr; this->sliceEnd = it.sliceEnd;
  1138.     return *this;
  1139. }
  1141. template<typename _Tp> inline _Tp& MatIterator_<_Tp>::operator *() const { return *(this->ptr); }
  1143. template<typename _Tp> inline MatIterator_<_Tp>& MatIterator_<_Tp>::operator += (int ofs)
  1144. {
  1145.     MatConstIterator_<_Tp>::operator += (ofs);
  1146.     return *this;
  1147. }
  1149. template<typename _Tp> inline MatIterator_<_Tp>& MatIterator_<_Tp>::operator -= (int ofs)
  1150. {
  1151.     MatConstIterator_<_Tp>::operator += (-ofs);
  1152.     return *this;
  1153. }
  1155. template<typename _Tp> inline MatIterator_<_Tp>& MatIterator_<_Tp>::operator --()
  1156. {
  1157.     MatConstIterator_<_Tp>::operator += (-1);
  1158.     return *this;
  1159. }
  1161. template<typename _Tp> inline MatIterator_<_Tp> MatIterator_<_Tp>::operator --(int)
  1162. {
  1163.     MatIterator_ b = *this;
  1164.     MatConstIterator_<_Tp>::operator += (-1);
  1165.     return b;
  1166. }
  1168. template<typename _Tp> inline MatIterator_<_Tp>& MatIterator_<_Tp>::operator ++()
  1169. {
  1170.     if( this->m && ++this->ptr >= this->sliceEnd )
  1171.     {
  1172.         --this->ptr;
  1173.         MatConstIterator_<_Tp>::operator += (1);
  1174.     }
  1175.     return *this;
  1176. }
  1178. template<typename _Tp> inline MatIterator_<_Tp> MatIterator_<_Tp>::operator ++(int)
  1179. {
  1180.     MatIterator_ b = *this;
  1181.     if( this->m && ++this->ptr >= this->sliceEnd )
  1182.     {
  1183.         --this->ptr;
  1184.         MatConstIterator_<_Tp>::operator += (1);
  1185.     }
  1186.     return b;
  1187. }
  1189. template<typename _Tp> static inline bool
  1190. operator == (const MatConstIterator_<_Tp>& a, const MatConstIterator_<_Tp>& b)
  1191. { return a.m == b.m && a.ptr == b.ptr; }
  1193. template<typename _Tp> static inline bool
  1194. operator != (const MatConstIterator_<_Tp>& a, const MatConstIterator_<_Tp>& b)
  1195. { return !(a == b); }
  1197. template<typename _Tp> static inline bool
  1198. operator < (const MatConstIterator_<_Tp>& a, const MatConstIterator_<_Tp>& b)
  1199. { return a.ptr < b.ptr; }
  1201. template<typename _Tp> static inline bool
  1202. operator > (const MatConstIterator_<_Tp>& a, const MatConstIterator_<_Tp>& b)
  1203. { return a.ptr > b.ptr; }
  1205. template<typename _Tp> static inline bool
  1206. operator <= (const MatConstIterator_<_Tp>& a, const MatConstIterator_<_Tp>& b)
  1207. { return a.ptr <= b.ptr; }
  1209. template<typename _Tp> static inline bool
  1210. operator >= (const MatConstIterator_<_Tp>& a, const MatConstIterator_<_Tp>& b)
  1211. { return a.ptr >= b.ptr; }
  1213. template<typename _Tp> static inline int
  1214. operator - (const MatConstIterator_<_Tp>& b, const MatConstIterator_<_Tp>& a)
  1215. {
  1216.     if( a.m != b.m )
  1217.         return INT_MAX;
  1218.     if( a.sliceEnd == b.sliceEnd )
  1219.         return b.ptr - a.ptr;
  1220.     {
  1221.         Point ap = a.pos(), bp = b.pos();
  1222.         if( bp.y > ap.y )
  1223.             return (bp.y - ap.y - 1)*a.m->cols + (a.m->cols - ap.x) + bp.x;
  1224.         if( bp.y < ap.y )
  1225.             return -((ap.y - bp.y - 1)*a.m->cols + (a.m->cols - bp.x) + ap.x);
  1226.         return bp.x - ap.x;
  1227.     }
  1228. }
  1230. template<typename _Tp> static inline MatConstIterator_<_Tp>
  1231. operator + (const MatConstIterator_<_Tp>& a, int ofs)
  1232. { MatConstIterator_<_Tp> b = a; return b += ofs; }
  1234. template<typename _Tp> static inline MatConstIterator_<_Tp>
  1235. operator + (int ofs, const MatConstIterator_<_Tp>& a)
  1236. { MatConstIterator_<_Tp> b = a; return b += ofs; }
  1238. template<typename _Tp> static inline MatConstIterator_<_Tp>
  1239. operator - (const MatConstIterator_<_Tp>& a, int ofs)
  1240. { MatConstIterator_<_Tp> b = a; return b += -ofs; }
  1242. template<typename _Tp> inline _Tp MatConstIterator_<_Tp>::operator [](int i) const
  1243. { return *(*this + i); }
  1245. template<typename _Tp> static inline MatIterator_<_Tp>
  1246. operator + (const MatIterator_<_Tp>& a, int ofs)
  1247. { MatIterator_<_Tp> b = a; return b += ofs; }
  1249. template<typename _Tp> static inline MatIterator_<_Tp>
  1250. operator + (int ofs, const MatIterator_<_Tp>& a)
  1251. { MatIterator_<_Tp> b = a; return b += ofs; }
  1253. template<typename _Tp> static inline MatIterator_<_Tp>
  1254. operator - (const MatIterator_<_Tp>& a, int ofs)
  1255. { MatIterator_<_Tp> b = a; return b += -ofs; }
  1257. template<typename _Tp> inline _Tp& MatIterator_<_Tp>::operator [](int i) const
  1258. { return *(*this + i); }
  1260. template<typename _Tp> inline MatConstIterator_<_Tp> Mat_<_Tp>::begin() const
  1261. { return Mat::begin<_Tp>(); }
  1263. template<typename _Tp> inline MatConstIterator_<_Tp> Mat_<_Tp>::end() const
  1264. { return Mat::end<_Tp>(); }
  1266. template<typename _Tp> inline MatIterator_<_Tp> Mat_<_Tp>::begin()
  1267. { return Mat::begin<_Tp>(); }
  1269. template<typename _Tp> inline MatIterator_<_Tp> Mat_<_Tp>::end()
  1270. { return Mat::end<_Tp>(); }
  1272. template<typename _Tp> class CV_EXPORTS MatOp_Iter_
  1273. {
  1274. public:    
  1275.     MatOp_Iter_() {}
  1277.     static void apply(const MatIterator_<_Tp>& a, Mat& c, int type=-1)
  1278.     {
  1279.         if( type < 0 )
  1280.             c = *a.m;
  1281.         else
  1282.             a.m->convertTo(c, type);
  1283.     }
  1284. };
  1286. template<typename _Tp> inline MatCommaInitializer_<_Tp>::MatCommaInitializer_(Mat_<_Tp>* _m) :
  1287.     MatExpr_<MatExpr_Op1_<MatIterator_<_Tp>, Mat_<_Tp>,
  1288.         MatOp_Iter_<_Tp> >, Mat_<_Tp> >(MatIterator_<_Tp>(_m)) {}
  1290. template<typename _Tp> template<typename T2> inline MatCommaInitializer_<_Tp>&
  1291. MatCommaInitializer_<_Tp>::operator , (T2 v)
  1292. {
  1293.     CV_DbgAssert( this->e.a1 < this->e.a1.m->end() );
  1294.     *this->e.a1 = _Tp(v); ++this->e.a1;
  1295.     return *this;
  1296. }
  1298. template<typename _Tp> inline MatCommaInitializer_<_Tp>::operator Mat_<_Tp>() const
  1299. {
  1300.     CV_DbgAssert( this->e.a1 == this->e.a1.m->end() );
  1301.     return *this->e.a1.m;
  1302. }
  1304. template<typename _Tp> inline Mat_<_Tp> MatCommaInitializer_<_Tp>::operator *() const
  1305. {
  1306.     CV_DbgAssert( this->e.a1 == this->e.a1.m->end() );
  1307.     return *this->e.a1.m;
  1308. }
  1310. template<typename _Tp> inline void
  1311. MatCommaInitializer_<_Tp>::assignTo(Mat& m, int type) const
  1312. {
  1313.     Mat_<_Tp>(*this).assignTo(m, type);
  1314. }
  1316. template<typename _Tp, typename T2> static inline MatCommaInitializer_<_Tp>
  1317. operator << (const Mat_<_Tp>& m, T2 val)
  1318. {
  1319.     MatCommaInitializer_<_Tp> commaInitializer((Mat_<_Tp>*)&m);
  1320.     return (commaInitializer, val);
  1321. }
  1323. //////////////////////////////// MatND ////////////////////////////////
  1325. inline MatND::MatND()
  1326.  : flags(MAGIC_VAL), dims(0), refcount(0), data(0), datastart(0), dataend(0)
  1327. {
  1328. }
  1330. inline MatND::MatND(int _dims, const int* _sizes, int _type)
  1331.  : flags(MAGIC_VAL), dims(0), refcount(0), data(0), datastart(0), dataend(0)
  1332. {
  1333.     create(_dims, _sizes, _type);
  1334. }
  1336. inline MatND::MatND(int _dims, const int* _sizes, int _type, const Scalar& _s)
  1337.  : flags(MAGIC_VAL), dims(0), refcount(0), data(0), datastart(0), dataend(0)
  1338. {
  1339.     create(_dims, _sizes, _type);
  1340.     *this = _s;
  1341. }
  1343. inline MatND::MatND(const MatND& m)
  1344.  : flags(m.flags), dims(m.dims), refcount(m.refcount),
  1345.  data(m.data), datastart(m.datastart), dataend(m.dataend)
  1346. {
  1347.     int i, d = dims;
  1348.     for( i = 0; i < d; i++ )
  1349.     {
  1350.         size[i] = m.size[i];
  1351.         step[i] = m.step[i];
  1352.     }
  1353.     if( refcount )
  1354.         CV_XADD(refcount, 1);
  1355. }
  1357. inline MatND::MatND(const CvMatND* m, bool copyData)
  1358.   : flags(MAGIC_VAL|(m->type & (CV_MAT_TYPE_MASK|CV_MAT_CONT_FLAG))),
  1359.   dims(m->dims), refcount(0), data(m->data.ptr)
  1360. {
  1361.     int i, d = dims;
  1362.     for( i = 0; i < d; i++ )
  1363.     {
  1364.         size[i] = m->dim[i].size;
  1365.         step[i] = m->dim[i].step;
  1366.     }
  1367.     datastart = data;
  1368.     dataend = datastart + size[0]*step[0];
  1369.     if( copyData )
  1370.     {
  1371.         MatND temp(*this);
  1372.         temp.copyTo(*this);
  1373.     }
  1374. }
  1376. inline MatND::~MatND() { release(); }
  1378. inline MatND& MatND::operator = (const MatND& m)
  1379. {
  1380.     if( this != &m )
  1381.     {
  1382.         if( m.refcount )
  1383.             CV_XADD(m.refcount, 1);
  1384.         release();
  1385.         flags = m.flags;
  1386.         dims = m.dims;
  1387.         data = m.data;
  1388.         datastart = m.datastart;
  1389.         dataend = m.dataend;
  1390.         refcount = m.refcount;
  1391.         int i, d = dims;
  1392.         for( i = 0; i < d; i++ )
  1393.         {
  1394.             size[i] = m.size[i];
  1395.             step[i] = m.step[i];
  1396.         }
  1397.     }
  1398.     return *this;
  1399. }
  1401. inline MatND MatND::clone() const
  1402. {
  1403.     MatND temp;
  1404.     this->copyTo(temp);
  1405.     return temp;
  1406. }
  1408. inline MatND MatND::operator()(const Range* ranges) const
  1409. {
  1410.     return MatND(*this, ranges);
  1411. }
  1413. inline void MatND::assignTo( MatND& m, int type ) const
  1414. {
  1415.     if( type < 0 )
  1416.         m = *this;
  1417.     else
  1418.         convertTo(m, type);
  1419. }
  1421. inline void MatND::addref()
  1422. {
  1423.     if( refcount ) CV_XADD(refcount, 1);
  1424. }
  1426. inline void MatND::release()
  1427. {
  1428.     if( refcount && CV_XADD(refcount, -1) == 1 )
  1429.         fastFree(datastart);
  1430.     dims = 0;
  1431.     data = datastart = dataend = 0;
  1432.     refcount = 0;
  1433. }
  1435. inline bool MatND::isContinuous() const { return (flags & CONTINUOUS_FLAG) != 0; }
  1436. inline size_t MatND::elemSize() const { return getElemSize(flags); }
  1437. inline size_t MatND::elemSize1() const { return CV_ELEM_SIZE1(flags); }
  1438. inline int MatND::type() const { return CV_MAT_TYPE(flags); }
  1439. inline int MatND::depth() const { return CV_MAT_DEPTH(flags); }
  1440. inline int MatND::channels() const { return CV_MAT_CN(flags); }
  1442. inline size_t MatND::step1(int i) const
  1443. { CV_DbgAssert((unsigned)i < (unsigned)dims); return step[i]/elemSize1(); }
  1445. inline uchar* MatND::ptr(int i0)
  1446. {
  1447.     CV_DbgAssert( dims == 1 && data &&
  1448.         (unsigned)i0 < (unsigned)size[0] );
  1449.     return data + i0*step[0];
  1450. }
  1452. inline const uchar* MatND::ptr(int i0) const
  1453. {
  1454.     CV_DbgAssert( dims == 1 && data &&
  1455.         (unsigned)i0 < (unsigned)size[0] );
  1456.     return data + i0*step[0];
  1457. }
  1459. inline uchar* MatND::ptr(int i0, int i1)
  1460. {
  1461.     CV_DbgAssert( dims == 2 && data &&
  1462.         (unsigned)i0 < (unsigned)size[0] &&
  1463.         (unsigned)i1 < (unsigned)size[1] );
  1464.     return data + i0*step[0] + i1*step[1];
  1465. }
  1467. inline const uchar* MatND::ptr(int i0, int i1) const
  1468. {
  1469.     CV_DbgAssert( dims == 2 && data &&
  1470.         (unsigned)i0 < (unsigned)size[0] &&
  1471.         (unsigned)i1 < (unsigned)size[1] );
  1472.     return data + i0*step[0] + i1*step[1];
  1473. }
  1475. inline uchar* MatND::ptr(int i0, int i1, int i2)
  1476. {
  1477.     CV_DbgAssert( dims == 3 && data &&
  1478.         (unsigned)i0 < (unsigned)size[0] &&
  1479.         (unsigned)i1 < (unsigned)size[1] &&
  1480.         (unsigned)i2 < (unsigned)size[2] );
  1481.     return data + i0*step[0] + i1*step[1] + i2*step[2];
  1482. }
  1484. inline const uchar* MatND::ptr(int i0, int i1, int i2) const
  1485. {
  1486.     CV_DbgAssert( dims == 3 && data &&
  1487.         (unsigned)i0 < (unsigned)size[0] &&
  1488.         (unsigned)i1 < (unsigned)size[1] &&
  1489.         (unsigned)i2 < (unsigned)size[2] );
  1490.     return data + i0*step[0] + i1*step[1] + i2*step[2];
  1491. }
  1493. inline uchar* MatND::ptr(const int* idx)
  1494. {
  1495.     int i, d = dims;
  1496.     uchar* p = data;
  1497.     CV_DbgAssert( data );
  1498.     for( i = 0; i < d; i++ )
  1499.     {
  1500.         CV_DbgAssert( (unsigned)idx[i] < (unsigned)size[i] );
  1501.         p += idx[i]*step[i];
  1502.     }
  1503.     return p;
  1504. }
  1506. inline const uchar* MatND::ptr(const int* idx) const
  1507. {
  1508.     int i, d = dims;
  1509.     uchar* p = data;
  1510.     CV_DbgAssert( data );
  1511.     for( i = 0; i < d; i++ )
  1512.     {
  1513.         CV_DbgAssert( (unsigned)idx[i] < (unsigned)size[i] );
  1514.         p += idx[i]*step[i];
  1515.     }
  1516.     return p;
  1517. }
  1519. template<typename _Tp> inline _Tp& MatND::at(int i0)
  1520. { return *(_Tp*)ptr(i0); }
  1521. template<typename _Tp> inline const _Tp& MatND::at(int i0) const
  1522. { return *(const _Tp*)ptr(i0); }
  1523. template<typename _Tp> inline _Tp& MatND::at(int i0, int i1)
  1524. { return *(_Tp*)ptr(i0, i1); }
  1525. template<typename _Tp> inline const _Tp& MatND::at(int i0, int i1) const
  1526. { return *(const _Tp*)ptr(i0, i1); }
  1527. template<typename _Tp> inline _Tp& MatND::at(int i0, int i1, int i2)
  1528. { return *(_Tp*)ptr(i0, i1, i2); }
  1529. template<typename _Tp> inline const _Tp& MatND::at(int i0, int i1, int i2) const
  1530. { return *(const _Tp*)ptr(i0, i1, i2); }
  1531. template<typename _Tp> inline _Tp& MatND::at(const int* idx)
  1532. { return *(_Tp*)ptr(idx); }
  1533. template<typename _Tp> inline const _Tp& MatND::at(const int* idx) const
  1534. { return *(const _Tp*)ptr(idx); }
  1536. inline NAryMatNDIterator::NAryMatNDIterator()
  1537. {
  1538. }
  1540. inline void subtract(const MatND& a, const Scalar& s, MatND& c, const MatND& mask=MatND())
  1541. {
  1542.     add(a, -s, c, mask);
  1543. }
  1546. template<typename _Tp> inline MatND_<_Tp>::MatND_()
  1547. {
  1548.     flags = MAGIC_VAL | DataType<_Tp>::type;
  1549. }
  1551. template<typename _Tp> inline MatND_<_Tp>::MatND_(int _dims, const int* _sizes)
  1552. : MatND(_dims, _sizes, DataType<_Tp>::type)
  1553. {
  1554. }
  1556. template<typename _Tp> inline MatND_<_Tp>::MatND_(int _dims, const int* _sizes, const _Tp& _s)
  1557. : MatND(_dims, _sizes, DataType<_Tp>::type, Scalar(_s))
  1558. {
  1559. }
  1561. template<typename _Tp> inline MatND_<_Tp>::MatND_(const MatND& m)
  1562. {
  1563.     if( m.type() == DataType<_Tp>::type )
  1564.         *this = (const MatND_<_Tp>&)m;
  1565.     else
  1566.         m.convertTo(this, DataType<_Tp>::type);
  1567. }
  1569. template<typename _Tp> inline MatND_<_Tp>::MatND_(const MatND_<_Tp>& m) : MatND(m)
  1570. {
  1571. }
  1573. template<typename _Tp> inline MatND_<_Tp>::MatND_(const MatND_<_Tp>& m, const Range* ranges)
  1574. : MatND(m, ranges)
  1575. {
  1576. }
  1578. template<typename _Tp> inline MatND_<_Tp>::MatND_(const CvMatND* m, bool copyData)
  1579. {
  1580.     *this = MatND(m, copyData || CV_MAT_TYPE(m->type) != DataType<_Tp>::type);
  1581. }
  1583. template<typename _Tp> inline MatND_<_Tp>& MatND_<_Tp>::operator = (const MatND& m)
  1584. {
  1585.     if( DataType<_Tp>::type == m.type() )
  1586.     {
  1587.         Mat::operator = (m);
  1588.         return *this;
  1589.     }
  1590.     if( DataType<_Tp>::depth == m.depth() )
  1591.     {
  1592.         return (*this = m.reshape(DataType<_Tp>::channels));
  1593.     }
  1594.     CV_DbgAssert(DataType<_Tp>::channels == m.channels());
  1595.     m.convertTo(*this, DataType<_Tp>::type);
  1596.     return *this;
  1597. }
  1599. template<typename _Tp> inline MatND_<_Tp>& MatND_<_Tp>::operator = (const MatND_<_Tp>& m)
  1600. {
  1601.     return ((MatND&)*this = m);
  1602. }
  1604. template<typename _Tp> inline MatND_<_Tp>& MatND_<_Tp>::operator = (const _Tp& s)
  1605. {
  1606.     return (MatND&)*this = Scalar(s);
  1607. }
  1609. template<typename _Tp> inline void MatND_<_Tp>::create(int _dims, const int* _sizes)
  1610. {
  1611.     MatND::create(_dims, _sizes, DataType<_Tp>::type);
  1612. }
  1614. template<typename _Tp> template<typename _Tp2> inline MatND_<_Tp>::operator MatND_<_Tp2>() const
  1615. {
  1616.     return MatND_<_Tp2>((const MatND&)*this);
  1617. }
  1619. template<typename _Tp> inline MatND_<_Tp> MatND_<_Tp>::clone() const
  1620. {
  1621.     MatND_<_Tp> temp;
  1622.     this->copyTo(temp);
  1623.     return temp;
  1624. }
  1626. template<typename _Tp> inline MatND_<_Tp>
  1627. MatND_<_Tp>::operator()(const Range* ranges) const
  1628. { return MatND_<_Tp>(*this, ranges); }
  1630. template<typename _Tp> inline size_t MatND_<_Tp>::elemSize() const
  1631. { return CV_ELEM_SIZE(DataType<_Tp>::type); }
  1633. template<typename _Tp> inline size_t MatND_<_Tp>::elemSize1() const
  1634. { return CV_ELEM_SIZE1(DataType<_Tp>::type); }
  1636. template<typename _Tp> inline int MatND_<_Tp>::type() const
  1637. { return DataType<_Tp>::type; }
  1639. template<typename _Tp> inline int MatND_<_Tp>::depth() const
  1640. { return DataType<_Tp>::depth; }
  1642. template<typename _Tp> inline int MatND_<_Tp>::channels() const
  1643. { return DataType<_Tp>::channels; }
  1645. template<typename _Tp> inline size_t MatND_<_Tp>::stepT(int i) const
  1646. {
  1647.     CV_DbgAssert( (unsigned)i < (unsigned)dims );
  1648.     return step[i]/elemSize();
  1649. }
  1651. template<typename _Tp> inline size_t MatND_<_Tp>::step1(int i) const
  1652. {
  1653.     CV_DbgAssert( (unsigned)i < (unsigned)dims );
  1654.     return step[i]/elemSize1();
  1655. }
  1657. template<typename _Tp> inline _Tp& MatND_<_Tp>::operator ()(const int* idx)
  1658. {
  1659.     uchar* ptr = data;
  1660.     int i, d = dims;
  1661.     for( i = 0; i < d; i++ )
  1662.     {
  1663.         int ii = idx[i];
  1664.         CV_DbgAssert( (unsigned)ii < (unsigned)size[i] );
  1665.         ptr += ii*step[i];
  1666.     }
  1667.     return *(_Tp*)ptr;
  1668. }
  1670. template<typename _Tp> inline const _Tp& MatND_<_Tp>::operator ()(const int* idx) const
  1671. {
  1672.     const uchar* ptr = data;
  1673.     int i, d = dims;
  1674.     for( i = 0; i < d; i++ )
  1675.     {
  1676.         int ii = idx[i];
  1677.         CV_DbgAssert( (unsigned)ii < (unsigned)size[i] );
  1678.         ptr += ii*step[i];
  1679.     }
  1680.     return *(const _Tp*)ptr;
  1681. }
  1683. template<typename _Tp> inline _Tp& MatND_<_Tp>::operator ()(int i0)
  1684. {
  1685.     CV_DbgAssert( dims == 1 &&
  1686.                  (unsigned)i0 < (unsigned)size[0] );
  1687.     
  1688.     return *(_Tp*)(data + i0*step[0]);
  1689. }
  1691. template<typename _Tp> inline const _Tp& MatND_<_Tp>::operator ()(int i0) const
  1692. {
  1693.     CV_DbgAssert( dims == 1 &&
  1694.                  (unsigned)i0 < (unsigned)size[0] );
  1695.     
  1696.     return *(const _Tp*)(data + i0*step[0]);
  1697. }
  1698.     
  1699.     
  1700. template<typename _Tp> inline _Tp& MatND_<_Tp>::operator ()(int i0, int i1)
  1701. {
  1702.     CV_DbgAssert( dims == 2 &&
  1703.                  (unsigned)i0 < (unsigned)size[0] &&
  1704.                  (unsigned)i1 < (unsigned)size[1] );
  1705.     
  1706.     return *(_Tp*)(data + i0*step[0] + i1*step[1]);
  1707. }
  1709. template<typename _Tp> inline const _Tp& MatND_<_Tp>::operator ()(int i0, int i1) const
  1710. {
  1711.     CV_DbgAssert( dims == 2 &&
  1712.                  (unsigned)i0 < (unsigned)size[0] &&
  1713.                  (unsigned)i1 < (unsigned)size[1] );
  1714.     
  1715.     return *(const _Tp*)(data + i0*step[0] + i1*step[1]);
  1716. }
  1717.     
  1718.     
  1719. template<typename _Tp> inline _Tp& MatND_<_Tp>::operator ()(int i0, int i1, int i2)
  1720. {
  1721.     CV_DbgAssert( dims == 3 &&
  1722.         (unsigned)i0 < (unsigned)size[0] &&
  1723.         (unsigned)i1 < (unsigned)size[1] &&
  1724.         (unsigned)i2 < (unsigned)size[2] );
  1726.     return *(_Tp*)(data + i0*step[0] + i1*step[1] + i2*step[2]);
  1727. }
  1729. template<typename _Tp> inline const _Tp& MatND_<_Tp>::operator ()(int i0, int i1, int i2) const
  1730. {
  1731.     CV_DbgAssert( dims == 3 &&
  1732.         (unsigned)i0 < (unsigned)size[0] &&
  1733.         (unsigned)i1 < (unsigned)size[1] &&
  1734.         (unsigned)i2 < (unsigned)size[2] );
  1736.     return *(const _Tp*)(data + i0*step[0] + i1*step[1] + i2*step[2]);
  1737. }
  1739.     
  1740. static inline void merge(const vector<MatND>& mv, MatND& dst)
  1741. {
  1742.     merge(&mv[0], mv.size(), dst);
  1743. }
  1744.     
  1745. static inline void split(const MatND& m, vector<MatND>& mv)
  1746. {
  1747.     mv.resize(m.channels());
  1748.     if(m.channels() > 0)
  1749.         split(m, &mv[0]);
  1750. }
  1752. static inline void mixChannels(const vector<MatND>& src, vector<MatND>& dst,
  1753.                                const int* fromTo, int npairs)
  1754. {
  1755.     mixChannels(&src[0], (int)src.size(), &dst[0], (int)dst.size(), fromTo, npairs);
  1756. }   
  1758. //////////////////////////////// SparseMat ////////////////////////////////
  1760. inline SparseMat::SparseMat()
  1761. : flags(MAGIC_VAL), hdr(0)
  1762. {
  1763. }
  1765. inline SparseMat::SparseMat(int _dims, const int* _sizes, int _type)
  1766. : flags(MAGIC_VAL), hdr(0)
  1767. {
  1768.     create(_dims, _sizes, _type);
  1769. }
  1771. inline SparseMat::SparseMat(const SparseMat& m)
  1772. : flags(m.flags), hdr(m.hdr)
  1773. {
  1774.     addref();
  1775. }
  1777. inline SparseMat::~SparseMat()
  1778. {
  1779.     release();
  1780. }
  1782. inline SparseMat& SparseMat::operator = (const SparseMat& m)
  1783. {
  1784.     if( this != &m )
  1785.     {
  1786.         if( m.hdr )
  1787.             CV_XADD(&m.hdr->refcount, 1);
  1788.         release();
  1789.         flags = m.flags;
  1790.         hdr = m.hdr;
  1791.     }
  1792.     return *this;
  1793. }
  1795. inline SparseMat& SparseMat::operator = (const Mat& m)
  1796. { return (*this = SparseMat(m)); }
  1798. inline SparseMat& SparseMat::operator = (const MatND& m)
  1799. { return (*this = SparseMat(m)); }
  1801. inline SparseMat SparseMat::clone() const
  1802. {
  1803.     SparseMat temp;
  1804.     this->copyTo(temp);
  1805.     return temp;
  1806. }
  1809. inline void SparseMat::assignTo( SparseMat& m, int type ) const
  1810. {
  1811.     if( type < 0 )
  1812.         m = *this;
  1813.     else
  1814.         convertTo(m, type);
  1815. }
  1817. inline void SparseMat::addref()
  1818. { if( hdr ) CV_XADD(&hdr->refcount, 1); }
  1820. inline void SparseMat::release()
  1821. {
  1822.     if( hdr && CV_XADD(&hdr->refcount, -1) == 1 )
  1823.         delete hdr;
  1824.     hdr = 0;
  1825. }
  1827. inline size_t SparseMat::elemSize() const
  1828. { return CV_ELEM_SIZE(flags); }
  1830. inline size_t SparseMat::elemSize1() const
  1831. { return CV_ELEM_SIZE1(flags); }
  1833. inline int SparseMat::type() const
  1834. { return CV_MAT_TYPE(flags); }
  1836. inline int SparseMat::depth() const
  1837. { return CV_MAT_DEPTH(flags); }
  1839. inline int SparseMat::channels() const
  1840. { return CV_MAT_CN(flags); }
  1842. inline const int* SparseMat::size() const
  1843. {
  1844.     return hdr ? hdr->size : 0;
  1845. }
  1847. inline int SparseMat::size(int i) const
  1848. {
  1849.     if( hdr )
  1850.     {
  1851.         CV_DbgAssert((unsigned)i < (unsigned)hdr->dims);
  1852.         return hdr->size[i];
  1853.     }
  1854.     return 0;
  1855. }
  1857. inline int SparseMat::dims() const
  1858. {
  1859.     return hdr ? hdr->dims : 0;
  1860. }
  1862. inline size_t SparseMat::nzcount() const
  1863. {
  1864.     return hdr ? hdr->nodeCount : 0;
  1865. }
  1867. inline size_t SparseMat::hash(int i0) const
  1868. {
  1869.     return (size_t)i0;
  1870. }
  1872. inline size_t SparseMat::hash(int i0, int i1) const
  1873. {
  1874.     return (size_t)(unsigned)i0*HASH_SCALE + (unsigned)i1;
  1875. }
  1877. inline size_t SparseMat::hash(int i0, int i1, int i2) const
  1878. {
  1879.     return ((size_t)(unsigned)i0*HASH_SCALE + (unsigned)i1)*HASH_SCALE + (unsigned)i2;
  1880. }
  1882. inline size_t SparseMat::hash(const int* idx) const
  1883. {
  1884.     size_t h = (unsigned)idx[0];
  1885.     if( !hdr )
  1886.         return 0;
  1887.     int i, d = hdr->dims;
  1888.     for( i = 1; i < d; i++ )
  1889.         h = h*HASH_SCALE + (unsigned)idx[i];
  1890.     return h;
  1891. }
  1893. template<typename _Tp> inline _Tp& SparseMat::ref(int i0, size_t* hashval)
  1894. { return *(_Tp*)((SparseMat*)this)->ptr(i0, true, hashval); }
  1895.     
  1896. template<typename _Tp> inline _Tp& SparseMat::ref(int i0, int i1, size_t* hashval)
  1897. { return *(_Tp*)((SparseMat*)this)->ptr(i0, i1, true, hashval); }
  1899. template<typename _Tp> inline _Tp& SparseMat::ref(int i0, int i1, int i2, size_t* hashval)
  1900. { return *(_Tp*)((SparseMat*)this)->ptr(i0, i1, i2, true, hashval); }
  1902. template<typename _Tp> inline _Tp& SparseMat::ref(const int* idx, size_t* hashval)
  1903. { return *(_Tp*)((SparseMat*)this)->ptr(idx, true, hashval); }
  1905. template<typename _Tp> inline _Tp SparseMat::value(int i0, size_t* hashval) const
  1906. {
  1907.     const _Tp* p = (const _Tp*)((SparseMat*)this)->ptr(i0, false, hashval);
  1908.     return p ? *p : _Tp();
  1909. }    
  1910.     
  1911. template<typename _Tp> inline _Tp SparseMat::value(int i0, int i1, size_t* hashval) const
  1912. {
  1913.     const _Tp* p = (const _Tp*)((SparseMat*)this)->ptr(i0, i1, false, hashval);
  1914.     return p ? *p : _Tp();
  1915. }
  1917. template<typename _Tp> inline _Tp SparseMat::value(int i0, int i1, int i2, size_t* hashval) const
  1918. {
  1919.     const _Tp* p = (const _Tp*)((SparseMat*)this)->ptr(i0, i1, i2, false, hashval);
  1920.     return p ? *p : _Tp();
  1921. }
  1923. template<typename _Tp> inline _Tp SparseMat::value(const int* idx, size_t* hashval) const
  1924. {
  1925.     const _Tp* p = (const _Tp*)((SparseMat*)this)->ptr(idx, false, hashval);
  1926.     return p ? *p : _Tp();
  1927. }
  1929. template<typename _Tp> inline const _Tp* SparseMat::find(int i0, size_t* hashval) const
  1930. { return (const _Tp*)((SparseMat*)this)->ptr(i0, true, hashval); }
  1931.     
  1932. template<typename _Tp> inline const _Tp* SparseMat::find(int i0, int i1, size_t* hashval) const
  1933. { return (const _Tp*)((SparseMat*)this)->ptr(i0, i1, true, hashval); }
  1935. template<typename _Tp> inline const _Tp* SparseMat::find(int i0, int i1, int i2, size_t* hashval) const
  1936. { return (const _Tp*)((SparseMat*)this)->ptr(i0, i1, i2, true, hashval); }
  1938. template<typename _Tp> inline const _Tp* SparseMat::find(const int* idx, size_t* hashval) const
  1939. { return (const _Tp*)((SparseMat*)this)->ptr(idx, true, hashval); }
  1941. template<typename _Tp> inline _Tp& SparseMat::value(Node* n)
  1942. { return *(_Tp*)((uchar*)n + hdr->valueOffset); }
  1944. template<typename _Tp> inline const _Tp& SparseMat::value(const Node* n) const
  1945. { return *(const _Tp*)((const uchar*)n + hdr->valueOffset); }
  1947. inline SparseMat::Node* SparseMat::node(size_t nidx)
  1948. { return (Node*)&hdr->pool[nidx]; }
  1950. inline const SparseMat::Node* SparseMat::node(size_t nidx) const
  1951. { return (const Node*)&hdr->pool[nidx]; }
  1953. inline SparseMatIterator SparseMat::begin()
  1954. { return SparseMatIterator(this); }
  1956. inline SparseMatConstIterator SparseMat::begin() const
  1957. { return SparseMatConstIterator(this); }
  1959. inline SparseMatIterator SparseMat::end()
  1960. { SparseMatIterator it(this); it.seekEnd(); return it; }
  1961.     
  1962. inline SparseMatConstIterator SparseMat::end() const
  1963. { SparseMatConstIterator it(this); it.seekEnd(); return it; }
  1964.     
  1965. template<typename _Tp> inline SparseMatIterator_<_Tp> SparseMat::begin()
  1966. { return SparseMatIterator_<_Tp>(this); }
  1967.     
  1968. template<typename _Tp> inline SparseMatConstIterator_<_Tp> SparseMat::begin() const
  1969. { return SparseMatConstIterator_<_Tp>(this); }
  1970.     
  1971. template<typename _Tp> inline SparseMatIterator_<_Tp> SparseMat::end()
  1972. { SparseMatIterator_<_Tp> it(this); it.seekEnd(); return it; }
  1974. template<typename _Tp> inline SparseMatConstIterator_<_Tp> SparseMat::end() const
  1975. { SparseMatConstIterator_<_Tp> it(this); it.seekEnd(); return it; }
  1976.     
  1977.     
  1978. inline SparseMatConstIterator::SparseMatConstIterator()
  1979. : m(0), hashidx(0), ptr(0)
  1980. {
  1981. }
  1983. inline SparseMatConstIterator::SparseMatConstIterator(const SparseMatConstIterator& it)
  1984. : m(it.m), hashidx(it.hashidx), ptr(it.ptr)
  1985. {
  1986. }
  1988. static inline bool operator == (const SparseMatConstIterator& it1, const SparseMatConstIterator& it2)
  1989. { return it1.m == it2.m && it1.hashidx == it2.hashidx && it1.ptr == it2.ptr; }
  1991. static inline bool operator != (const SparseMatConstIterator& it1, const SparseMatConstIterator& it2)
  1992. { return !(it1 == it2); }
  1995. inline SparseMatConstIterator& SparseMatConstIterator::operator = (const SparseMatConstIterator& it)
  1996. {
  1997.     if( this != &it )
  1998.     {
  1999.         m = it.m;
  2000.         hashidx = it.hashidx;
  2001.         ptr = it.ptr;
  2002.     }
  2003.     return *this;
  2004. }
  2006. template<typename _Tp> inline const _Tp& SparseMatConstIterator::value() const
  2007. { return *(_Tp*)ptr; }
  2009. inline const SparseMat::Node* SparseMatConstIterator::node() const
  2010. {
  2011.     return ptr && m && m->hdr ?
  2012.         (const SparseMat::Node*)(ptr - m->hdr->valueOffset) : 0;
  2013. }
  2015. inline SparseMatConstIterator SparseMatConstIterator::operator ++(int)
  2016. {
  2017.     SparseMatConstIterator it = *this;
  2018.     ++*this;
  2019.     return it;
  2020. }
  2022.     
  2023. inline void SparseMatConstIterator::seekEnd()
  2024. {
  2025.     if( m && m->hdr )
  2026.     {
  2027.         hashidx = m->hdr->hashtab.size();
  2028.         ptr = 0;
  2029.     }
  2030. }
  2031.     
  2032. inline SparseMatIterator::SparseMatIterator()
  2033. {}
  2035. inline SparseMatIterator::SparseMatIterator(SparseMat* _m)
  2036. : SparseMatConstIterator(_m)
  2037. {}
  2039. inline SparseMatIterator::SparseMatIterator(const SparseMatIterator& it)
  2040. : SparseMatConstIterator(it)
  2041. {
  2042. }
  2044. inline SparseMatIterator& SparseMatIterator::operator = (const SparseMatIterator& it)
  2045. {
  2046.     (SparseMatConstIterator&)*this = it;
  2047.     return *this;
  2048. }
  2050. template<typename _Tp> inline _Tp& SparseMatIterator::value() const
  2051. { return *(_Tp*)ptr; }
  2053. inline SparseMat::Node* SparseMatIterator::node() const
  2054. {
  2055.     return (SparseMat::Node*)SparseMatConstIterator::node();
  2056. }
  2058. inline SparseMatIterator& SparseMatIterator::operator ++()
  2059. {
  2060.     SparseMatConstIterator::operator ++();
  2061.     return *this;
  2062. }
  2064. inline SparseMatIterator SparseMatIterator::operator ++(int)
  2065. {
  2066.     SparseMatIterator it = *this;
  2067.     ++*this;
  2068.     return it;
  2069. }
  2072. template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_()
  2073. { flags = MAGIC_VAL | DataType<_Tp>::type; }
  2075. template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(int _dims, const int* _sizes)
  2076. : SparseMat(_dims, _sizes, DataType<_Tp>::type)
  2077. {}
  2079. template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const SparseMat& m)
  2080. {
  2081.     if( m.type() == DataType<_Tp>::type )
  2082.         *this = (const SparseMat_<_Tp>&)m;
  2083.     else
  2084.         m.convertTo(this, DataType<_Tp>::type);
  2085. }
  2087. template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const SparseMat_<_Tp>& m)
  2088. {
  2089.     this->flags = m.flags;
  2090.     this->hdr = m.hdr;
  2091.     if( this->hdr )
  2092.         CV_XADD(&this->hdr->refcount, 1);
  2093. }
  2095. template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const Mat& m)
  2096. {
  2097.     SparseMat sm(m);
  2098.     *this = sm;
  2099. }
  2101. template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const MatND& m)
  2102. {
  2103.     SparseMat sm(m);
  2104.     *this = sm;
  2105. }
  2107. template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const CvSparseMat* m)
  2108. {
  2109.     SparseMat sm(m);
  2110.     *this = sm;
  2111. }
  2113. template<typename _Tp> inline SparseMat_<_Tp>&
  2114. SparseMat_<_Tp>::operator = (const SparseMat_<_Tp>& m)
  2115. {
  2116.     if( this != &m )
  2117.     {
  2118.         if( m.hdr ) CV_XADD(&m.hdr->refcount, 1);
  2119.         release();
  2120.         flags = m.flags;
  2121.         hdr = m.hdr;
  2122.     }
  2123.     return *this;
  2124. }
  2126. template<typename _Tp> inline SparseMat_<_Tp>&
  2127. SparseMat_<_Tp>::operator = (const SparseMat& m)
  2128. {
  2129.     if( m.type() == DataType<_Tp>::type )
  2130.         return (*this = (const SparseMat_<_Tp>&)m);
  2131.     m.convertTo(*this, DataType<_Tp>::type);
  2132.     return *this;
  2133. }
  2135. template<typename _Tp> inline SparseMat_<_Tp>&
  2136. SparseMat_<_Tp>::operator = (const Mat& m)
  2137. { return (*this = SparseMat(m)); }
  2139. template<typename _Tp> inline SparseMat_<_Tp>&
  2140. SparseMat_<_Tp>::operator = (const MatND& m)
  2141. { return (*this = SparseMat(m)); }
  2143. template<typename _Tp> inline SparseMat_<_Tp>
  2144. SparseMat_<_Tp>::clone() const
  2145. {
  2146.     SparseMat_<_Tp> m;
  2147.     this->copyTo(m);
  2148.     return m;
  2149. }
  2151. template<typename _Tp> inline void
  2152. SparseMat_<_Tp>::create(int _dims, const int* _sizes)
  2153. {
  2154.     SparseMat::create(_dims, _sizes, DataType<_Tp>::type);
  2155. }
  2157. template<typename _Tp> inline
  2158. SparseMat_<_Tp>::operator CvSparseMat*() const
  2159. {
  2160.     return SparseMat::operator CvSparseMat*();
  2161. }
  2163. template<typename _Tp> inline int SparseMat_<_Tp>::type() const
  2164. { return DataType<_Tp>::type; }
  2166. template<typename _Tp> inline int SparseMat_<_Tp>::depth() const
  2167. { return DataType<_Tp>::depth; }
  2169. template<typename _Tp> inline int SparseMat_<_Tp>::channels() const
  2170. { return DataType<_Tp>::channels; }
  2172. template<typename _Tp> inline _Tp&
  2173. SparseMat_<_Tp>::ref(int i0, size_t* hashval)
  2174. { return SparseMat::ref<_Tp>(i0, hashval); }
  2176. template<typename _Tp> inline _Tp
  2177. SparseMat_<_Tp>::operator()(int i0, size_t* hashval) const
  2178. { return SparseMat::value<_Tp>(i0, hashval); }    
  2179.     
  2180. template<typename _Tp> inline _Tp&
  2181. SparseMat_<_Tp>::ref(int i0, int i1, size_t* hashval)
  2182. { return SparseMat::ref<_Tp>(i0, i1, hashval); }
  2184. template<typename _Tp> inline _Tp
  2185. SparseMat_<_Tp>::operator()(int i0, int i1, size_t* hashval) const
  2186. { return SparseMat::value<_Tp>(i0, i1, hashval); }
  2188. template<typename _Tp> inline _Tp&
  2189. SparseMat_<_Tp>::ref(int i0, int i1, int i2, size_t* hashval)
  2190. { return SparseMat::ref<_Tp>(i0, i1, i2, hashval); }
  2192. template<typename _Tp> inline _Tp
  2193. SparseMat_<_Tp>::operator()(int i0, int i1, int i2, size_t* hashval) const
  2194. { return SparseMat::value<_Tp>(i0, i1, i2, hashval); }
  2196. template<typename _Tp> inline _Tp&
  2197. SparseMat_<_Tp>::ref(const int* idx, size_t* hashval)
  2198. { return SparseMat::ref<_Tp>(idx, hashval); }
  2200. template<typename _Tp> inline _Tp
  2201. SparseMat_<_Tp>::operator()(const int* idx, size_t* hashval) const
  2202. { return SparseMat::value<_Tp>(idx, hashval); }
  2204. template<typename _Tp> inline SparseMatIterator_<_Tp> SparseMat_<_Tp>::begin()
  2205. { return SparseMatIterator_<_Tp>(this); }
  2207. template<typename _Tp> inline SparseMatConstIterator_<_Tp> SparseMat_<_Tp>::begin() const
  2208. { return SparseMatConstIterator_<_Tp>(this); }
  2210. template<typename _Tp> inline SparseMatIterator_<_Tp> SparseMat_<_Tp>::end()
  2211. { SparseMatIterator_<_Tp> it(this); it.seekEnd(); return it; }
  2212.     
  2213. template<typename _Tp> inline SparseMatConstIterator_<_Tp> SparseMat_<_Tp>::end() const
  2214. { SparseMatConstIterator_<_Tp> it(this); it.seekEnd(); return it; }
  2216. template<typename _Tp> inline
  2217. SparseMatConstIterator_<_Tp>::SparseMatConstIterator_()
  2218. {}
  2220. template<typename _Tp> inline
  2221. SparseMatConstIterator_<_Tp>::SparseMatConstIterator_(const SparseMat_<_Tp>* _m)
  2222. : SparseMatConstIterator(_m)
  2223. {}
  2225. template<typename _Tp> inline
  2226. SparseMatConstIterator_<_Tp>::SparseMatConstIterator_(const SparseMatConstIterator_<_Tp>& it)
  2227. : SparseMatConstIterator(it)
  2228. {}
  2230. template<typename _Tp> inline SparseMatConstIterator_<_Tp>&
  2231. SparseMatConstIterator_<_Tp>::operator = (const SparseMatConstIterator_<_Tp>& it)
  2232. { return ((SparseMatConstIterator&)*this = it); }
  2234. template<typename _Tp> inline const _Tp&
  2235. SparseMatConstIterator_<_Tp>::operator *() const
  2236. { return *(const _Tp*)this->ptr; }
  2238. template<typename _Tp> inline SparseMatConstIterator_<_Tp>&
  2239. SparseMatConstIterator_<_Tp>::operator ++()
  2240. {
  2241.     SparseMatConstIterator::operator ++();
  2242.     return *this;
  2243. }
  2245. template<typename _Tp> inline SparseMatConstIterator_<_Tp>
  2246. SparseMatConstIterator_<_Tp>::operator ++(int)
  2247. {
  2248.     SparseMatConstIterator it = *this;
  2249.     SparseMatConstIterator::operator ++();
  2250.     return it;
  2251. }
  2253. template<typename _Tp> inline
  2254. SparseMatIterator_<_Tp>::SparseMatIterator_()
  2255. {}
  2257. template<typename _Tp> inline
  2258. SparseMatIterator_<_Tp>::SparseMatIterator_(SparseMat_<_Tp>* _m)
  2259. : SparseMatConstIterator_<_Tp>(_m)
  2260. {}
  2262. template<typename _Tp> inline
  2263. SparseMatIterator_<_Tp>::SparseMatIterator_(const SparseMatIterator_<_Tp>& it)
  2264. : SparseMatConstIterator_<_Tp>(it)
  2265. {}
  2267. template<typename _Tp> inline SparseMatIterator_<_Tp>&
  2268. SparseMatIterator_<_Tp>::operator = (const SparseMatIterator_<_Tp>& it)
  2269. { return ((SparseMatIterator&)*this = it); }
  2271. template<typename _Tp> inline _Tp&
  2272. SparseMatIterator_<_Tp>::operator *() const
  2273. { return *(_Tp*)this->ptr; }
  2275. template<typename _Tp> inline SparseMatIterator_<_Tp>&
  2276. SparseMatIterator_<_Tp>::operator ++()
  2277. {
  2278.     SparseMatConstIterator::operator ++();
  2279.     return *this;
  2280. }
  2282. template<typename _Tp> inline SparseMatIterator_<_Tp>
  2283. SparseMatIterator_<_Tp>::operator ++(int)
  2284. {
  2285.     SparseMatIterator it = *this;
  2286.     SparseMatConstIterator::operator ++();
  2287.     return it;
  2288. }
  2289.     
  2290. }
  2292. #endif
  2293. #endif