t                  43 3rdparty/include/ffmpeg_/libavutil/mem.h     #define DECLARE_ALIGNED(n,t,v)      t __attribute__ ((aligned (n))) v
t                  44 3rdparty/include/ffmpeg_/libavutil/mem.h     #define DECLARE_ASM_CONST(n,t,v)    const t __attribute__ ((aligned (n))) v
t                  46 3rdparty/include/ffmpeg_/libavutil/mem.h     #define DECLARE_ALIGNED(n,t,v)                      \
t                  48 3rdparty/include/ffmpeg_/libavutil/mem.h         t __attribute__((aligned(n))) v
t                  49 3rdparty/include/ffmpeg_/libavutil/mem.h     #define DECLARE_ASM_CONST(n,t,v)                    \
t                  51 3rdparty/include/ffmpeg_/libavutil/mem.h         static const t __attribute__((aligned(n))) v
t                  53 3rdparty/include/ffmpeg_/libavutil/mem.h     #define DECLARE_ALIGNED(n,t,v)      t __attribute__ ((aligned (n))) v
t                  54 3rdparty/include/ffmpeg_/libavutil/mem.h     #define DECLARE_ASM_CONST(n,t,v)    static const t av_used __attribute__ ((aligned (n))) v
t                  56 3rdparty/include/ffmpeg_/libavutil/mem.h     #define DECLARE_ALIGNED(n,t,v)      __declspec(align(n)) t v
t                  57 3rdparty/include/ffmpeg_/libavutil/mem.h     #define DECLARE_ASM_CONST(n,t,v)    __declspec(align(n)) static const t v
t                  59 3rdparty/include/ffmpeg_/libavutil/mem.h     #define DECLARE_ALIGNED(n,t,v)      t v
t                  60 3rdparty/include/ffmpeg_/libavutil/mem.h     #define DECLARE_ASM_CONST(n,t,v)    static const t v
t                 278 3rdparty/include/ffmpeg_/libavutil/mem.h     size_t t = a * b;
t                 281 3rdparty/include/ffmpeg_/libavutil/mem.h     if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b)
t                 283 3rdparty/include/ffmpeg_/libavutil/mem.h     *r = t;
t                 917 3rdparty/libjasper/jas_cm.c     jas_cmreal_t t;
t                 920 3rdparty/libjasper/jas_cm.c     t = x * (lut->size - 1);
t                 921 3rdparty/libjasper/jas_cm.c     lo = floor(t);
t                 924 3rdparty/libjasper/jas_cm.c     hi = ceil(t);
t                 927 3rdparty/libjasper/jas_cm.c     return lut->data[lo] + (t - lo) * (lut->data[hi] - lut->data[lo]);
t                 914 3rdparty/libjasper/jas_image.c     uint_fast32_t t;
t                 924 3rdparty/libjasper/jas_image.c     t = inttobits(v, cmpt->prec_, cmpt->sgnd_);
t                 926 3rdparty/libjasper/jas_image.c         c = (t >> (8 * (cmpt->cps_ - 1))) & 0xff;
t                 930 3rdparty/libjasper/jas_image.c         t <<= 8;
t                1167 3rdparty/libjasper/jas_image.c     jas_image_coord_t t;
t                1181 3rdparty/libjasper/jas_image.c             t = cmpt->tlx_ + cmpt->hstep_ * (cmpt->width_ - 1);
t                1182 3rdparty/libjasper/jas_image.c             if (t > tmpbrx)
t                1183 3rdparty/libjasper/jas_image.c                 tmpbrx = t;
t                1184 3rdparty/libjasper/jas_image.c             t = cmpt->tly_ + cmpt->vstep_ * (cmpt->height_ - 1);
t                1185 3rdparty/libjasper/jas_image.c             if (t > tmpbry)
t                1186 3rdparty/libjasper/jas_image.c                 tmpbry = t;
t                 125 3rdparty/libjasper/jas_tmr.c     double t;
t                 126 3rdparty/libjasper/jas_tmr.c     t = ((tmr->stop.ru_utime.tv_sec * 1e6 + tmr->stop.ru_utime.tv_usec) -
t                 128 3rdparty/libjasper/jas_tmr.c     t += ((tmr->stop.ru_stime.tv_sec * 1e6 + tmr->stop.ru_stime.tv_usec) -
t                 130 3rdparty/libjasper/jas_tmr.c     return t;
t                 217 3rdparty/libjasper/jasper/jas_types.h #define	JAS_CAST(t, e) \
t                 218 3rdparty/libjasper/jasper/jas_types.h     ((t) (e))
t                1775 3rdparty/libjasper/jpc_dec.c     int t;
t                1784 3rdparty/libjasper/jpc_dec.c             t = jas_matrix_get(x, i, j);
t                1785 3rdparty/libjasper/jpc_dec.c             if (t) {
t                1786 3rdparty/libjasper/jpc_dec.c                 t = jpc_fix_mul(t, absstepsize);
t                1788 3rdparty/libjasper/jpc_dec.c                 t = 0;
t                1790 3rdparty/libjasper/jpc_dec.c             jas_matrix_set(x, i, j, t);
t                1490 3rdparty/libjasper/jpc_enc.c     jpc_fix_t t;
t                1498 3rdparty/libjasper/jpc_enc.c             t = jas_matrix_get(data, i, j);
t                1501 3rdparty/libjasper/jpc_enc.c     if (t < 0) {
t                1502 3rdparty/libjasper/jpc_enc.c         t = jpc_fix_neg(jpc_fix_div(jpc_fix_neg(t), stepsize));
t                1504 3rdparty/libjasper/jpc_enc.c         t = jpc_fix_div(t, stepsize);
t                1508 3rdparty/libjasper/jpc_enc.c             jas_matrix_set(data, i, j, t);
t                 241 3rdparty/libjasper/jpc_t1cod.c     float t;
t                 267 3rdparty/libjasper/jpc_t1cod.c         t = i * jpc_pow2i(-JPC_NMSEDEC_FRACBITS);
t                 268 3rdparty/libjasper/jpc_t1cod.c         u = t;
t                 269 3rdparty/libjasper/jpc_t1cod.c         v = t - 1.5;
t                 273 3rdparty/libjasper/jpc_t1cod.c         u = t - 1.0;
t                 275 3rdparty/libjasper/jpc_t1cod.c             v = t - 1.5;
t                 277 3rdparty/libjasper/jpc_t1cod.c             v = t - 0.5;
t                 299 3rdparty/libjasper/jpc_t1cod.c     int t;
t                 310 3rdparty/libjasper/jpc_t1cod.c         t = h;
t                 312 3rdparty/libjasper/jpc_t1cod.c         v = t;
t                 559 3rdparty/libjasper/jpc_t1dec.c     int t; \
t                 563 3rdparty/libjasper/jpc_t1dec.c         t = (v ? (poshalf) : (neghalf)); \
t                 564 3rdparty/libjasper/jpc_t1dec.c         *(dp) += (*(dp) < 0) ? (-t) : t; \
t                 655 3rdparty/libjasper/jpc_t1dec.c     jpc_fix_t t; \
t                 661 3rdparty/libjasper/jpc_t1dec.c         t = (v ? poshalf : neghalf); \
t                 662 3rdparty/libjasper/jpc_t1dec.c         *(dp) += (*(dp) < 0) ? (-t) : t; \
t                 202 3rdparty/libjasper/jpc_t1enc.c     int t;
t                 370 3rdparty/libjasper/jpc_t1enc.c                 t = (pass->mqencstate.lastbyte == 0xff) ? 1 : 0;
t                 372 3rdparty/libjasper/jpc_t1enc.c                     adjust = 4 + t;
t                 374 3rdparty/libjasper/jpc_t1enc.c                     adjust = 5 + t;
t                 426 3rdparty/libpng/pngpriv.h #     define png_alignof(type) offsetof(struct{char c; type t;}, t)
t                 438 3rdparty/libpng/pngrtran.c                   png_byte t;
t                 440 3rdparty/libpng/pngrtran.c                   t = png_ptr->quantize_sort[j];
t                 442 3rdparty/libpng/pngrtran.c                   png_ptr->quantize_sort[j + 1] = t;
t                 541 3rdparty/libpng/pngrtran.c          png_dsortp t;
t                 544 3rdparty/libpng/pngrtran.c          t = NULL;
t                 589 3rdparty/libpng/pngrtran.c                      t = (png_dsortp)png_malloc_warn(png_ptr,
t                 592 3rdparty/libpng/pngrtran.c                      if (t == NULL)
t                 595 3rdparty/libpng/pngrtran.c                      t->next = hash[d];
t                 596 3rdparty/libpng/pngrtran.c                      t->left = (png_byte)i;
t                 597 3rdparty/libpng/pngrtran.c                      t->right = (png_byte)j;
t                 598 3rdparty/libpng/pngrtran.c                      hash[d] = t;
t                 601 3rdparty/libpng/pngrtran.c                if (t == NULL)
t                 605 3rdparty/libpng/pngrtran.c             if (t != NULL)
t                 680 3rdparty/libpng/pngrtran.c                      t = p->next;
t                 682 3rdparty/libpng/pngrtran.c                      p = t;
t                 279 3rdparty/libpng/pngtrans.c          png_byte t = *rp;
t                 281 3rdparty/libpng/pngtrans.c          *(rp + 1) = t;
t                 107 3rdparty/libtiff/tif_aux.c         double t = (double)i/((double) n-1.);
t                 108 3rdparty/libtiff/tif_aux.c         tf[0][i] = (uint16)floor(65535.*pow(t, 2.2) + .5);
t                  93 3rdparty/libtiff/tif_fax3.c #define isAligned(p,t) ((((size_t)(p)) & (sizeof (t)-1)) == 0)
t                 265 3rdparty/libtiff/tif_fax3.c #define	SWAP(t,a,b)	{ t x; x = (a); (a) = (b); (b) = x; }
t                 622 3rdparty/libtiff/tif_fax3.c     int t;								\
t                 624 3rdparty/libtiff/tif_fax3.c     for (t = length-1; t >= 0; t--)					\
t                 625 3rdparty/libtiff/tif_fax3.c     putchar(code & (1<<t) ? '1' : '0');				\
t                1376 3rdparty/libtiff/tif_fax3.c #define SWAP(t,a,b) { t x; x = (a); (a) = (b); (b) = x; }
t                 194 3rdparty/libtiff/tif_fax3.h #define DEBUG_SHOW putchar(BitAcc & (1 << t) ? '1' : '0')
t                 196 3rdparty/libtiff/tif_fax3.h     int t;								\
t                 201 3rdparty/libtiff/tif_fax3.h     for (t = 0; t < TabEnt->Width; t++)					\
t                 208 3rdparty/libtiff/tif_fax3.h     int t;								\
t                 213 3rdparty/libtiff/tif_fax3.h     for (t = 0; t < TabEnt->Width; t++)					\
t                 414 3rdparty/libtiff/tif_lzw.c             int t;
t                 416 3rdparty/libtiff/tif_lzw.c             t = codep->value;
t                 418 3rdparty/libtiff/tif_lzw.c             *tp = t;
t                 526 3rdparty/libtiff/tif_lzw.c                 int t;
t                 528 3rdparty/libtiff/tif_lzw.c                 t = codep->value;
t                 530 3rdparty/libtiff/tif_lzw.c                 *tp = t;
t                 184 3rdparty/libtiff/tif_pixarlog.c #define CLAMP12(t) (((t) < 3071) ? (uint16) (t) : 3071)
t                  39 3rdparty/libtiff/tif_swab.c     unsigned char t;
t                  41 3rdparty/libtiff/tif_swab.c     t = cp[1]; cp[1] = cp[0]; cp[0] = t;
t                  50 3rdparty/libtiff/tif_swab.c     unsigned char t;
t                  52 3rdparty/libtiff/tif_swab.c     t = cp[3]; cp[3] = cp[0]; cp[0] = t;
t                  53 3rdparty/libtiff/tif_swab.c     t = cp[2]; cp[2] = cp[1]; cp[1] = t;
t                  62 3rdparty/libtiff/tif_swab.c     unsigned char t;
t                  64 3rdparty/libtiff/tif_swab.c     t = cp[7]; cp[7] = cp[0]; cp[0] = t;
t                  65 3rdparty/libtiff/tif_swab.c     t = cp[6]; cp[6] = cp[1]; cp[1] = t;
t                  66 3rdparty/libtiff/tif_swab.c     t = cp[5]; cp[5] = cp[2]; cp[2] = t;
t                  67 3rdparty/libtiff/tif_swab.c     t = cp[4]; cp[4] = cp[3]; cp[3] = t;
t                  76 3rdparty/libtiff/tif_swab.c     register unsigned char t;
t                  81 3rdparty/libtiff/tif_swab.c         t = cp[1]; cp[1] = cp[0]; cp[0] = t;
t                  92 3rdparty/libtiff/tif_swab.c     unsigned char t;
t                  97 3rdparty/libtiff/tif_swab.c         t = cp[2]; cp[2] = cp[0]; cp[0] = t;
t                 108 3rdparty/libtiff/tif_swab.c     register unsigned char t;
t                 113 3rdparty/libtiff/tif_swab.c         t = cp[3]; cp[3] = cp[0]; cp[0] = t;
t                 114 3rdparty/libtiff/tif_swab.c         t = cp[2]; cp[2] = cp[1]; cp[1] = t;
t                 125 3rdparty/libtiff/tif_swab.c     register unsigned char t;
t                 130 3rdparty/libtiff/tif_swab.c         t = cp[7]; cp[7] = cp[0]; cp[0] = t;
t                 131 3rdparty/libtiff/tif_swab.c         t = cp[6]; cp[6] = cp[1]; cp[1] = t;
t                 132 3rdparty/libtiff/tif_swab.c         t = cp[5]; cp[5] = cp[2]; cp[2] = t;
t                 133 3rdparty/libtiff/tif_swab.c         t = cp[4]; cp[4] = cp[3]; cp[3] = t;
t                 144 3rdparty/libtiff/tif_swab.c     unsigned char t;
t                 146 3rdparty/libtiff/tif_swab.c     t = cp[3]; cp[3] = cp[0]; cp[0] = t;
t                 147 3rdparty/libtiff/tif_swab.c     t = cp[2]; cp[2] = cp[1]; cp[1] = t;
t                 156 3rdparty/libtiff/tif_swab.c     register unsigned char t;
t                 161 3rdparty/libtiff/tif_swab.c         t = cp[3]; cp[3] = cp[0]; cp[0] = t;
t                 162 3rdparty/libtiff/tif_swab.c         t = cp[2]; cp[2] = cp[1]; cp[1] = t;
t                 173 3rdparty/libtiff/tif_swab.c     unsigned char t;
t                 175 3rdparty/libtiff/tif_swab.c     t = cp[7]; cp[7] = cp[0]; cp[0] = t;
t                 176 3rdparty/libtiff/tif_swab.c     t = cp[6]; cp[6] = cp[1]; cp[1] = t;
t                 177 3rdparty/libtiff/tif_swab.c     t = cp[5]; cp[5] = cp[2]; cp[2] = t;
t                 178 3rdparty/libtiff/tif_swab.c     t = cp[4]; cp[4] = cp[3]; cp[3] = t;
t                 187 3rdparty/libtiff/tif_swab.c     register unsigned char t;
t                 192 3rdparty/libtiff/tif_swab.c         t = cp[7]; cp[7] = cp[0]; cp[0] = t;
t                 193 3rdparty/libtiff/tif_swab.c         t = cp[6]; cp[6] = cp[1]; cp[1] = t;
t                 194 3rdparty/libtiff/tif_swab.c         t = cp[5]; cp[5] = cp[2]; cp[2] = t;
t                 195 3rdparty/libtiff/tif_swab.c         t = cp[4]; cp[4] = cp[3]; cp[3] = t;
t                 206 3rdparty/libtiff/tiffiop.h #define isPseudoTag(t) (t > 0xffff)            /* is tag value normal or pseudo */
t                 254 3rdparty/libtiff/tiffiop.h #define TIFFSafeMultiply(t,v,m) ((((t)(m) != (t)0) && (((t)(((v)*(m))/(m))) == (t)(v))) ? (t)((v)*(m)) : (t)0)
t                 543 3rdparty/libwebp/dec/tree.c   int t, b, c, p;
t                 544 3rdparty/libwebp/dec/tree.c   for (t = 0; t < NUM_TYPES; ++t) {
t                 548 3rdparty/libwebp/dec/tree.c           if (VP8GetBit(br, CoeffsUpdateProba[t][b][c][p])) {
t                 549 3rdparty/libwebp/dec/tree.c             proba->coeffs_[t][b][c][p] = VP8GetValue(br, 8);
t                 544 3rdparty/libwebp/dsp/dec.c                                      int step, int t, int it) {
t                 547 3rdparty/libwebp/dsp/dec.c   if ((2 * abs0[255 + p0 - q0] + abs1[255 + p1 - q1]) > t)
t                 260 3rdparty/libwebp/dsp/dec_sse2.c   __m128i t = a;                                                               \
t                 261 3rdparty/libwebp/dsp/dec_sse2.c   t = _mm_slli_epi16(t, 8);                                                    \
t                 262 3rdparty/libwebp/dsp/dec_sse2.c   t = _mm_srai_epi16(t, N);                                                    \
t                 263 3rdparty/libwebp/dsp/dec_sse2.c   t = _mm_srli_epi16(t, 8);                                                    \
t                 268 3rdparty/libwebp/dsp/dec_sse2.c   a = _mm_or_si128(t, a);                                                      \
t                  73 3rdparty/libwebp/dsp/upsampling_sse2.c   const __m128i t = _mm_avg_epu8(b, c);        /* t = (b + c + 1) / 2 */       \
t                  74 3rdparty/libwebp/dsp/upsampling_sse2.c   const __m128i st = _mm_xor_si128(s, t);      /* st = s^t */                  \
t                  82 3rdparty/libwebp/dsp/upsampling_sse2.c   const __m128i t4 = _mm_avg_epu8(s, t);                                       \
t                  86 3rdparty/libwebp/dsp/upsampling_sse2.c   GET_M(bc, t, diag1);                  /* diag1 = (a + 3b + 3c + d) / 8 */    \
t                  87 3rdparty/libwebp/enc/filter.c                                      int step, int t, int it) {
t                  90 3rdparty/libwebp/enc/filter.c   if ((2 * abs0[255 + p0 - q0] + abs1[255 + p1 - q1]) > t)
t                 183 3rdparty/libwebp/enc/frame.c   int t, b, c, p;
t                 184 3rdparty/libwebp/enc/frame.c   for (t = 0; t < NUM_TYPES; ++t) {
t                 188 3rdparty/libwebp/enc/frame.c           const proba_t stats = proba->stats_[t][b][c][p];
t                 191 3rdparty/libwebp/enc/frame.c           const int update_proba = VP8CoeffsUpdateProba[t][b][c][p];
t                 192 3rdparty/libwebp/enc/frame.c           const int old_p = VP8CoeffsProba0[t][b][c][p];
t                 202 3rdparty/libwebp/enc/frame.c             proba->coeffs_[t][b][c][p] = new_p;
t                 206 3rdparty/libwebp/enc/frame.c             proba->coeffs_[t][b][c][p] = old_p;
t                 289 3rdparty/libwebp/enc/frame.c   const uint16_t* t = res->cost[n][ctx0];
t                 302 3rdparty/libwebp/enc/frame.c       cost += t[0];
t                 303 3rdparty/libwebp/enc/frame.c       t = res->cost[b][0];
t                 308 3rdparty/libwebp/enc/frame.c     cost += VP8LevelCost(t, v);
t                 312 3rdparty/libwebp/enc/frame.c       t = res->cost[b][ctx];
t                 320 3rdparty/libwebp/enc/frame.c     cost += VP8LevelCost(t, v);
t                  80 3rdparty/libwebp/enc/token.c #define TOKEN_ID(t, b, ctx, p) \
t                  81 3rdparty/libwebp/enc/token.c     ((p) + NUM_PROBAS * ((ctx) + NUM_CTX * ((b) + NUM_BANDS * (t))))
t                 491 3rdparty/libwebp/enc/tree.c   int t, b, c, p;
t                 492 3rdparty/libwebp/enc/tree.c   for (t = 0; t < NUM_TYPES; ++t) {
t                 496 3rdparty/libwebp/enc/tree.c           const uint8_t p0 = probas->coeffs_[t][b][c][p];
t                 497 3rdparty/libwebp/enc/tree.c           const int update = (p0 != VP8CoeffsProba0[t][b][c][p]);
t                 498 3rdparty/libwebp/enc/tree.c           if (VP8PutBit(bw, update, VP8CoeffsUpdateProba[t][b][c][p])) {
t                 144 3rdparty/openexr/Half/half.cpp     int t = 14 - e;
t                 145 3rdparty/openexr/Half/half.cpp     int a = (1 << (t - 1)) - 1;
t                 146 3rdparty/openexr/Half/half.cpp     int b = (m >> t) & 1;
t                 148 3rdparty/openexr/Half/half.cpp     m = (m + a + b) >> t;
t                 345 3rdparty/openexr/IlmImf/ImfAttribute.h     TypedAttribute<T> *t =
t                 348 3rdparty/openexr/IlmImf/ImfAttribute.h     if (t == 0)
t                 351 3rdparty/openexr/IlmImf/ImfAttribute.h     return t;
t                 359 3rdparty/openexr/IlmImf/ImfAttribute.h     const TypedAttribute<T> *t =
t                 362 3rdparty/openexr/IlmImf/ImfAttribute.h     if (t == 0)
t                 365 3rdparty/openexr/IlmImf/ImfAttribute.h     return t;
t                 224 3rdparty/openexr/IlmImf/ImfB44Compressor.cpp     unsigned short t[16];
t                 229 3rdparty/openexr/IlmImf/ImfB44Compressor.cpp         t[i] = 0x8000;
t                 231 3rdparty/openexr/IlmImf/ImfB44Compressor.cpp         t[i] = ~s[i];
t                 233 3rdparty/openexr/IlmImf/ImfB44Compressor.cpp         t[i] = s[i] | 0x8000;
t                 243 3rdparty/openexr/IlmImf/ImfB44Compressor.cpp     if (tMax < t[i])
t                 244 3rdparty/openexr/IlmImf/ImfB44Compressor.cpp         tMax = t[i];
t                 274 3rdparty/openexr/IlmImf/ImfB44Compressor.cpp         d[i] = shiftAndRound (tMax - t[i], shift);
t                 322 3rdparty/openexr/IlmImf/ImfB44Compressor.cpp     b[0] = (t[0] >> 8);
t                 323 3rdparty/openexr/IlmImf/ImfB44Compressor.cpp     b[1] =  t[0];
t                 336 3rdparty/openexr/IlmImf/ImfB44Compressor.cpp     t[0] = tMax - (d[0] << shift);
t                 343 3rdparty/openexr/IlmImf/ImfB44Compressor.cpp     b[ 0] = (t[0] >> 8);
t                 344 3rdparty/openexr/IlmImf/ImfB44Compressor.cpp     b[ 1] =  t[0];
t                  54 3rdparty/openexr/IlmImf/ImfChannelList.cpp Channel::Channel (PixelType t, int xs, int ys, bool pl):
t                  55 3rdparty/openexr/IlmImf/ImfChannelList.cpp     type (t),
t                  52 3rdparty/openexr/IlmImf/ImfFrameBuffer.cpp Slice::Slice (PixelType t,
t                  62 3rdparty/openexr/IlmImf/ImfFrameBuffer.cpp     type (t),
t                 104 3rdparty/openexr/IlmImf/ImfOutputFile.cpp OutSliceInfo::OutSliceInfo (PixelType t,
t                 110 3rdparty/openexr/IlmImf/ImfOutputFile.cpp     type (t),
t                 235 3rdparty/openexr/IlmImf/ImfRleCompressor.cpp     unsigned char *t = (unsigned char *) _tmpBuffer + 1;
t                 237 3rdparty/openexr/IlmImf/ImfRleCompressor.cpp     int p = t[-1];
t                 239 3rdparty/openexr/IlmImf/ImfRleCompressor.cpp     while (t < stop)
t                 241 3rdparty/openexr/IlmImf/ImfRleCompressor.cpp         int d = int (t[0]) - p + (128 + 256);
t                 242 3rdparty/openexr/IlmImf/ImfRleCompressor.cpp         p = t[0];
t                 243 3rdparty/openexr/IlmImf/ImfRleCompressor.cpp         t[0] = d;
t                 244 3rdparty/openexr/IlmImf/ImfRleCompressor.cpp         ++t;
t                 291 3rdparty/openexr/IlmImf/ImfRleCompressor.cpp     unsigned char *t = (unsigned char *) _tmpBuffer + 1;
t                 294 3rdparty/openexr/IlmImf/ImfRleCompressor.cpp     while (t < stop)
t                 296 3rdparty/openexr/IlmImf/ImfRleCompressor.cpp         int d = int (t[-1]) + int (t[0]) - 128;
t                 297 3rdparty/openexr/IlmImf/ImfRleCompressor.cpp         t[0] = d;
t                 298 3rdparty/openexr/IlmImf/ImfRleCompressor.cpp         ++t;
t                 109 3rdparty/openexr/IlmImf/ImfTiledOutputFile.cpp TOutSliceInfo::TOutSliceInfo (PixelType t,
t                 116 3rdparty/openexr/IlmImf/ImfTiledOutputFile.cpp     type (t),
t                 348 3rdparty/openexr/IlmImf/ImfTimeCode.cpp     unsigned int t = _time;
t                 350 3rdparty/openexr/IlmImf/ImfTimeCode.cpp     t &= ~((1 << 6) | (1 << 15) | (1 << 23) | (1 << 30) | (1 << 31));
t                 352 3rdparty/openexr/IlmImf/ImfTimeCode.cpp     t |= ((unsigned int) bgf0() << 15);
t                 353 3rdparty/openexr/IlmImf/ImfTimeCode.cpp     t |= ((unsigned int) bgf2() << 23);
t                 354 3rdparty/openexr/IlmImf/ImfTimeCode.cpp     t |= ((unsigned int) bgf1() << 30);
t                 355 3rdparty/openexr/IlmImf/ImfTimeCode.cpp     t |= ((unsigned int) fieldPhase() << 31);
t                 357 3rdparty/openexr/IlmImf/ImfTimeCode.cpp     return t;
t                 137 3rdparty/openexr/IlmImf/ImfZipCompressor.cpp     unsigned char *t = (unsigned char *) _tmpBuffer + 1;
t                 139 3rdparty/openexr/IlmImf/ImfZipCompressor.cpp     int p = t[-1];
t                 141 3rdparty/openexr/IlmImf/ImfZipCompressor.cpp     while (t < stop)
t                 143 3rdparty/openexr/IlmImf/ImfZipCompressor.cpp         int d = int (t[0]) - p + (128 + 256);
t                 144 3rdparty/openexr/IlmImf/ImfZipCompressor.cpp         p = t[0];
t                 145 3rdparty/openexr/IlmImf/ImfZipCompressor.cpp         t[0] = d;
t                 146 3rdparty/openexr/IlmImf/ImfZipCompressor.cpp         ++t;
t                 200 3rdparty/openexr/IlmImf/ImfZipCompressor.cpp     unsigned char *t = (unsigned char *) _tmpBuffer + 1;
t                 203 3rdparty/openexr/IlmImf/ImfZipCompressor.cpp     while (t < stop)
t                 205 3rdparty/openexr/IlmImf/ImfZipCompressor.cpp         int d = int (t[-1]) + int (t[0]) - 128;
t                 206 3rdparty/openexr/IlmImf/ImfZipCompressor.cpp         t[0] = d;
t                 207 3rdparty/openexr/IlmImf/ImfZipCompressor.cpp         ++t;
t                 144 3rdparty/openexr/IlmThread/IlmThread.h     void operator = (const Thread& t);	// not implemented
t                 145 3rdparty/openexr/IlmThread/IlmThread.h     Thread (const Thread& t);		// not implemented
t                  67 3rdparty/openexr/IlmThread/IlmThreadPosix.cpp threadLoop (void * t)
t                  69 3rdparty/openexr/IlmThread/IlmThreadPosix.cpp     return (reinterpret_cast<Thread*>(t))->run();
t                  59 3rdparty/openexr/IlmThread/IlmThreadWin32.cpp threadLoop (void * t)
t                  61 3rdparty/openexr/IlmThread/IlmThreadWin32.cpp     reinterpret_cast<Thread*>(t)->run();
t                 803 3rdparty/openexr/Imath/ImathBoxAlgo.h         T t = d / r.dir.x;
t                 805 3rdparty/openexr/Imath/ImathBoxAlgo.h         if (tBackMin > t)
t                 806 3rdparty/openexr/Imath/ImathBoxAlgo.h         tBackMin = t;
t                 812 3rdparty/openexr/Imath/ImathBoxAlgo.h         T t = (r.dir.x > 1 || d < TMAX * r.dir.x)? d / r.dir.x: TMAX;
t                 814 3rdparty/openexr/Imath/ImathBoxAlgo.h         if (tFrontMax < t)
t                 816 3rdparty/openexr/Imath/ImathBoxAlgo.h         tFrontMax = t;
t                 819 3rdparty/openexr/Imath/ImathBoxAlgo.h         ip.y = clamp (r.pos.y + t * r.dir.y, b.min.y, b.max.y);
t                 820 3rdparty/openexr/Imath/ImathBoxAlgo.h         ip.z = clamp (r.pos.z + t * r.dir.z, b.min.z, b.max.z);
t                 833 3rdparty/openexr/Imath/ImathBoxAlgo.h         T t = d / r.dir.x;
t                 835 3rdparty/openexr/Imath/ImathBoxAlgo.h         if (tBackMin > t)
t                 836 3rdparty/openexr/Imath/ImathBoxAlgo.h         tBackMin = t;
t                 842 3rdparty/openexr/Imath/ImathBoxAlgo.h         T t = (r.dir.x < -1 || d > TMAX * r.dir.x)? d / r.dir.x: TMAX;
t                 844 3rdparty/openexr/Imath/ImathBoxAlgo.h         if (tFrontMax < t)
t                 846 3rdparty/openexr/Imath/ImathBoxAlgo.h         tFrontMax = t;
t                 849 3rdparty/openexr/Imath/ImathBoxAlgo.h         ip.y = clamp (r.pos.y + t * r.dir.y, b.min.y, b.max.y);
t                 850 3rdparty/openexr/Imath/ImathBoxAlgo.h         ip.z = clamp (r.pos.z + t * r.dir.z, b.min.z, b.max.z);
t                 873 3rdparty/openexr/Imath/ImathBoxAlgo.h         T t = d / r.dir.y;
t                 875 3rdparty/openexr/Imath/ImathBoxAlgo.h         if (tBackMin > t)
t                 876 3rdparty/openexr/Imath/ImathBoxAlgo.h         tBackMin = t;
t                 882 3rdparty/openexr/Imath/ImathBoxAlgo.h         T t = (r.dir.y > 1 || d < TMAX * r.dir.y)? d / r.dir.y: TMAX;
t                 884 3rdparty/openexr/Imath/ImathBoxAlgo.h         if (tFrontMax < t)
t                 886 3rdparty/openexr/Imath/ImathBoxAlgo.h         tFrontMax = t;
t                 888 3rdparty/openexr/Imath/ImathBoxAlgo.h         ip.x = clamp (r.pos.x + t * r.dir.x, b.min.x, b.max.x);
t                 890 3rdparty/openexr/Imath/ImathBoxAlgo.h         ip.z = clamp (r.pos.z + t * r.dir.z, b.min.z, b.max.z);
t                 903 3rdparty/openexr/Imath/ImathBoxAlgo.h         T t = d / r.dir.y;
t                 905 3rdparty/openexr/Imath/ImathBoxAlgo.h         if (tBackMin > t)
t                 906 3rdparty/openexr/Imath/ImathBoxAlgo.h         tBackMin = t;
t                 912 3rdparty/openexr/Imath/ImathBoxAlgo.h         T t = (r.dir.y < -1 || d > TMAX * r.dir.y)? d / r.dir.y: TMAX;
t                 914 3rdparty/openexr/Imath/ImathBoxAlgo.h         if (tFrontMax < t)
t                 916 3rdparty/openexr/Imath/ImathBoxAlgo.h         tFrontMax = t;
t                 918 3rdparty/openexr/Imath/ImathBoxAlgo.h         ip.x = clamp (r.pos.x + t * r.dir.x, b.min.x, b.max.x);
t                 920 3rdparty/openexr/Imath/ImathBoxAlgo.h         ip.z = clamp (r.pos.z + t * r.dir.z, b.min.z, b.max.z);
t                 943 3rdparty/openexr/Imath/ImathBoxAlgo.h         T t = d / r.dir.z;
t                 945 3rdparty/openexr/Imath/ImathBoxAlgo.h         if (tBackMin > t)
t                 946 3rdparty/openexr/Imath/ImathBoxAlgo.h         tBackMin = t;
t                 952 3rdparty/openexr/Imath/ImathBoxAlgo.h         T t = (r.dir.z > 1 || d < TMAX * r.dir.z)? d / r.dir.z: TMAX;
t                 954 3rdparty/openexr/Imath/ImathBoxAlgo.h         if (tFrontMax < t)
t                 956 3rdparty/openexr/Imath/ImathBoxAlgo.h         tFrontMax = t;
t                 958 3rdparty/openexr/Imath/ImathBoxAlgo.h         ip.x = clamp (r.pos.x + t * r.dir.x, b.min.x, b.max.x);
t                 959 3rdparty/openexr/Imath/ImathBoxAlgo.h         ip.y = clamp (r.pos.y + t * r.dir.y, b.min.y, b.max.y);
t                 973 3rdparty/openexr/Imath/ImathBoxAlgo.h         T t = d / r.dir.z;
t                 975 3rdparty/openexr/Imath/ImathBoxAlgo.h         if (tBackMin > t)
t                 976 3rdparty/openexr/Imath/ImathBoxAlgo.h         tBackMin = t;
t                 982 3rdparty/openexr/Imath/ImathBoxAlgo.h         T t = (r.dir.z < -1 || d > TMAX * r.dir.z)? d / r.dir.z: TMAX;
t                 984 3rdparty/openexr/Imath/ImathBoxAlgo.h         if (tFrontMax < t)
t                 986 3rdparty/openexr/Imath/ImathBoxAlgo.h         tFrontMax = t;
t                 988 3rdparty/openexr/Imath/ImathBoxAlgo.h         ip.x = clamp (r.pos.x + t * r.dir.x, b.min.x, b.max.x);
t                 989 3rdparty/openexr/Imath/ImathBoxAlgo.h         ip.y = clamp (r.pos.y + t * r.dir.y, b.min.y, b.max.y);
t                  63 3rdparty/openexr/Imath/ImathColorAlgo.cpp     double t = val*(1-(sat*(1-f)));
t                  67 3rdparty/openexr/Imath/ImathColorAlgo.cpp       case 0: x = val; y = t; z = p; break;
t                  69 3rdparty/openexr/Imath/ImathColorAlgo.cpp       case 2: x = p; y = val; z = t; break;
t                  71 3rdparty/openexr/Imath/ImathColorAlgo.cpp       case 4: x = t; y = p; z = val; break;
t                  95 3rdparty/openexr/Imath/ImathColorAlgo.cpp     double t = val*(1-(sat*(1-f)));
t                  99 3rdparty/openexr/Imath/ImathColorAlgo.cpp       case 0: r = val; g = t; b = p; break;
t                 101 3rdparty/openexr/Imath/ImathColorAlgo.cpp       case 2: r = p; g = val; b = t; break;
t                 103 3rdparty/openexr/Imath/ImathColorAlgo.cpp       case 4: r = t; g = p; b = val; break;
t                 545 3rdparty/openexr/Imath/ImathEuler.h     T t = x;
t                 547 3rdparty/openexr/Imath/ImathEuler.h     z = t;
t                 621 3rdparty/openexr/Imath/ImathEuler.h     T t = x;
t                 623 3rdparty/openexr/Imath/ImathEuler.h     z = t;
t                  94 3rdparty/openexr/Imath/ImathFrame.h     Vec3<T> t = pj - pi; t.normalizeExc();
t                  96 3rdparty/openexr/Imath/ImathFrame.h     Vec3<T> n = t.cross( pk - pi ); n.normalize();
t                  99 3rdparty/openexr/Imath/ImathFrame.h         int i = fabs( t[0] ) < fabs( t[1] ) ? 0 : 1;
t                 100 3rdparty/openexr/Imath/ImathFrame.h         if( fabs( t[2] ) < fabs( t[i] )) i = 2;
t                 103 3rdparty/openexr/Imath/ImathFrame.h         n = t.cross( v ); n.normalize();
t                 106 3rdparty/openexr/Imath/ImathFrame.h     Vec3<T> b = t.cross( n );
t                 110 3rdparty/openexr/Imath/ImathFrame.h     M[0][0] =  t[0]; M[0][1] =  t[1]; M[0][2] =  t[2]; M[0][3] = 0.0,
t                 202 3rdparty/openexr/Imath/ImathFrustum.h inline Frustum<T>::Frustum(T n, T f, T l, T r, T t, T b, bool o)
t                 204 3rdparty/openexr/Imath/ImathFrustum.h     set(n,f,l,r,t,b,o);
t                 255 3rdparty/openexr/Imath/ImathFrustum.h void Frustum<T>::set(T n, T f, T l, T r, T t, T b, bool o)
t                 262 3rdparty/openexr/Imath/ImathFrustum.h     _top	    = t;
t                 450 3rdparty/openexr/Imath/ImathFrustum.h Frustum<T> Frustum<T>::window(T l, T r, T t, T b) const
t                 455 3rdparty/openexr/Imath/ImathFrustum.h     Vec2<T> tr = screenToLocal( Vec2<T>(r,t) );
t                  69 3rdparty/openexr/Imath/ImathFun.h lerp (T a, T b, Q t)
t                  71 3rdparty/openexr/Imath/ImathFun.h     return (T) (a * (1 - t) + b * t);
t                  77 3rdparty/openexr/Imath/ImathFun.h ulerp (T a, T b, Q t)
t                  79 3rdparty/openexr/Imath/ImathFun.h     return (T) ((a > b)? (a - (a - b) * t): (a + (b - a) * t));
t                 125 3rdparty/openexr/Imath/ImathFun.h cmpt (T a, T b, T t)
t                 127 3rdparty/openexr/Imath/ImathFun.h     return (Imath::abs (a - b) <= t)? 0 : cmp (a, b);
t                 133 3rdparty/openexr/Imath/ImathFun.h iszero (T a, T t)
t                 135 3rdparty/openexr/Imath/ImathFun.h     return (Imath::abs (a) <= t) ? 1 : 0;
t                 141 3rdparty/openexr/Imath/ImathFun.h equal (T1 a, T2 b, T3 t)
t                 143 3rdparty/openexr/Imath/ImathFun.h     return Imath::abs (a - b) <= t;
t                  50 3rdparty/openexr/Imath/ImathGL.h inline void glTranslate ( const Imath::V3f &t ) { glTranslatef(t.x,t.y,t.z); }
t                  52 3rdparty/openexr/Imath/ImathGL.h inline void glTexCoord( const Imath::V2f &t )
t                  54 3rdparty/openexr/Imath/ImathGL.h     glTexCoord2f(t.x,t.y);
t                 340 3rdparty/openexr/Imath/ImathMatrix.h     const Matrix33 &    setTranslation (const Vec2<S> &t);
t                 355 3rdparty/openexr/Imath/ImathMatrix.h     const Matrix33 &    translate (const Vec2<S> &t);
t                 474 3rdparty/openexr/Imath/ImathMatrix.h     Matrix44 (Matrix33<T> r, Vec3<T> t);
t                 722 3rdparty/openexr/Imath/ImathMatrix.h     const Matrix44 &    setTranslation (const Vec3<S> &t);
t                 737 3rdparty/openexr/Imath/ImathMatrix.h     const Matrix44 &    translate (const Vec3<S> &t);
t                1444 3rdparty/openexr/Imath/ImathMatrix.h     Matrix33 t (*this);
t                1452 3rdparty/openexr/Imath/ImathMatrix.h         T pivotsize = t[i][i];
t                1459 3rdparty/openexr/Imath/ImathMatrix.h             T tmp = t[j][i];
t                1485 3rdparty/openexr/Imath/ImathMatrix.h                 tmp = t[i][j];
t                1486 3rdparty/openexr/Imath/ImathMatrix.h                 t[i][j] = t[pivot][j];
t                1487 3rdparty/openexr/Imath/ImathMatrix.h                 t[pivot][j] = tmp;
t                1497 3rdparty/openexr/Imath/ImathMatrix.h             T f = t[j][i] / t[i][i];
t                1501 3rdparty/openexr/Imath/ImathMatrix.h                 t[j][k] -= f * t[i][k];
t                1513 3rdparty/openexr/Imath/ImathMatrix.h         if ((f = t[i][i]) == 0)
t                1523 3rdparty/openexr/Imath/ImathMatrix.h             t[i][j] /= f;
t                1529 3rdparty/openexr/Imath/ImathMatrix.h             f = t[j][i];
t                1533 3rdparty/openexr/Imath/ImathMatrix.h                 t[j][k] -= f * t[i][k];
t                1768 3rdparty/openexr/Imath/ImathMatrix.h Matrix33<T>::setTranslation (const Vec2<S> &t)
t                1778 3rdparty/openexr/Imath/ImathMatrix.h     x[2][0] = t[0];
t                1779 3rdparty/openexr/Imath/ImathMatrix.h     x[2][1] = t[1];
t                1795 3rdparty/openexr/Imath/ImathMatrix.h Matrix33<T>::translate (const Vec2<S> &t)
t                1797 3rdparty/openexr/Imath/ImathMatrix.h     x[2][0] += t[0] * x[0][0] + t[1] * x[1][0];
t                1798 3rdparty/openexr/Imath/ImathMatrix.h     x[2][1] += t[0] * x[0][1] + t[1] * x[1][1];
t                1799 3rdparty/openexr/Imath/ImathMatrix.h     x[2][2] += t[0] * x[0][2] + t[1] * x[1][2];
t                1965 3rdparty/openexr/Imath/ImathMatrix.h Matrix44<T>::Matrix44 (Matrix33<T> r, Vec3<T> t)
t                1979 3rdparty/openexr/Imath/ImathMatrix.h     x[3][0] = t[0];
t                1980 3rdparty/openexr/Imath/ImathMatrix.h     x[3][1] = t[1];
t                1981 3rdparty/openexr/Imath/ImathMatrix.h     x[3][2] = t[2];
t                2713 3rdparty/openexr/Imath/ImathMatrix.h     Matrix44 t (*this);
t                2721 3rdparty/openexr/Imath/ImathMatrix.h         T pivotsize = t[i][i];
t                2728 3rdparty/openexr/Imath/ImathMatrix.h             T tmp = t[j][i];
t                2754 3rdparty/openexr/Imath/ImathMatrix.h                 tmp = t[i][j];
t                2755 3rdparty/openexr/Imath/ImathMatrix.h                 t[i][j] = t[pivot][j];
t                2756 3rdparty/openexr/Imath/ImathMatrix.h                 t[pivot][j] = tmp;
t                2766 3rdparty/openexr/Imath/ImathMatrix.h             T f = t[j][i] / t[i][i];
t                2770 3rdparty/openexr/Imath/ImathMatrix.h                 t[j][k] -= f * t[i][k];
t                2782 3rdparty/openexr/Imath/ImathMatrix.h         if ((f = t[i][i]) == 0)
t                2792 3rdparty/openexr/Imath/ImathMatrix.h             t[i][j] /= f;
t                2798 3rdparty/openexr/Imath/ImathMatrix.h             f = t[j][i];
t                2802 3rdparty/openexr/Imath/ImathMatrix.h                 t[j][k] -= f * t[i][k];
t                3101 3rdparty/openexr/Imath/ImathMatrix.h Matrix44<T>::setTranslation (const Vec3<S> &t)
t                3118 3rdparty/openexr/Imath/ImathMatrix.h     x[3][0] = t[0];
t                3119 3rdparty/openexr/Imath/ImathMatrix.h     x[3][1] = t[1];
t                3120 3rdparty/openexr/Imath/ImathMatrix.h     x[3][2] = t[2];
t                3136 3rdparty/openexr/Imath/ImathMatrix.h Matrix44<T>::translate (const Vec3<S> &t)
t                3138 3rdparty/openexr/Imath/ImathMatrix.h     x[3][0] += t[0] * x[0][0] + t[1] * x[1][0] + t[2] * x[2][0];
t                3139 3rdparty/openexr/Imath/ImathMatrix.h     x[3][1] += t[0] * x[0][1] + t[1] * x[1][1] + t[2] * x[2][1];
t                3140 3rdparty/openexr/Imath/ImathMatrix.h     x[3][2] += t[0] * x[0][2] + t[1] * x[1][2] + t[2] * x[2][2];
t                3141 3rdparty/openexr/Imath/ImathMatrix.h     x[3][3] += t[0] * x[0][3] + t[1] * x[1][3] + t[2] * x[2][3];
t                  87 3rdparty/openexr/Imath/ImathMatrixAlgo.cpp         const double t = _total + y;
t                  88 3rdparty/openexr/Imath/ImathMatrixAlgo.cpp         _correction = (t - _total) - y;
t                  89 3rdparty/openexr/Imath/ImathMatrixAlgo.cpp         _total = t;
t                 996 3rdparty/openexr/Imath/ImathMatrixAlgo.cpp     const T t = (rho < 0 ? T(-1) : T(1)) / (std::abs(rho) + std::sqrt(1 + rho*rho));
t                 997 3rdparty/openexr/Imath/ImathMatrixAlgo.cpp     const T c = T(1) / std::sqrt (T(1) + t*t);
t                 998 3rdparty/openexr/Imath/ImathMatrixAlgo.cpp     const T s = t * c;
t                1000 3rdparty/openexr/Imath/ImathMatrixAlgo.cpp     const T h = t * y;
t                1051 3rdparty/openexr/Imath/ImathMatrixAlgo.cpp     const T t = (rho < 0 ? T(-1) : T(1)) / (std::abs(rho) + std::sqrt(1 + rho*rho));
t                1052 3rdparty/openexr/Imath/ImathMatrixAlgo.cpp     const T c = T(1) / std::sqrt (T(1) + t*t);
t                1053 3rdparty/openexr/Imath/ImathMatrixAlgo.cpp     const T s = c * t;
t                1055 3rdparty/openexr/Imath/ImathMatrixAlgo.cpp     const T h = t * y;
t                 182 3rdparty/openexr/Imath/ImathMatrixAlgo.h                      Vec3<T> &t,
t                 191 3rdparty/openexr/Imath/ImathMatrixAlgo.h                      Vec3<T> &t,
t                 199 3rdparty/openexr/Imath/ImathMatrixAlgo.h                      Vec3<T> &t,
t                 345 3rdparty/openexr/Imath/ImathMatrixAlgo.h                          Vec2<T> &t,
t                 743 3rdparty/openexr/Imath/ImathMatrixAlgo.h          Vec3<T> &t,
t                 755 3rdparty/openexr/Imath/ImathMatrixAlgo.h     t.x = mat[3][0];
t                 756 3rdparty/openexr/Imath/ImathMatrixAlgo.h     t.y = mat[3][1];
t                 757 3rdparty/openexr/Imath/ImathMatrixAlgo.h     t.z = mat[3][2];
t                 775 3rdparty/openexr/Imath/ImathMatrixAlgo.h          Vec3<T> &t,
t                 778 3rdparty/openexr/Imath/ImathMatrixAlgo.h     return extractSHRT(mat, s, h, r, t, exc, Imath::Euler<T>::XYZ);
t                 787 3rdparty/openexr/Imath/ImathMatrixAlgo.h          Vec3<T> &t,
t                 790 3rdparty/openexr/Imath/ImathMatrixAlgo.h     return extractSHRT (mat, s, h, r, t, exc, r.order ());
t                1273 3rdparty/openexr/Imath/ImathMatrixAlgo.h          Vec2<T> &t,
t                1284 3rdparty/openexr/Imath/ImathMatrixAlgo.h     t.x = mat[2][0];
t                1285 3rdparty/openexr/Imath/ImathMatrixAlgo.h     t.y = mat[2][1];
t                 190 3rdparty/openexr/Imath/ImathPlane.h     T t = - ((normal ^ line.pos) - distance) /  d;
t                 191 3rdparty/openexr/Imath/ImathPlane.h     point = line(t);
t                 196 3rdparty/openexr/Imath/ImathPlane.h inline bool Plane3<T>::intersectT(const Line3<T>& line, T &t) const
t                 200 3rdparty/openexr/Imath/ImathPlane.h     t = - ((normal ^ line.pos) - distance) /  d;
t                 113 3rdparty/openexr/Imath/ImathQuat.h     const Quat<T> &	operator *=	(T t);
t                 115 3rdparty/openexr/Imath/ImathQuat.h     const Quat<T> &	operator /=	(T t);
t                 160 3rdparty/openexr/Imath/ImathQuat.h Quat<T>			slerp (const Quat<T> &q1, const Quat<T> &q2, T t);
t                 164 3rdparty/openexr/Imath/ImathQuat.h                               (const Quat<T> &q1, const Quat<T> &q2, T t);
t                 169 3rdparty/openexr/Imath/ImathQuat.h                    const Quat<T> &qa, const Quat<T> &qb, T t);
t                 192 3rdparty/openexr/Imath/ImathQuat.h Quat<T>			operator / (const Quat<T> &q, T t);
t                 195 3rdparty/openexr/Imath/ImathQuat.h Quat<T>			operator * (const Quat<T> &q, T t);
t                 198 3rdparty/openexr/Imath/ImathQuat.h Quat<T>			operator * (T t, const Quat<T> &q);
t                 291 3rdparty/openexr/Imath/ImathQuat.h Quat<T>::operator *= (T t)
t                 293 3rdparty/openexr/Imath/ImathQuat.h     r *= t;
t                 294 3rdparty/openexr/Imath/ImathQuat.h     v *= t;
t                 310 3rdparty/openexr/Imath/ImathQuat.h Quat<T>::operator /= (T t)
t                 312 3rdparty/openexr/Imath/ImathQuat.h     r /= t;
t                 313 3rdparty/openexr/Imath/ImathQuat.h     v /= t;
t                 494 3rdparty/openexr/Imath/ImathQuat.h slerp (const Quat<T> &q1, const Quat<T> &q2, T t)
t                 516 3rdparty/openexr/Imath/ImathQuat.h     T s = 1 - t;
t                 519 3rdparty/openexr/Imath/ImathQuat.h             sinx_over_x (t * a) / sinx_over_x (a) * t * q2;
t                 527 3rdparty/openexr/Imath/ImathQuat.h slerpShortestArc (const Quat<T> &q1, const Quat<T> &q2, T t)
t                 536 3rdparty/openexr/Imath/ImathQuat.h         return slerp (q1, q2, t);
t                 538 3rdparty/openexr/Imath/ImathQuat.h         return slerp (q1, -q2, t);
t                 546 3rdparty/openexr/Imath/ImathQuat.h     T t)
t                 572 3rdparty/openexr/Imath/ImathQuat.h     Quat<T> result = squad (q1, qa, qb, q2, t);
t                 582 3rdparty/openexr/Imath/ImathQuat.h        T t)
t                 593 3rdparty/openexr/Imath/ImathQuat.h     Quat<T> r1 = slerp (q1, q2, t);
t                 594 3rdparty/openexr/Imath/ImathQuat.h     Quat<T> r2 = slerp (qa, qb, t);
t                 595 3rdparty/openexr/Imath/ImathQuat.h     Quat<T> result = slerp (r1, r2, 2 * t * (1 - t));
t                 894 3rdparty/openexr/Imath/ImathQuat.h operator / (const Quat<T> &q, T t)
t                 896 3rdparty/openexr/Imath/ImathQuat.h     return Quat<T> (q.r / t, q.v / t);
t                 902 3rdparty/openexr/Imath/ImathQuat.h operator * (const Quat<T> &q, T t)
t                 904 3rdparty/openexr/Imath/ImathQuat.h     return Quat<T> (q.r * t, q.v * t);
t                 910 3rdparty/openexr/Imath/ImathQuat.h operator * (T t, const Quat<T> &q)
t                 912 3rdparty/openexr/Imath/ImathQuat.h     return Quat<T> (q.r * t, q.v * t);
t                  86 3rdparty/openexr/Imath/ImathRoots.h template <class T> int	solveNormalizedCubic (T r, T s, T t, T x[3]);
t                 150 3rdparty/openexr/Imath/ImathRoots.h solveNormalizedCubic (T r, T s, T t, T x[3])
t                 153 3rdparty/openexr/Imath/ImathRoots.h     T q  = 2 * r * r * r / 27 - r * s / 3 + t;
t                  92 3rdparty/openexr/Imath/ImathSphere.h     bool intersectT(const Line3<T> &l, T &t) const;
t                 117 3rdparty/openexr/Imath/ImathSphere.h bool Sphere3<T>::intersectT(const Line3<T> &line, T &t) const
t                 141 3rdparty/openexr/Imath/ImathSphere.h     t = (-B - sqroot) * T(0.5);
t                 143 3rdparty/openexr/Imath/ImathSphere.h     if (t < 0.0)
t                 147 3rdparty/openexr/Imath/ImathSphere.h         t = (-B + sqroot) * T(0.5);
t                 150 3rdparty/openexr/Imath/ImathSphere.h     if (t < 0.0)
t                 161 3rdparty/openexr/Imath/ImathSphere.h     T t;
t                 163 3rdparty/openexr/Imath/ImathSphere.h     if (intersectT (line, t))
t                 165 3rdparty/openexr/Imath/ImathSphere.h     intersection = line(t);
t                  60 3rdparty/openexr/Imath/ImathVecAlgo.h template <class Vec> Vec        project (const Vec &s, const Vec &t);
t                  68 3rdparty/openexr/Imath/ImathVecAlgo.h template <class Vec> Vec        orthogonal (const Vec &s, const Vec &t);
t                  76 3rdparty/openexr/Imath/ImathVecAlgo.h template <class Vec> Vec        reflect (const Vec &s, const Vec &t);
t                  95 3rdparty/openexr/Imath/ImathVecAlgo.h project (const Vec &s, const Vec &t)
t                  98 3rdparty/openexr/Imath/ImathVecAlgo.h     return sNormalized * (sNormalized ^ t);
t                 103 3rdparty/openexr/Imath/ImathVecAlgo.h orthogonal (const Vec &s, const Vec &t)
t                 105 3rdparty/openexr/Imath/ImathVecAlgo.h     return t - project (s, t);
t                 110 3rdparty/openexr/Imath/ImathVecAlgo.h reflect (const Vec &s, const Vec &t)
t                 112 3rdparty/openexr/Imath/ImathVecAlgo.h     return s - typename Vec::BaseType(2) * (s - project(t, s));
t                  69 apps/traincascade/HOGfeatures.cpp     int x, y, t, w, h;
t                  71 apps/traincascade/HOGfeatures.cpp     for (t = 8; t <= winSize.width/2; t+=8) //t = size of a cell. blocksize = 4*cellSize
t                  74 apps/traincascade/HOGfeatures.cpp         w = 2*t; //width of a block
t                  75 apps/traincascade/HOGfeatures.cpp         h = 2*t; //height of a block
t                  80 apps/traincascade/HOGfeatures.cpp                 features.push_back(Feature(offset, x, y, t, t));
t                  83 apps/traincascade/HOGfeatures.cpp         w = 2*t;
t                  84 apps/traincascade/HOGfeatures.cpp         h = 4*t;
t                  89 apps/traincascade/HOGfeatures.cpp                 features.push_back(Feature(offset, x, y, t, 2*t));
t                  92 apps/traincascade/HOGfeatures.cpp         w = 4*t;
t                  93 apps/traincascade/HOGfeatures.cpp         h = 2*t;
t                  98 apps/traincascade/HOGfeatures.cpp                 features.push_back(Feature(offset, x, y, 2*t, t));
t                 522 apps/traincascade/old_ml_boost.cpp         double t = responses[idx]*w;
t                 524 apps/traincascade/old_ml_boost.cpp         lsum += t; rsum -= t;
t                 857 apps/traincascade/old_ml_boost.cpp             double t = values[i];
t                 860 apps/traincascade/old_ml_boost.cpp             sum += t*w;
t                 861 apps/traincascade/old_ml_boost.cpp             sum2 += t*t*w;
t                 720 apps/traincascade/old_ml_data.cpp             int t;
t                 721 apps/traincascade/old_ml_data.cpp             CV_SWAP( sample_idx[a], sample_idx[b], t );
t                 441 apps/traincascade/old_ml_tree.cpp                         float t = fdata[(size_t)si*step];
t                 442 apps/traincascade/old_ml_tree.cpp                         val = cvRound(t);
t                 443 apps/traincascade/old_ml_tree.cpp                         if( fabs(t - val) > FLT_EPSILON )
t                2170 apps/traincascade/old_ml_tree.cpp                     double t = v[j]*alpha - s[j]*beta;
t                2171 apps/traincascade/old_ml_tree.cpp                     dist2 += t*t;
t                2310 apps/traincascade/old_ml_tree.cpp                 int t = crow[k];
t                2311 apps/traincascade/old_ml_tree.cpp                 int lval = lc[k] + t;
t                2312 apps/traincascade/old_ml_tree.cpp                 int rval = rc[k] - t;
t                2325 apps/traincascade/old_ml_tree.cpp                 int t = crow[k];
t                2326 apps/traincascade/old_ml_tree.cpp                 int lval = lc[k] - t;
t                2327 apps/traincascade/old_ml_tree.cpp                 int rval = rc[k] + t;
t                2407 apps/traincascade/old_ml_tree.cpp         float t = responses[sorted_indices[i]];
t                2409 apps/traincascade/old_ml_tree.cpp         lsum += t;
t                2410 apps/traincascade/old_ml_tree.cpp         rsum -= t;
t                2893 apps/traincascade/old_ml_tree.cpp                 double t = values[i];
t                2894 apps/traincascade/old_ml_tree.cpp                 sum += t;
t                2895 apps/traincascade/old_ml_tree.cpp                 sum2 += t*t;
t                2913 apps/traincascade/old_ml_tree.cpp                 double t = values[i];
t                2914 apps/traincascade/old_ml_tree.cpp                 double s = cv_sum[j] + t;
t                2915 apps/traincascade/old_ml_tree.cpp                 double s2 = cv_sum2[j] + t*t;
t                3485 apps/traincascade/old_ml_tree.cpp             int t = fold >= 0 ? node->cv_Tn[fold] : node->Tn;
t                3486 apps/traincascade/old_ml_tree.cpp             if( t <= T || !node->left )
t                3537 apps/traincascade/old_ml_tree.cpp             int t = fold >= 0 ? node->cv_Tn[fold] : node->Tn;
t                3538 apps/traincascade/old_ml_tree.cpp             if( t <= T || !node->left )
t                1230 modules/calib3d/include/opencv2/calib3d.hpp CV_EXPORTS_W void decomposeEssentialMat( InputArray E, OutputArray R1, OutputArray R2, OutputArray t );
t                1277 modules/calib3d/include/opencv2/calib3d.hpp                             OutputArray R, OutputArray t,
t                 601 modules/calib3d/src/calibinit.cpp                 float t = ((c.x - a.x)*dx0 + (c.y - a.y)*dy0)/(dx0*dx0 + dy0*dy0);
t                 602 modules/calib3d/src/calibinit.cpp                 if( t < prevt || t > 1 )
t                 604 modules/calib3d/src/calibinit.cpp                 prevt = t;
t                 403 modules/calib3d/src/calibration.cpp             double t;
t                 409 modules/calib3d/src/calibration.cpp                 t = (R[0] + 1)*0.5;
t                 410 modules/calib3d/src/calibration.cpp                 rx = std::sqrt(MAX(t,0.));
t                 411 modules/calib3d/src/calibration.cpp                 t = (R[4] + 1)*0.5;
t                 412 modules/calib3d/src/calibration.cpp                 ry = std::sqrt(MAX(t,0.))*(R[1] < 0 ? -1. : 1.);
t                 413 modules/calib3d/src/calibration.cpp                 t = (R[8] + 1)*0.5;
t                 414 modules/calib3d/src/calibration.cpp                 rz = std::sqrt(MAX(t,0.))*(R[2] < 0 ? -1. : 1.);
t                 439 modules/calib3d/src/calibration.cpp                 double t, dtheta_dtr = -1./s;
t                 479 modules/calib3d/src/calibration.cpp                 CV_SWAP(J[1], J[3], t); CV_SWAP(J[2], J[6], t); CV_SWAP(J[5], J[7], t);
t                 480 modules/calib3d/src/calibration.cpp                 CV_SWAP(J[10], J[12], t); CV_SWAP(J[11], J[15], t); CV_SWAP(J[14], J[16], t);
t                 481 modules/calib3d/src/calibration.cpp                 CV_SWAP(J[19], J[21], t); CV_SWAP(J[20], J[24], t); CV_SWAP(J[23], J[25], t);
t                 545 modules/calib3d/src/calibration.cpp     double r[3], R[9], dRdr[27], t[3], a[9], k[12] = {0,0,0,0,0,0,0,0,0,0,0,0}, fx, fy, cx, cy;
t                 626 modules/calib3d/src/calibration.cpp     _t = cvMat( t_vec->rows, t_vec->cols, CV_MAKETYPE(CV_64F,CV_MAT_CN(t_vec->type)), t );
t                 752 modules/calib3d/src/calibration.cpp         double x = R[0]*X + R[1]*Y + R[2]*Z + t[0];
t                 753 modules/calib3d/src/calibration.cpp         double y = R[3]*X + R[4]*Y + R[5]*Z + t[1];
t                 754 modules/calib3d/src/calibration.cpp         double z = R[6]*X + R[7]*Y + R[8]*Z + t[2];
t                1802 modules/calib3d/src/calibration.cpp         double _om[2][3], r[2][9], t[2][3];
t                1811 modules/calib3d/src/calibration.cpp             T[k] = cvMat(3, 1, CV_64F, t[k]);
t                1823 modules/calib3d/src/calibration.cpp                 solver.param->data.db[(i+1)*6 + 3] = t[0][0];
t                1824 modules/calib3d/src/calibration.cpp                 solver.param->data.db[(i+1)*6 + 4] = t[0][1];
t                1825 modules/calib3d/src/calibration.cpp                 solver.param->data.db[(i+1)*6 + 5] = t[0][2];
t                1831 modules/calib3d/src/calibration.cpp         RT0->data.db[i] = t[0][0];
t                1832 modules/calib3d/src/calibration.cpp         RT0->data.db[i + nimages] = t[0][1];
t                1833 modules/calib3d/src/calibration.cpp         RT0->data.db[i + nimages*2] = t[0][2];
t                1834 modules/calib3d/src/calibration.cpp         RT0->data.db[i + nimages*3] = t[1][0];
t                1835 modules/calib3d/src/calibration.cpp         RT0->data.db[i + nimages*4] = t[1][1];
t                1836 modules/calib3d/src/calibration.cpp         RT0->data.db[i + nimages*5] = t[1][2];
t                2066 modules/calib3d/src/calibration.cpp         double* t = T_LR.data.db;
t                2069 modules/calib3d/src/calibration.cpp             0, -t[2], t[1],
t                2070 modules/calib3d/src/calibration.cpp             t[2], 0, -t[0],
t                2071 modules/calib3d/src/calibration.cpp             -t[1], t[0], 0
t                2152 modules/calib3d/src/calibration.cpp     CvMat t   = cvMat(3, 1, CV_64F, _t);
t                2169 modules/calib3d/src/calibration.cpp     cvMatMul(&r_r, matT, &t);
t                2172 modules/calib3d/src/calibration.cpp     double c = _t[idx], nt = cvNorm(&t, 0, CV_L2);
t                2176 modules/calib3d/src/calibration.cpp     cvCrossProduct(&t,&uu,&ww);
t                2187 modules/calib3d/src/calibration.cpp     cvMatMul(&Ri, matT, &t);
t                2523 modules/calib3d/src/calibration.cpp     double t[] =
t                2529 modules/calib3d/src/calibration.cpp     CvMat T = cvMat(3, 3, CV_64F, t);
t                3601 modules/calib3d/src/calibration.cpp     R3 = wR*r_r.t()*r_r13.t();
t                3605 modules/calib3d/src/calibration.cpp     Mat t = P3.col(3);
t                3606 modules/calib3d/src/calibration.cpp     t13.copyTo(t);
t                  49 modules/calib3d/src/dls.cpp bool dls::compute_pose(cv::Mat& R, cv::Mat& t)
t                  86 modules/calib3d/src/dls.cpp         t_est__.copyTo(t);
t                 117 modules/calib3d/src/dls.cpp         cv::Mat V_k; cv::solve(V_kB.t(), V_kA.t(), V_k); // A/B = B'\A'
t                 118 modules/calib3d/src/dls.cpp         cv::Mat( V_k.t()).copyTo( eigenvec_r.col(k) );
t                 146 modules/calib3d/src/dls.cpp                 cv::Mat Cbarvec = Cbar.reshape(1,1).t();
t                 149 modules/calib3d/src/dls.cpp                 cv::Mat cost_mat =  Cbarvec.t() * D * Cbarvec;
t                 167 modules/calib3d/src/dls.cpp         double sols_mult = 1./(1.+cv::Mat( sols_j.t() * sols_j ).at<double>(0));
t                 176 modules/calib3d/src/dls.cpp             cv::Mat z_mul = z.col(i)*z.col(i).t();
t                 223 modules/calib3d/src/dls.cpp         A += ( z_i*z_i.t() - eye ) * LeftMultVec(pp.col(i));
t                 226 modules/calib3d/src/dls.cpp     H = eye.mul(N) - z * z.t();
t                 237 modules/calib3d/src/dls.cpp         D += ppi_A.t() * ( eye - z_i*z_i.t() ) * ppi_A;
t                 257 modules/calib3d/src/dls.cpp     cv::Mat M2_5; cv::solve(M2_3.t(), M2_2.t(), M2_5);
t                 262 modules/calib3d/src/dls.cpp     Mtilde = M2_1 - M2_5.t()*M2_4;
t                 528 modules/calib3d/src/dls.cpp     return M.t();
t                 571 modules/calib3d/src/dls.cpp     H.at<double>(0,0) = cv::Mat(cv::Mat(f1coeff).rowRange(1,21).t()*cv::Mat(20, 1, CV_64F, &Hs1)).at<double>(0,0);
t                 572 modules/calib3d/src/dls.cpp     H.at<double>(0,1) = cv::Mat(cv::Mat(f1coeff).rowRange(1,21).t()*cv::Mat(20, 1, CV_64F, &Hs2)).at<double>(0,0);
t                 573 modules/calib3d/src/dls.cpp     H.at<double>(0,2) = cv::Mat(cv::Mat(f1coeff).rowRange(1,21).t()*cv::Mat(20, 1, CV_64F, &Hs3)).at<double>(0,0);
t                 575 modules/calib3d/src/dls.cpp     H.at<double>(1,0) = cv::Mat(cv::Mat(f2coeff).rowRange(1,21).t()*cv::Mat(20, 1, CV_64F, &Hs1)).at<double>(0,0);
t                 576 modules/calib3d/src/dls.cpp     H.at<double>(1,1) = cv::Mat(cv::Mat(f2coeff).rowRange(1,21).t()*cv::Mat(20, 1, CV_64F, &Hs2)).at<double>(0,0);
t                 577 modules/calib3d/src/dls.cpp     H.at<double>(1,2) = cv::Mat(cv::Mat(f2coeff).rowRange(1,21).t()*cv::Mat(20, 1, CV_64F, &Hs3)).at<double>(0,0);
t                 579 modules/calib3d/src/dls.cpp     H.at<double>(2,0) = cv::Mat(cv::Mat(f3coeff).rowRange(1,21).t()*cv::Mat(20, 1, CV_64F, &Hs1)).at<double>(0,0);
t                 580 modules/calib3d/src/dls.cpp     H.at<double>(2,1) = cv::Mat(cv::Mat(f3coeff).rowRange(1,21).t()*cv::Mat(20, 1, CV_64F, &Hs2)).at<double>(0,0);
t                 581 modules/calib3d/src/dls.cpp     H.at<double>(2,2) = cv::Mat(cv::Mat(f3coeff).rowRange(1,21).t()*cv::Mat(20, 1, CV_64F, &Hs3)).at<double>(0,0);
t                 588 modules/calib3d/src/dls.cpp     double s_mul1 = cv::Mat(s.t()*s).at<double>(0,0);
t                 589 modules/calib3d/src/dls.cpp     cv::Mat s_mul2 = s*s.t();
t                 592 modules/calib3d/src/dls.cpp     return cv::Mat( eye.mul(1.-s_mul1) + skewsymm(&s).mul(2.) + s_mul2.mul(2.) ).t();
t                 603 modules/calib3d/src/dls.cpp cv::Mat dls::rotx(const double t)
t                 606 modules/calib3d/src/dls.cpp     double ct = cos(t);
t                 607 modules/calib3d/src/dls.cpp     double st = sin(t);
t                 611 modules/calib3d/src/dls.cpp cv::Mat dls::roty(const double t)
t                 614 modules/calib3d/src/dls.cpp     double ct = cos(t);
t                 615 modules/calib3d/src/dls.cpp     double st = sin(t);
t                 619 modules/calib3d/src/dls.cpp cv::Mat dls::rotz(const double t)
t                 622 modules/calib3d/src/dls.cpp     double ct = cos(t);
t                 623 modules/calib3d/src/dls.cpp     double st = sin(t);
t                  17 modules/calib3d/src/dls.h     bool compute_pose(cv::Mat& R, cv::Mat& t);
t                  67 modules/calib3d/src/dls.h     cv::Mat rotx(const double t);
t                  68 modules/calib3d/src/dls.h     cv::Mat roty(const double t);
t                  69 modules/calib3d/src/dls.h     cv::Mat rotz(const double t);
t                 168 modules/calib3d/src/dls.h         double p = 0, q = 0, r = 0, s = 0, z = 0, t, w, x, y;
t                 471 modules/calib3d/src/dls.h                             t = (x * s - z * r) / q;
t                 472 modules/calib3d/src/dls.h                             H[i][n1] = t;
t                 474 modules/calib3d/src/dls.h                                 H[i + 1][n1] = (-r - w * t) / x;
t                 476 modules/calib3d/src/dls.h                                 H[i + 1][n1] = (-s - y * t) / z;
t                 482 modules/calib3d/src/dls.h                         t = std::abs(H[i][n1]);
t                 483 modules/calib3d/src/dls.h                         if ((eps * t) * t > 1) {
t                 485 modules/calib3d/src/dls.h                                 H[j][n1] = H[j][n1] / t;
t                 557 modules/calib3d/src/dls.h                         t = std::max(std::abs(H[i][n1 - 1]), std::abs(H[i][n1]));
t                 558 modules/calib3d/src/dls.h                         if ((eps * t) * t > 1) {
t                 560 modules/calib3d/src/dls.h                                 H[j][n1 - 1] = H[j][n1 - 1] / t;
t                 561 modules/calib3d/src/dls.h                                 H[j][n1] = H[j][n1] / t;
t                 150 modules/calib3d/src/epnp.cpp void epnp::compute_pose(Mat& R, Mat& t)
t                 195 modules/calib3d/src/epnp.cpp   Mat(3, 1, CV_64F, ts[N]).copyTo(t);
t                 222 modules/calib3d/src/epnp.cpp void epnp::estimate_R_and_t(double R[3][3], double t[3])
t                 277 modules/calib3d/src/epnp.cpp   t[0] = pc0[0] - dot(R[0], pw0);
t                 278 modules/calib3d/src/epnp.cpp   t[1] = pc0[1] - dot(R[1], pw0);
t                 279 modules/calib3d/src/epnp.cpp   t[2] = pc0[2] - dot(R[2], pw0);
t                 298 modules/calib3d/src/epnp.cpp            double R[3][3], double t[3])
t                 305 modules/calib3d/src/epnp.cpp   estimate_R_and_t(R, t);
t                 307 modules/calib3d/src/epnp.cpp   return reprojection_error(R, t);
t                 310 modules/calib3d/src/epnp.cpp double epnp::reprojection_error(const double R[3][3], const double t[3])
t                 316 modules/calib3d/src/epnp.cpp     double Xc = dot(R[0], pw) + t[0];
t                 317 modules/calib3d/src/epnp.cpp     double Yc = dot(R[1], pw) + t[1];
t                 318 modules/calib3d/src/epnp.cpp     double inv_Zc = 1.0 / (dot(R[2], pw) + t[2]);
t                  18 modules/calib3d/src/epnp.h   void compute_pose(cv::Mat& R, cv::Mat& t);
t                  41 modules/calib3d/src/epnp.h   double reprojection_error(const double R[3][3], const double t[3]);
t                  66 modules/calib3d/src/epnp.h              double R[3][3], double t[3]);
t                  68 modules/calib3d/src/epnp.h   void estimate_R_and_t(double R[3][3], double t[3]);
t                 158 modules/calib3d/src/fisheye.cpp             Matx33d dYdom_data = Matx<double, 3, 9>(dYdR) * dRdom.t();
t                 637 modules/calib3d/src/fisheye.cpp     Vec3d t = r_r * tvec;
t                 638 modules/calib3d/src/fisheye.cpp     Vec3d uu(t[0] > 0 ? 1 : -1, 0, 0);
t                 641 modules/calib3d/src/fisheye.cpp     Vec3d ww = t.cross(uu);
t                 644 modules/calib3d/src/fisheye.cpp         ww *= acos(fabs(t[0])/cv::norm(t))/nw;
t                 650 modules/calib3d/src/fisheye.cpp     Matx33d ri1 = wr * r_r.t();
t                 915 modules/calib3d/src/fisheye.cpp         R_ref = R2 * R1.t();
t                 955 modules/calib3d/src/fisheye.cpp             cv::Mat(cv::Mat((imageLeft - projected).t()).reshape(1, 1).t()).copyTo(ekk.rowRange(0, 2 * n_points));
t                 969 modules/calib3d/src/fisheye.cpp             cv::Mat(cv::Mat((imageRight - projected).t()).reshape(1, 1).t()).copyTo(ekk.rowRange(2 * n_points, 4 * n_points));
t                1004 modules/calib3d/src/fisheye.cpp         cv::Mat J2 = J.t() * J;
t                1008 modules/calib3d/src/fisheye.cpp         cv::Mat deltas = J2_inv * J.t() * e;
t                1172 modules/calib3d/src/fisheye.cpp         Mat ex = imagePoints - Mat(x).t();
t                1248 modules/calib3d/src/fisheye.cpp     if (Np > 4) L = L.t() * L;
t                1265 modules/calib3d/src/fisheye.cpp             m_err = Mat(m_err.t()).reshape(1, m_err.cols * m_err.rows);
t                1285 modules/calib3d/src/fisheye.cpp             Mat hh_innov = (J.t() * J).inv() * (J.t()) * m_err;
t                1319 modules/calib3d/src/fisheye.cpp     Mat imagePointsNormalized = NormalizePixels(_imagePoints.t(), param).reshape(1).t();
t                1320 modules/calib3d/src/fisheye.cpp     Mat objectPoints = Mat(_objectPoints.t()).reshape(1).t();
t                1413 modules/calib3d/src/fisheye.cpp         Mat exkk = image.t() - Mat(x);
t                1420 modules/calib3d/src/fisheye.cpp         A = A.t();
t                1423 modules/calib3d/src/fisheye.cpp         B = B.t();
t                1425 modules/calib3d/src/fisheye.cpp         JJ3(Rect(0, 0, 9, 9)) = JJ3(Rect(0, 0, 9, 9)) + A * A.t();
t                1426 modules/calib3d/src/fisheye.cpp         JJ3(Rect(9 + 6 * image_idx, 9 + 6 * image_idx, 6, 6)) = B * B.t();
t                1428 modules/calib3d/src/fisheye.cpp         Mat AB = A * B.t();
t                1431 modules/calib3d/src/fisheye.cpp         JJ3(Rect(0, 9 + 6 * image_idx, 9, 6)) = AB.t();
t                1438 modules/calib3d/src/fisheye.cpp             Mat JJ_kk = B.t();
t                1474 modules/calib3d/src/fisheye.cpp         Mat ex_ = image.t() - Mat(x);
t                1546 modules/calib3d/src/fisheye.cpp         Mat(src.row(0).t()).copyTo(tmp.col(0));
t                1547 modules/calib3d/src/fisheye.cpp         Mat(src.row(1).t()).copyTo(tmp.col(3));
t                1548 modules/calib3d/src/fisheye.cpp         Mat(src.row(2).t()).copyTo(tmp.col(6));
t                1549 modules/calib3d/src/fisheye.cpp         Mat(src.row(3).t()).copyTo(tmp.col(1));
t                1550 modules/calib3d/src/fisheye.cpp         Mat(src.row(4).t()).copyTo(tmp.col(4));
t                1551 modules/calib3d/src/fisheye.cpp         Mat(src.row(5).t()).copyTo(tmp.col(7));
t                1552 modules/calib3d/src/fisheye.cpp         Mat(src.row(6).t()).copyTo(tmp.col(2));
t                1553 modules/calib3d/src/fisheye.cpp         Mat(src.row(7).t()).copyTo(tmp.col(5));
t                1554 modules/calib3d/src/fisheye.cpp         Mat(src.row(8).t()).copyTo(tmp.col(8));
t                1558 modules/calib3d/src/fisheye.cpp         Mat(src.col(0).t()).copyTo(tmp.row(0));
t                1559 modules/calib3d/src/fisheye.cpp         Mat(src.col(1).t()).copyTo(tmp.row(3));
t                1560 modules/calib3d/src/fisheye.cpp         Mat(src.col(2).t()).copyTo(tmp.row(6));
t                1561 modules/calib3d/src/fisheye.cpp         Mat(src.col(3).t()).copyTo(tmp.row(1));
t                1562 modules/calib3d/src/fisheye.cpp         Mat(src.col(4).t()).copyTo(tmp.row(4));
t                1563 modules/calib3d/src/fisheye.cpp         Mat(src.col(5).t()).copyTo(tmp.row(7));
t                1564 modules/calib3d/src/fisheye.cpp         Mat(src.col(6).t()).copyTo(tmp.row(2));
t                1565 modules/calib3d/src/fisheye.cpp         Mat(src.col(7).t()).copyTo(tmp.row(5));
t                1566 modules/calib3d/src/fisheye.cpp         Mat(src.col(8).t()).copyTo(tmp.row(8));
t                1622 modules/calib3d/src/fisheye.cpp     Mat M = Mat(m.getMat().t()).reshape(1).t();
t                  61 modules/calib3d/src/five-point.cpp         Mat EE = Mat(Vt.t()).colRange(5, 9) * 1.0;
t                  63 modules/calib3d/src/five-point.cpp         EE = EE.t();
t                  65 modules/calib3d/src/five-point.cpp         EE = EE.t();
t                 389 modules/calib3d/src/five-point.cpp             Vec3d Etx2 = E.t() * x2;
t                 470 modules/calib3d/src/five-point.cpp     points1 = points1.t();
t                 471 modules/calib3d/src/five-point.cpp     points2 = points2.t();
t                 473 modules/calib3d/src/five-point.cpp     Mat R1, R2, t;
t                 474 modules/calib3d/src/five-point.cpp     decomposeEssentialMat(E, R1, R2, t);
t                 477 modules/calib3d/src/five-point.cpp     P1(Range::all(), Range(0, 3)) = R1 * 1.0; P1.col(3) = t * 1.0;
t                 478 modules/calib3d/src/five-point.cpp     P2(Range::all(), Range(0, 3)) = R2 * 1.0; P2.col(3) = t * 1.0;
t                 479 modules/calib3d/src/five-point.cpp     P3(Range::all(), Range(0, 3)) = R1 * 1.0; P3.col(3) = -t * 1.0;
t                 480 modules/calib3d/src/five-point.cpp     P4(Range::all(), Range(0, 3)) = R2 * 1.0; P4.col(3) = -t * 1.0;
t                 532 modules/calib3d/src/five-point.cpp     mask1 = mask1.t();
t                 533 modules/calib3d/src/five-point.cpp     mask2 = mask2.t();
t                 534 modules/calib3d/src/five-point.cpp     mask3 = mask3.t();
t                 535 modules/calib3d/src/five-point.cpp     mask4 = mask4.t();
t                 554 modules/calib3d/src/five-point.cpp     _t.create(3, 1, t.type());
t                 564 modules/calib3d/src/five-point.cpp         t.copyTo(_t);
t                 571 modules/calib3d/src/five-point.cpp         t.copyTo(_t);
t                 577 modules/calib3d/src/five-point.cpp         t = -t;
t                 579 modules/calib3d/src/five-point.cpp         t.copyTo(_t);
t                 585 modules/calib3d/src/five-point.cpp         t = -t;
t                 587 modules/calib3d/src/five-point.cpp         t.copyTo(_t);
t                 608 modules/calib3d/src/five-point.cpp     Mat R1, R2, t;
t                 610 modules/calib3d/src/five-point.cpp     R2 = U * W.t() * Vt;
t                 611 modules/calib3d/src/five-point.cpp     t = U.col(2) * 1.0;
t                 615 modules/calib3d/src/five-point.cpp     t.copyTo(_t);
t                 100 modules/calib3d/src/fundam.cpp                 const int* t = tt[i];
t                 101 modules/calib3d/src/fundam.cpp                 Matx33d A(src[t[0]].x, src[t[0]].y, 1., src[t[1]].x, src[t[1]].y, 1., src[t[2]].x, src[t[2]].y, 1.);
t                 102 modules/calib3d/src/fundam.cpp                 Matx33d B(dst[t[0]].x, dst[t[0]].y, 1., dst[t[1]].x, dst[t[1]].y, 1., dst[t[2]].x, dst[t[2]].y, 1.);
t                 557 modules/calib3d/src/fundam.cpp     double t, scale1 = 0, scale2 = 0;
t                 578 modules/calib3d/src/fundam.cpp     t = 1./count;
t                 579 modules/calib3d/src/fundam.cpp     m1c.x *= t; m1c.y *= t;
t                 580 modules/calib3d/src/fundam.cpp     m2c.x *= t; m2c.y *= t;
t                 591 modules/calib3d/src/fundam.cpp     scale1 *= t;
t                 592 modules/calib3d/src/fundam.cpp     scale2 *= t;
t                  62 modules/calib3d/src/homography_decomp.cpp     cv::Vec3d t; //!< translation vector
t                 133 modules/calib3d/src/homography_decomp.cpp     Matx33d RtR = R.t() * R;
t                 143 modules/calib3d/src/homography_decomp.cpp     Matx31d t = Matx31d(motion.t);
t                 145 modules/calib3d/src/homography_decomp.cpp     Matx11d proj = n.t() * motion.R.t() * t;
t                 172 modules/calib3d/src/homography_decomp.cpp     Matx33d temp = tstar_m * n_m.t();
t                 177 modules/calib3d/src/homography_decomp.cpp     motion.t = motion.R * tstar;
t                 302 modules/calib3d/src/homography_decomp.cpp     R = getHnorm() * (I - (2/v) * tstar_m * n_m.t() );
t                 311 modules/calib3d/src/homography_decomp.cpp     S = getHnorm().t() * getHnorm();
t                 320 modules/calib3d/src/homography_decomp.cpp         motion.t = Vec3d(0, 0, 0);
t                 410 modules/calib3d/src/homography_decomp.cpp     camMotions[0].t = ta;
t                 415 modules/calib3d/src/homography_decomp.cpp     camMotions[1].t = -ta;
t                 423 modules/calib3d/src/homography_decomp.cpp     camMotions[2].t = tb;
t                 428 modules/calib3d/src/homography_decomp.cpp     camMotions[3].t = -tb;
t                 468 modules/calib3d/src/homography_decomp.cpp             _translations.getMatRef(k) = Mat(motions[k].t);
t                 152 modules/calib3d/src/levmarq.cpp                 double t = d.dot(v);
t                 153 modules/calib3d/src/levmarq.cpp                 double nu = (Sd - S)/(fabs(t) > DBL_EPSILON ? t : 1) + 2;
t                  58 modules/calib3d/src/p3p.cpp bool p3p::solve(double R[3][3], double t[3],
t                  89 modules/calib3d/src/p3p.cpp         t[i] = ts[ns][i];
t                  95 modules/calib3d/src/p3p.cpp int p3p::solve(double R[4][3][3], double t[4][3],
t                 148 modules/calib3d/src/p3p.cpp         if (!align(M_orig, X0, Y0, Z0, X1, Y1, Z1, X2, Y2, Z2, R[nb_solutions], t[nb_solutions]))
t                 363 modules/calib3d/src/p3p.cpp                     double hh = D[j] - D[i], t;
t                 365 modules/calib3d/src/p3p.cpp                         t = Aij / hh;
t                 368 modules/calib3d/src/p3p.cpp                         t = 1.0 / (fabs(theta) + sqrt(1.0 + theta * theta));
t                 369 modules/calib3d/src/p3p.cpp                         if (theta < 0.0) t = -t;
t                 372 modules/calib3d/src/p3p.cpp                     hh = t * Aij;
t                 379 modules/calib3d/src/p3p.cpp                     double c = 1.0 / sqrt(1 + t * t);
t                 380 modules/calib3d/src/p3p.cpp                     double s = t * c;
t                  14 modules/calib3d/src/p3p.h   int solve(double R[4][3][3], double t[4][3],
t                  18 modules/calib3d/src/p3p.h   bool solve(double R[3][3], double t[3],
t                  94 modules/calib3d/src/ptsetreg.cpp         float t = (float)(thresh*thresh);
t                  98 modules/calib3d/src/ptsetreg.cpp             int f = errptr[i] <= t;
t                 459 modules/calib3d/src/ptsetreg.cpp             const Point3f& t = to[i];
t                 461 modules/calib3d/src/ptsetreg.cpp             double a = F[0]*f.x + F[1]*f.y + F[ 2]*f.z + F[ 3] - t.x;
t                 462 modules/calib3d/src/ptsetreg.cpp             double b = F[4]*f.x + F[5]*f.y + F[ 6]*f.z + F[ 7] - t.y;
t                 463 modules/calib3d/src/ptsetreg.cpp             double c = F[8]*f.x + F[9]*f.y + F[10]*f.z + F[11] - t.z;
t                2434 modules/calib3d/src/rho.cpp     float s[2][2], t[2][2];
t                2498 modules/calib3d/src/rho.cpp     t[0][0] = s[0][0]*M[0][0]+s[0][1]*M[1][0];
t                2499 modules/calib3d/src/rho.cpp     t[0][1] =                 s[0][1]*M[1][1];
t                2500 modules/calib3d/src/rho.cpp     t[1][0] = s[1][0]*M[0][0]+s[1][1]*M[1][0];
t                2501 modules/calib3d/src/rho.cpp     t[1][1] =                 s[1][1]*M[1][1];
t                2503 modules/calib3d/src/rho.cpp     M[2][0] = -t[0][0];
t                2504 modules/calib3d/src/rho.cpp     M[2][1] = -t[0][1];
t                2505 modules/calib3d/src/rho.cpp     M[3][0] = -t[1][0];
t                2506 modules/calib3d/src/rho.cpp     M[3][1] = -t[1][1];
t                2518 modules/calib3d/src/rho.cpp     t[0][0] = s[0][0]*M[4][4]+s[0][1]*M[5][4];
t                2519 modules/calib3d/src/rho.cpp     t[0][1] =                 s[0][1]*M[5][5];
t                2520 modules/calib3d/src/rho.cpp     t[1][0] = s[1][0]*M[4][4]+s[1][1]*M[5][4];
t                2521 modules/calib3d/src/rho.cpp     t[1][1] =                 s[1][1]*M[5][5];
t                2523 modules/calib3d/src/rho.cpp     M[6][4] = -t[0][0];
t                2524 modules/calib3d/src/rho.cpp     M[6][5] = -t[0][1];
t                2525 modules/calib3d/src/rho.cpp     M[7][4] = -t[1][0];
t                2526 modules/calib3d/src/rho.cpp     M[7][5] = -t[1][1];
t                2633 modules/calib3d/src/rho.cpp     float t[8];
t                2635 modules/calib3d/src/rho.cpp     t[0]  = L[0][0]*Jte[0];
t                2636 modules/calib3d/src/rho.cpp     t[1]  = L[1][0]*Jte[0]+L[1][1]*Jte[1];
t                2637 modules/calib3d/src/rho.cpp     t[2]  = L[2][0]*Jte[0]+L[2][1]*Jte[1]+L[2][2]*Jte[2];
t                2638 modules/calib3d/src/rho.cpp     t[3]  = L[3][0]*Jte[0]+L[3][1]*Jte[1]+L[3][2]*Jte[2]+L[3][3]*Jte[3];
t                2639 modules/calib3d/src/rho.cpp     t[4]  = L[4][0]*Jte[0]+L[4][1]*Jte[1]+L[4][2]*Jte[2]+L[4][3]*Jte[3]+L[4][4]*Jte[4];
t                2640 modules/calib3d/src/rho.cpp     t[5]  = L[5][0]*Jte[0]+L[5][1]*Jte[1]+L[5][2]*Jte[2]+L[5][3]*Jte[3]+L[5][4]*Jte[4]+L[5][5]*Jte[5];
t                2641 modules/calib3d/src/rho.cpp     t[6]  = L[6][0]*Jte[0]+L[6][1]*Jte[1]+L[6][2]*Jte[2]+L[6][3]*Jte[3]+L[6][4]*Jte[4]+L[6][5]*Jte[5]+L[6][6]*Jte[6];
t                2642 modules/calib3d/src/rho.cpp     t[7]  = L[7][0]*Jte[0]+L[7][1]*Jte[1]+L[7][2]*Jte[2]+L[7][3]*Jte[3]+L[7][4]*Jte[4]+L[7][5]*Jte[5]+L[7][6]*Jte[6]+L[7][7]*Jte[7];
t                2645 modules/calib3d/src/rho.cpp     dH[0] = L[0][0]*t[0]+L[1][0]*t[1]+L[2][0]*t[2]+L[3][0]*t[3]+L[4][0]*t[4]+L[5][0]*t[5]+L[6][0]*t[6]+L[7][0]*t[7];
t                2646 modules/calib3d/src/rho.cpp     dH[1] =              L[1][1]*t[1]+L[2][1]*t[2]+L[3][1]*t[3]+L[4][1]*t[4]+L[5][1]*t[5]+L[6][1]*t[6]+L[7][1]*t[7];
t                2647 modules/calib3d/src/rho.cpp     dH[2] =                           L[2][2]*t[2]+L[3][2]*t[3]+L[4][2]*t[4]+L[5][2]*t[5]+L[6][2]*t[6]+L[7][2]*t[7];
t                2648 modules/calib3d/src/rho.cpp     dH[3] =                                        L[3][3]*t[3]+L[4][3]*t[4]+L[5][3]*t[5]+L[6][3]*t[6]+L[7][3]*t[7];
t                2649 modules/calib3d/src/rho.cpp     dH[4] =                                                     L[4][4]*t[4]+L[5][4]*t[5]+L[6][4]*t[6]+L[7][4]*t[7];
t                2650 modules/calib3d/src/rho.cpp     dH[5] =                                                                  L[5][5]*t[5]+L[6][5]*t[6]+L[7][5]*t[7];
t                2651 modules/calib3d/src/rho.cpp     dH[6] =                                                                               L[6][6]*t[6]+L[7][6]*t[7];
t                2652 modules/calib3d/src/rho.cpp     dH[7] =                                                                                            L[7][7]*t[7];
t                 249 modules/calib3d/src/triangulate.cpp     double t_min, s_val, t, s;
t                 348 modules/calib3d/src/triangulate.cpp             t = result->data.db[2*ti];
t                 349 modules/calib3d/src/triangulate.cpp             s = (t*t)/(1 + f1*f1*t*t) + ((c*t + d)*(c*t + d))/((a*t + b)*(a*t + b) + f2*f2*(c*t + d)*(c*t + d));
t                 352 modules/calib3d/src/triangulate.cpp                 t_min = t;
t                 400 modules/calib3d/src/triangulate.cpp         points1 = points1.reshape(1, static_cast<int>(points1.total())).t();
t                 403 modules/calib3d/src/triangulate.cpp         points2 = points2.reshape(1, static_cast<int>(points2.total())).t();
t                  95 modules/calib3d/src/upnp.cpp double upnp::compute_pose(Mat& R, Mat& t)
t                 113 modules/calib3d/src/upnp.cpp   MtM = M->t() * (*M);
t                 115 modules/calib3d/src/upnp.cpp   Mat(Ut.t()).copyTo(Ut);
t                 139 modules/calib3d/src/upnp.cpp   Mat(3, 1, CV_64F, ts[N]).copyTo(t);
t                 156 modules/calib3d/src/upnp.cpp void upnp::estimate_R_and_t(double R[3][3], double t[3])
t                 196 modules/calib3d/src/upnp.cpp   Mat(ABt_V.t()).copyTo(ABt_V);
t                 212 modules/calib3d/src/upnp.cpp   t[0] = pc0[0] - dot(R[0], pw0);
t                 213 modules/calib3d/src/upnp.cpp   t[1] = pc0[1] - dot(R[1], pw0);
t                 214 modules/calib3d/src/upnp.cpp   t[2] = pc0[2] - dot(R[2], pw0);
t                 233 modules/calib3d/src/upnp.cpp          double R[3][3], double t[3])
t                 240 modules/calib3d/src/upnp.cpp   estimate_R_and_t(R, t);
t                 242 modules/calib3d/src/upnp.cpp   return reprojection_error(R, t);
t                 245 modules/calib3d/src/upnp.cpp double upnp::reprojection_error(const double R[3][3], const double t[3])
t                 251 modules/calib3d/src/upnp.cpp     double Xc = dot(R[0], pw) + t[0];
t                 252 modules/calib3d/src/upnp.cpp     double Yc = dot(R[1], pw) + t[1];
t                 253 modules/calib3d/src/upnp.cpp     double inv_Zc = 1.0 / (dot(R[2], pw) + t[2]);
t                 277 modules/calib3d/src/upnp.cpp     Mat CC_ = CC.clone().t();
t                 278 modules/calib3d/src/upnp.cpp     Mat PC_ = PC.clone().t();
t                 286 modules/calib3d/src/upnp.cpp     ALPHAS = Mat( CC_.inv() * PC_ ).t();
t                 338 modules/calib3d/src/upnp.cpp   Mat Dt = D.t();
t                  61 modules/calib3d/src/upnp.h     double compute_pose(cv::Mat& R, cv::Mat& t);
t                  85 modules/calib3d/src/upnp.h       double reprojection_error(const double R[3][3], const double t[3]);
t                 116 modules/calib3d/src/upnp.h                    double R[3][3], double t[3]);
t                 118 modules/calib3d/src/upnp.h       void estimate_R_and_t(double R[3][3], double t[3]);
t                1482 modules/calib3d/test/test_cameracalibration.cpp         Mat R1t = R1.t(), R2t = R2.t();
t                1545 modules/calib3d/test/test_cameracalibration.cpp         Mat homogeneousPoints4d = points4d.t();
t                1554 modules/calib3d/test/test_cameracalibration.cpp         sparsePoints = sparsePoints.t();
t                1568 modules/calib3d/test/test_cameracalibration.cpp         Mat points1 = projectedPoints_1.t();
t                1570 modules/calib3d/test/test_cameracalibration.cpp         Mat points2 = projectedPoints_2.t();
t                1582 modules/calib3d/test/test_cameracalibration.cpp             Mat error = newHomogeneousPoints2.row(i) * typedF * newHomogeneousPoints1.row(i).t();
t                  81 modules/calib3d/test/test_cameracalibration_artificial.cpp     Rodrigues(rot.t(), res);
t                 322 modules/calib3d/test/test_chesscorners.cpp     Mat m3; flip(m1, m3, 1); m3 = m3.t(); flip(m3, m3, 1);
t                 324 modules/calib3d/test/test_chesscorners.cpp     Mat m4 = m1.t(); flip(m4, m4, 1);
t                 110 modules/calib3d/test/test_decompose_projection.cpp         cv::Vec3d t = -R*cameraCenter;
t                 126 modules/calib3d/test/test_decompose_projection.cpp         if ( norm(origT, t, cv::NORM_INF) > thresh )
t                 298 modules/calib3d/test/test_fisheye.cpp     cv::Mat imagePointsNormalized = NormalizePixels(_imagePoints, param).reshape(1).t();
t                 299 modules/calib3d/test/test_fisheye.cpp     _objectPoints = _objectPoints.reshape(1).t();
t                 322 modules/calib3d/test/test_fisheye.cpp     cv::Mat merr = (mrep.rowRange(0, 2) - imagePointsNormalized).t();
t                 317 modules/calib3d/test/test_fundam.cpp                 CvMat t = cvMat( 3, 3, CV_64F, J + i*9 );
t                 318 modules/calib3d/test/test_fundam.cpp                 cvTranspose( &t, &t );
t                 694 modules/calib3d/test/test_fundam.cpp                     J1 = J1.t();
t                 700 modules/calib3d/test/test_fundam.cpp                     J2 = J2.t();
t                 899 modules/calib3d/test/test_fundam.cpp     double t[12]={0};
t                 928 modules/calib3d/test/test_fundam.cpp         Mat rot_mat( 3, 3, CV_64F, t, 4*sizeof(t[0]) );
t                 934 modules/calib3d/test/test_fundam.cpp         t[3] = cvtest::randReal(rng)*cube_size;
t                 935 modules/calib3d/test/test_fundam.cpp         t[7] = cvtest::randReal(rng)*cube_size;
t                 936 modules/calib3d/test/test_fundam.cpp         t[11] = cvtest::randReal(rng)*cube_size;
t                 937 modules/calib3d/test/test_fundam.cpp         Mat( 3, 4, CV_64F, t ).convertTo(arr, arr.type());
t                 942 modules/calib3d/test/test_fundam.cpp         t[0] = t[4] = cvtest::randReal(rng)*(max_f - min_f) + min_f;
t                 943 modules/calib3d/test/test_fundam.cpp         t[2] = (img_size*0.5 + cvtest::randReal(rng)*4. - 2.)*t[0];
t                 944 modules/calib3d/test/test_fundam.cpp         t[5] = (img_size*0.5 + cvtest::randReal(rng)*4. - 2.)*t[4];
t                 945 modules/calib3d/test/test_fundam.cpp         t[8] = 1.;
t                 946 modules/calib3d/test/test_fundam.cpp         Mat( 3, 3, CV_64F, t ).convertTo( arr, arr.type() );
t                1040 modules/calib3d/test/test_fundam.cpp         double t = fabs(f[0]*x2*x1 + f[1]*x2*y1 + f[2]*x2 +
t                1044 modules/calib3d/test/test_fundam.cpp         mtfm2[i] = !status[i] || t0 > err_level || t < err_level;
t                1199 modules/calib3d/test/test_fundam.cpp     double t[12]={0};
t                1228 modules/calib3d/test/test_fundam.cpp         Mat rot_mat( 3, 3, CV_64F, t, 4*sizeof(t[0]) );
t                1234 modules/calib3d/test/test_fundam.cpp         t[3] = cvtest::randReal(rng)*cube_size;
t                1235 modules/calib3d/test/test_fundam.cpp         t[7] = cvtest::randReal(rng)*cube_size;
t                1236 modules/calib3d/test/test_fundam.cpp         t[11] = cvtest::randReal(rng)*cube_size;
t                1237 modules/calib3d/test/test_fundam.cpp         Mat( 3, 4, CV_64F, t ).convertTo(arr, arr.type());
t                1241 modules/calib3d/test/test_fundam.cpp         t[0] = t[4] = cvtest::randReal(rng)*(max_f - min_f) + min_f;
t                1242 modules/calib3d/test/test_fundam.cpp         t[2] = (img_size*0.5 + cvtest::randReal(rng)*4. - 2.)*t[0];
t                1243 modules/calib3d/test/test_fundam.cpp         t[5] = (img_size*0.5 + cvtest::randReal(rng)*4. - 2.)*t[4];
t                1244 modules/calib3d/test/test_fundam.cpp         t[8] = 1.;
t                1245 modules/calib3d/test/test_fundam.cpp         Mat( 3, 3, CV_64F, t ).convertTo( arr, arr.type() );
t                1295 modules/calib3d/test/test_fundam.cpp     Mat R, t, mask2;
t                1296 modules/calib3d/test/test_fundam.cpp     recoverPose( E, _input0, _input1, R, t, focal, pp, mask2 );
t                1298 modules/calib3d/test/test_fundam.cpp     t.copyTo(test_mat[TEMP][3]);
t                1378 modules/calib3d/test/test_fundam.cpp         double t = fabs(f[0]*x2*x1 + f[1]*x2*y1 + f[2]*x2 +
t                1382 modules/calib3d/test/test_fundam.cpp         mtfm2[i] = !status[i] || t0 > err_level || t < err_level;
t                1462 modules/calib3d/test/test_fundam.cpp     int t;
t                1476 modules/calib3d/test/test_fundam.cpp         CV_SWAP( dims1, dims2, t );
t                 683 modules/calib3d/test/test_homography.cpp         double t = (double)getTickCount();
t                 685 modules/calib3d/test/test_homography.cpp         t = (double)getTickCount() - t;
t                 686 modules/calib3d/test/test_homography.cpp         min_t0 = std::min(min_t0, t);
t                 691 modules/calib3d/test/test_homography.cpp         double t = (double)getTickCount();
t                 693 modules/calib3d/test/test_homography.cpp         t = (double)getTickCount() - t;
t                 694 modules/calib3d/test/test_homography.cpp         min_t1 = std::min(min_t1, t);
t                 166 modules/calib3d/test/test_reproject_image_to_3d.cpp                     double err = error(pixel_out, pixel_exp), t = thres<OutT>();
t                 167 modules/calib3d/test/test_reproject_image_to_3d.cpp                     if ( err > t )
t                 170 modules/calib3d/test/test_reproject_image_to_3d.cpp                             caseId, x, y, err, t, res(0,0), res(1,0), res(2,0), res(3,0),
t                 332 modules/calib3d/test/test_solvepnp_ransac.cpp     Mat R,t, RF, tF;
t                 336 modules/calib3d/test/test_solvepnp_ransac.cpp     solvePnPRansac(points3d, points2d, intrinsics, cv::Mat(), R, t, true, 100, 8.f, 0.999, inliers, cv::SOLVEPNP_P3P);
t                 339 modules/calib3d/test/test_solvepnp_ransac.cpp     ASSERT_LE(norm(t, Mat_<double>(tF), NORM_INF), 1e-3);
t                  75 modules/core/include/opencv2/core/affine.hpp         Affine3(const Mat3& R, const Vec3& t = Vec3::all(0));
t                  78 modules/core/include/opencv2/core/affine.hpp         Affine3(const Vec3& rvec, const Vec3& t = Vec3::all(0));
t                  81 modules/core/include/opencv2/core/affine.hpp         explicit Affine3(const Mat& data, const Vec3& t = Vec3::all(0));
t                  99 modules/core/include/opencv2/core/affine.hpp         void translation(const Vec3& t);
t                 117 modules/core/include/opencv2/core/affine.hpp         Affine3 translate(const Vec3& t) const;
t                 185 modules/core/include/opencv2/core/affine.hpp cv::Affine3<T>::Affine3(const Mat3& R, const Vec3& t)
t                 188 modules/core/include/opencv2/core/affine.hpp     translation(t);
t                 194 modules/core/include/opencv2/core/affine.hpp cv::Affine3<T>::Affine3(const Vec3& _rvec, const Vec3& t)
t                 197 modules/core/include/opencv2/core/affine.hpp     translation(t);
t                 203 modules/core/include/opencv2/core/affine.hpp cv::Affine3<T>::Affine3(const cv::Mat& data, const Vec3& t)
t                 220 modules/core/include/opencv2/core/affine.hpp     translation(t);
t                 304 modules/core/include/opencv2/core/affine.hpp void cv::Affine3<T>::translation(const Vec3& t)
t                 306 modules/core/include/opencv2/core/affine.hpp     matrix.val[3] = t[0]; matrix.val[7] = t[1]; matrix.val[11] = t[2];
t                 354 modules/core/include/opencv2/core/affine.hpp             double t;
t                 355 modules/core/include/opencv2/core/affine.hpp             t = (R.val[0] + 1) * 0.5;
t                 356 modules/core/include/opencv2/core/affine.hpp             rx = std::sqrt(std::max(t, 0.0));
t                 357 modules/core/include/opencv2/core/affine.hpp             t = (R.val[4] + 1) * 0.5;
t                 358 modules/core/include/opencv2/core/affine.hpp             ry = std::sqrt(std::max(t, 0.0)) * (R.val[1] < 0 ? -1.0 : 1.0);
t                 359 modules/core/include/opencv2/core/affine.hpp             t = (R.val[8] + 1) * 0.5;
t                 360 modules/core/include/opencv2/core/affine.hpp             rz = std::sqrt(std::max(t, 0.0)) * (R.val[2] < 0 ? -1.0 : 1.0);
t                 405 modules/core/include/opencv2/core/affine.hpp         result(j, 3) = R.row(j).dot(tc.t());
t                 417 modules/core/include/opencv2/core/affine.hpp cv::Affine3<T> cv::Affine3<T>::translate(const Vec3& t) const
t                 420 modules/core/include/opencv2/core/affine.hpp     m.val[ 3] += t[0];
t                 421 modules/core/include/opencv2/core/affine.hpp     m.val[ 7] += t[1];
t                 422 modules/core/include/opencv2/core/affine.hpp     m.val[11] += t[2];
t                  80 modules/core/include/opencv2/core/cuda/block.hpp             It t = beg + flattenedThreadId();
t                  82 modules/core/include/opencv2/core/cuda/block.hpp             for(; t < end; t += STRIDE)
t                  83 modules/core/include/opencv2/core/cuda/block.hpp                 *t = value;
t                  93 modules/core/include/opencv2/core/cuda/block.hpp             for(OutIt t = beg + tid; t < end; t += STRIDE, value += STRIDE)
t                  94 modules/core/include/opencv2/core/cuda/block.hpp                 *t = value;
t                 101 modules/core/include/opencv2/core/cuda/block.hpp             InIt  t = beg + flattenedThreadId();
t                 102 modules/core/include/opencv2/core/cuda/block.hpp             OutIt o = out + (t - beg);
t                 104 modules/core/include/opencv2/core/cuda/block.hpp             for(; t < end; t += STRIDE, o += STRIDE)
t                 105 modules/core/include/opencv2/core/cuda/block.hpp                 *o = *t;
t                 112 modules/core/include/opencv2/core/cuda/block.hpp             InIt  t = beg + flattenedThreadId();
t                 113 modules/core/include/opencv2/core/cuda/block.hpp             OutIt o = out + (t - beg);
t                 115 modules/core/include/opencv2/core/cuda/block.hpp             for(; t < end; t += STRIDE, o += STRIDE)
t                 116 modules/core/include/opencv2/core/cuda/block.hpp                 *o = op(*t);
t                 363 modules/core/include/opencv2/core/cuda/detail/color_detail.hpp             static __device__ __forceinline__ ushort cvt(uint t)
t                 365 modules/core/include/opencv2/core/cuda/detail/color_detail.hpp                 return (ushort)((t >> 3) | ((t & ~3) << 3) | ((t & ~7) << 8));
t                 371 modules/core/include/opencv2/core/cuda/detail/color_detail.hpp             static __device__ __forceinline__ ushort cvt(uint t)
t                 373 modules/core/include/opencv2/core/cuda/detail/color_detail.hpp                 t >>= 3;
t                 374 modules/core/include/opencv2/core/cuda/detail/color_detail.hpp                 return (ushort)(t | (t << 5) | (t << 10));
t                 407 modules/core/include/opencv2/core/cuda/detail/color_detail.hpp             static __device__ __forceinline__ uchar cvt(uint t)
t                 409 modules/core/include/opencv2/core/cuda/detail/color_detail.hpp                 return (uchar)CV_DESCALE(((t << 3) & 0xf8) * B2Y + ((t >> 3) & 0xfc) * G2Y + ((t >> 8) & 0xf8) * R2Y, yuv_shift);
t                 415 modules/core/include/opencv2/core/cuda/detail/color_detail.hpp             static __device__ __forceinline__ uchar cvt(uint t)
t                 417 modules/core/include/opencv2/core/cuda/detail/color_detail.hpp                 return (uchar)CV_DESCALE(((t << 3) & 0xf8) * B2Y + ((t >> 2) & 0xf8) * G2Y + ((t >> 7) & 0xf8) * R2Y, yuv_shift);
t                 140 modules/core/include/opencv2/core/cuda/simd_functions.hpp         unsigned int s, t, u, v;
t                 147 modules/core/include/opencv2/core/cuda/simd_functions.hpp         t = ::max(r, s);    // maximum of high halfwords
t                 149 modules/core/include/opencv2/core/cuda/simd_functions.hpp         r = u | t;          // maximum of both halfwords
t                 440 modules/core/include/opencv2/core/cuda/simd_functions.hpp         unsigned int s, t, u;
t                 443 modules/core/include/opencv2/core/cuda/simd_functions.hpp         t = ::max(r, s);    // maximum of low halfwords
t                 447 modules/core/include/opencv2/core/cuda/simd_functions.hpp         r = t | u;          // combine halfword maximums
t                 463 modules/core/include/opencv2/core/cuda/simd_functions.hpp         unsigned int s, t, u;
t                 466 modules/core/include/opencv2/core/cuda/simd_functions.hpp         t = ::min(r, s);    // minimum of low halfwords
t                 470 modules/core/include/opencv2/core/cuda/simd_functions.hpp         r = t | u;          // combine halfword minimums
t                 490 modules/core/include/opencv2/core/cuda/simd_functions.hpp         unsigned int s, t;
t                 493 modules/core/include/opencv2/core/cuda/simd_functions.hpp         t = b & 0x7f7f7f7f; // clear msbs
t                 495 modules/core/include/opencv2/core/cuda/simd_functions.hpp         r = r + t;          // add without msbs, record carry-out in msbs
t                 514 modules/core/include/opencv2/core/cuda/simd_functions.hpp         unsigned int s, t;
t                 517 modules/core/include/opencv2/core/cuda/simd_functions.hpp         t = b & 0x7f7f7f7f; // clear msbs
t                 519 modules/core/include/opencv2/core/cuda/simd_functions.hpp         r = r - t;          // subtract w/o msbs, record inverted borrows in msb
t                 584 modules/core/include/opencv2/core/cuda/simd_functions.hpp         unsigned int r, t;
t                 588 modules/core/include/opencv2/core/cuda/simd_functions.hpp         t = r << 8;         // convert bool
t                 589 modules/core/include/opencv2/core/cuda/simd_functions.hpp         r = t - r;          //  to mask
t                 593 modules/core/include/opencv2/core/cuda/simd_functions.hpp         t = a ^ b;          // 0x00 if a == b
t                 594 modules/core/include/opencv2/core/cuda/simd_functions.hpp         r = t | 0x80808080; // set msbs, to catch carry out
t                 595 modules/core/include/opencv2/core/cuda/simd_functions.hpp         t = t ^ r;          // extract msbs, msb = 1 if t < 0x80
t                 597 modules/core/include/opencv2/core/cuda/simd_functions.hpp         r = t & ~r;         // msb = 1, if t was 0x00
t                 598 modules/core/include/opencv2/core/cuda/simd_functions.hpp         t = r >> 7;         // build mask
t                 599 modules/core/include/opencv2/core/cuda/simd_functions.hpp         t = r - t;          //  from
t                 600 modules/core/include/opencv2/core/cuda/simd_functions.hpp         r = t | r;          //   msbs
t                  74 modules/core/include/opencv2/core/cuda/warp.hpp             for(It t = beg + laneId(); t < end; t += STRIDE)
t                  75 modules/core/include/opencv2/core/cuda/warp.hpp                 *t = value;
t                  81 modules/core/include/opencv2/core/cuda/warp.hpp             for(InIt t = beg + laneId(); t < end; t += STRIDE, out += STRIDE)
t                  82 modules/core/include/opencv2/core/cuda/warp.hpp                 *out = *t;
t                  89 modules/core/include/opencv2/core/cuda/warp.hpp             for(InIt t = beg + laneId(); t < end; t += STRIDE, out += STRIDE)
t                  90 modules/core/include/opencv2/core/cuda/warp.hpp                 *out = op(*t);
t                 131 modules/core/include/opencv2/core/cuda/warp.hpp             for(OutIt t = beg + lane; t < end; t += STRIDE, value += STRIDE)
t                 132 modules/core/include/opencv2/core/cuda/warp.hpp                 *t = value;
t                  86 modules/core/include/opencv2/core/eigen.hpp         dst = Matx<_Tp, _cols, _rows>(static_cast<const _Tp*>(src.data())).t();
t                 111 modules/core/include/opencv2/core/eigen.hpp             Mat(src.t()).convertTo(_dst, _dst.type());
t                 157 modules/core/include/opencv2/core/eigen.hpp             Mat(src.t()).convertTo(_dst, _dst.type());
t                 201 modules/core/include/opencv2/core/eigen.hpp             Mat(src.t()).convertTo(_dst, _dst.type());
t                 246 modules/core/include/opencv2/core/eigen.hpp             Mat(src.t()).convertTo(_dst, _dst.type());
t                1151 modules/core/include/opencv2/core/mat.hpp     MatExpr t() const;
t                2203 modules/core/include/opencv2/core/mat.hpp     UMat t() const;
t                3269 modules/core/include/opencv2/core/mat.hpp     MatExpr t() const;
t                2459 modules/core/include/opencv2/core/mat.inl.hpp     MatConstIterator t = (const MatConstIterator&)a + ofs;
t                2460 modules/core/include/opencv2/core/mat.inl.hpp     return (MatConstIterator_<_Tp>&)t;
t                2466 modules/core/include/opencv2/core/mat.inl.hpp     MatConstIterator t = (const MatConstIterator&)a + ofs;
t                2467 modules/core/include/opencv2/core/mat.inl.hpp     return (MatConstIterator_<_Tp>&)t;
t                2473 modules/core/include/opencv2/core/mat.inl.hpp     MatConstIterator t = (const MatConstIterator&)a - ofs;
t                2474 modules/core/include/opencv2/core/mat.inl.hpp     return (MatConstIterator_<_Tp>&)t;
t                2596 modules/core/include/opencv2/core/mat.inl.hpp     MatConstIterator t = (const MatConstIterator&)a + ofs;
t                2597 modules/core/include/opencv2/core/mat.inl.hpp     return (MatIterator_<_Tp>&)t;
t                2603 modules/core/include/opencv2/core/mat.inl.hpp     MatConstIterator t = (const MatConstIterator&)a + ofs;
t                2604 modules/core/include/opencv2/core/mat.inl.hpp     return (MatIterator_<_Tp>&)t;
t                2610 modules/core/include/opencv2/core/mat.inl.hpp     MatConstIterator t = (const MatConstIterator&)a - ofs;
t                2611 modules/core/include/opencv2/core/mat.inl.hpp     return (MatIterator_<_Tp>&)t;
t                 156 modules/core/include/opencv2/core/matx.hpp     Matx<_Tp, n, m> t() const;
t                1353 modules/core/include/opencv2/core/matx.hpp     Vec<_Tp,cn> t;
t                1354 modules/core/include/opencv2/core/matx.hpp     for( int i = 0; i < cn; i++ ) t.val[i] = saturate_cast<_Tp>(-a.val[i]);
t                1355 modules/core/include/opencv2/core/matx.hpp     return t;
t                 606 modules/core/include/opencv2/core/ocl.hpp CV_EXPORTS const char* typeToStr(int t);
t                 607 modules/core/include/opencv2/core/ocl.hpp CV_EXPORTS const char* memopTypeToStr(int t);
t                 608 modules/core/include/opencv2/core/ocl.hpp CV_EXPORTS const char* vecopTypeToStr(int t);
t                 343 modules/core/include/opencv2/core/operations.hpp inline RNG::operator double()   { unsigned t = next(); return (((uint64)t << 32) | next()) * 5.4210108624275221700372640043497e-20; }
t                1026 modules/core/include/opencv2/core/types.hpp     double t = 1./((double)b.re*b.re + (double)b.im*b.im);
t                1027 modules/core/include/opencv2/core/types.hpp     return Complex<_Tp>( (_Tp)((a.re*b.re + a.im*b.im)*t),
t                1028 modules/core/include/opencv2/core/types.hpp                         (_Tp)((-a.re*b.im + a.im*b.re)*t) );
t                1040 modules/core/include/opencv2/core/types.hpp     _Tp t = (_Tp)1/b;
t                1041 modules/core/include/opencv2/core/types.hpp     return Complex<_Tp>( a.re*t, a.im*t );
t                1053 modules/core/include/opencv2/core/types.hpp     _Tp t = (_Tp)1/b;
t                1054 modules/core/include/opencv2/core/types.hpp     a.re *= t; a.im *= t; return a;
t                 181 modules/core/include/opencv2/core/types_c.h #define CV_SWAP(a,b,t) ((t) = (a), (a) = (b), (b) = (t))
t                 845 modules/core/include/opencv2/core/types_c.h     CvTermCriteria(const cv::TermCriteria& t) : type(t.type), max_iter(t.maxCount), epsilon(t.epsilon)  {}
t                 854 modules/core/include/opencv2/core/types_c.h     CvTermCriteria t;
t                 856 modules/core/include/opencv2/core/types_c.h     t.type = type;
t                 857 modules/core/include/opencv2/core/types_c.h     t.max_iter = max_iter;
t                 858 modules/core/include/opencv2/core/types_c.h     t.epsilon = (float)epsilon;
t                 860 modules/core/include/opencv2/core/types_c.h     return t;
t                 933 modules/core/misc/java/src/java/core+Mat.java         int t = type();
t                 934 modules/core/misc/java/src/java/core+Mat.java         if (data == null || data.length % CvType.channels(t) != 0)
t                 939 modules/core/misc/java/src/java/core+Mat.java                             CvType.channels(t) + ")");
t                 945 modules/core/misc/java/src/java/core+Mat.java         int t = type();
t                 946 modules/core/misc/java/src/java/core+Mat.java         if (data == null || data.length % CvType.channels(t) != 0)
t                 951 modules/core/misc/java/src/java/core+Mat.java                             CvType.channels(t) + ")");
t                 952 modules/core/misc/java/src/java/core+Mat.java         if (CvType.depth(t) == CvType.CV_32F) {
t                 955 modules/core/misc/java/src/java/core+Mat.java         throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
t                 960 modules/core/misc/java/src/java/core+Mat.java         int t = type();
t                 961 modules/core/misc/java/src/java/core+Mat.java         if (data == null || data.length % CvType.channels(t) != 0)
t                 966 modules/core/misc/java/src/java/core+Mat.java                             CvType.channels(t) + ")");
t                 967 modules/core/misc/java/src/java/core+Mat.java         if (CvType.depth(t) == CvType.CV_32S) {
t                 970 modules/core/misc/java/src/java/core+Mat.java         throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
t                 975 modules/core/misc/java/src/java/core+Mat.java         int t = type();
t                 976 modules/core/misc/java/src/java/core+Mat.java         if (data == null || data.length % CvType.channels(t) != 0)
t                 981 modules/core/misc/java/src/java/core+Mat.java                             CvType.channels(t) + ")");
t                 982 modules/core/misc/java/src/java/core+Mat.java         if (CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) {
t                 985 modules/core/misc/java/src/java/core+Mat.java         throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
t                 990 modules/core/misc/java/src/java/core+Mat.java         int t = type();
t                 991 modules/core/misc/java/src/java/core+Mat.java         if (data == null || data.length % CvType.channels(t) != 0)
t                 996 modules/core/misc/java/src/java/core+Mat.java                             CvType.channels(t) + ")");
t                 997 modules/core/misc/java/src/java/core+Mat.java         if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) {
t                1000 modules/core/misc/java/src/java/core+Mat.java         throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
t                1005 modules/core/misc/java/src/java/core+Mat.java         int t = type();
t                1006 modules/core/misc/java/src/java/core+Mat.java         if (data == null || data.length % CvType.channels(t) != 0)
t                1011 modules/core/misc/java/src/java/core+Mat.java                             CvType.channels(t) + ")");
t                1012 modules/core/misc/java/src/java/core+Mat.java         if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) {
t                1015 modules/core/misc/java/src/java/core+Mat.java         throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
t                1020 modules/core/misc/java/src/java/core+Mat.java         int t = type();
t                1021 modules/core/misc/java/src/java/core+Mat.java         if (data == null || data.length % CvType.channels(t) != 0)
t                1026 modules/core/misc/java/src/java/core+Mat.java                             CvType.channels(t) + ")");
t                1027 modules/core/misc/java/src/java/core+Mat.java         if (CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) {
t                1030 modules/core/misc/java/src/java/core+Mat.java         throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
t                1035 modules/core/misc/java/src/java/core+Mat.java         int t = type();
t                1036 modules/core/misc/java/src/java/core+Mat.java         if (data == null || data.length % CvType.channels(t) != 0)
t                1041 modules/core/misc/java/src/java/core+Mat.java                             CvType.channels(t) + ")");
t                1042 modules/core/misc/java/src/java/core+Mat.java         if (CvType.depth(t) == CvType.CV_32S) {
t                1045 modules/core/misc/java/src/java/core+Mat.java         throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
t                1050 modules/core/misc/java/src/java/core+Mat.java         int t = type();
t                1051 modules/core/misc/java/src/java/core+Mat.java         if (data == null || data.length % CvType.channels(t) != 0)
t                1056 modules/core/misc/java/src/java/core+Mat.java                             CvType.channels(t) + ")");
t                1057 modules/core/misc/java/src/java/core+Mat.java         if (CvType.depth(t) == CvType.CV_32F) {
t                1060 modules/core/misc/java/src/java/core+Mat.java         throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
t                1065 modules/core/misc/java/src/java/core+Mat.java         int t = type();
t                1066 modules/core/misc/java/src/java/core+Mat.java         if (data == null || data.length % CvType.channels(t) != 0)
t                1071 modules/core/misc/java/src/java/core+Mat.java                             CvType.channels(t) + ")");
t                1072 modules/core/misc/java/src/java/core+Mat.java         if (CvType.depth(t) == CvType.CV_64F) {
t                1075 modules/core/misc/java/src/java/core+Mat.java         throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
t                 233 modules/core/misc/java/test/CoreTest.java         assertMatEqual(grayRnd_32f, grayRnd_32f.t(), EPS);
t                 241 modules/core/misc/java/test/CoreTest.java         assertMatEqual(grayRnd_32f, grayRnd_32f.t(), EPS);
t                 948 modules/core/misc/java/test/MatTest.java         assertMatEqual(gray255, gray255.t());
t                 958 modules/core/misc/java/test/MatTest.java         dst = src.t();
t                 663 modules/core/src/array.cpp             int t = idx[i];
t                 664 modules/core/src/array.cpp             if( (unsigned)t >= (unsigned)mat->size[i] )
t                 666 modules/core/src/array.cpp             hashval = hashval*ICV_SPARSE_MAT_HASH_MULTIPLIER + t;
t                 757 modules/core/src/array.cpp             int t = idx[i];
t                 758 modules/core/src/array.cpp             if( (unsigned)t >= (unsigned)mat->size[i] )
t                 760 modules/core/src/array.cpp             hashval = hashval*ICV_SPARSE_MAT_HASH_MULTIPLIER + t;
t                1475 modules/core/src/array.cpp             int t = cvRound( scalar->val[cn] );
t                1476 modules/core/src/array.cpp             ((uchar*)data)[cn] = cv::saturate_cast<uchar>(t);
t                1482 modules/core/src/array.cpp             int t = cvRound( scalar->val[cn] );
t                1483 modules/core/src/array.cpp             ((char*)data)[cn] = cv::saturate_cast<schar>(t);
t                1489 modules/core/src/array.cpp             int t = cvRound( scalar->val[cn] );
t                1490 modules/core/src/array.cpp             ((ushort*)data)[cn] = cv::saturate_cast<ushort>(t);
t                1496 modules/core/src/array.cpp             int t = cvRound( scalar->val[cn] );
t                1497 modules/core/src/array.cpp             ((short*)data)[cn] = cv::saturate_cast<short>(t);
t                1716 modules/core/src/array.cpp                     int t = idx/sz;
t                1717 modules/core/src/array.cpp                     ptr += (idx - t*sz)*mat->dim[j].step;
t                1718 modules/core/src/array.cpp                     idx = t;
t                1736 modules/core/src/array.cpp                 int t = idx / m->size[i];
t                1737 modules/core/src/array.cpp                 _idx[i] = idx - t*m->size[i];
t                1738 modules/core/src/array.cpp                 idx = t;
t                1007 modules/core/src/convert.cpp                 for( int t = 0; t < cn; t++ )
t                1008 modules/core/src/convert.cpp                     ptrs[t+1] += bsz*esz1;
t                1235 modules/core/src/convert.cpp         for( int t = 0; t < total; t += blocksize )
t                1237 modules/core/src/convert.cpp             int bsz = std::min(total - t, blocksize);
t                1240 modules/core/src/convert.cpp             if( t + blocksize < total )
t                2708 modules/core/src/datastructs.cpp         const CvGraphVtx* t;
t                2709 modules/core/src/datastructs.cpp         CV_SWAP( start_vtx, end_vtx, t );
t                2762 modules/core/src/datastructs.cpp         CvGraphVtx* t;
t                2763 modules/core/src/datastructs.cpp         CV_SWAP( start_vtx, end_vtx, t );
t                2849 modules/core/src/datastructs.cpp         CvGraphVtx* t;
t                2850 modules/core/src/datastructs.cpp         CV_SWAP( start_vtx, end_vtx, t );
t                 183 modules/core/src/dxt.cpp     double t;
t                 317 modules/core/src/dxt.cpp         t = -CV_PI*2/n0;
t                 318 modules/core/src/dxt.cpp         w.im = w1.im = sin(t);
t                 342 modules/core/src/dxt.cpp             t = w.re*w1.re - w.im*w1.im;
t                 344 modules/core/src/dxt.cpp             w.re = t;
t                 368 modules/core/src/dxt.cpp             t = w.re*w1.re - w.im*w1.im;
t                 370 modules/core/src/dxt.cpp             w.re = t;
t                 389 modules/core/src/dxt.cpp         Cv32suf t; t.i = 0x80000000;
t                 390 modules/core/src/dxt.cpp         __m128 neg0_mask = _mm_load_ss(&t.f);
t                 546 modules/core/src/dxt.cpp     Complex<T> t;
t                 597 modules/core/src/dxt.cpp                 t.re = src[k0].re; t.im = -src[k0].im;
t                 598 modules/core/src/dxt.cpp                 dst[i] = t;
t                 599 modules/core/src/dxt.cpp                 t.re = src[k1].re; t.im = -src[k1].im;
t                 600 modules/core/src/dxt.cpp                 dst[i+1] = t;
t                 605 modules/core/src/dxt.cpp                 t.re = src[n-1].re; t.im = -src[n-1].im;
t                 606 modules/core/src/dxt.cpp                 dst[i] = t;
t                 627 modules/core/src/dxt.cpp                         CV_SWAP(dst[i+1], dsth[j], t);
t                 630 modules/core/src/dxt.cpp                             CV_SWAP(dst[i], dst[j], t);
t                 631 modules/core/src/dxt.cpp                             CV_SWAP(dsth[i+1], dsth[j+1], t);
t                 644 modules/core/src/dxt.cpp                         CV_SWAP(dst[i], dst[j], t);
t                1019 modules/core/src/dxt.cpp         T t = (src[0] + src[1])*scale;
t                1021 modules/core/src/dxt.cpp         dst[0] = t;
t                1045 modules/core/src/dxt.cpp         T t0, t;
t                1055 modules/core/src/dxt.cpp         t = dst[0] - dst[1];
t                1057 modules/core/src/dxt.cpp         dst[1] = t*scale;
t                1060 modules/core/src/dxt.cpp         t = dst[n-1];
t                1066 modules/core/src/dxt.cpp             h2_re = scale2*(dst[j+1] + t);
t                1071 modules/core/src/dxt.cpp             h1_im = scale2*(dst[j+1] - t);
t                1074 modules/core/src/dxt.cpp             t = h2_re*wave->re - h2_im*wave->im;
t                1076 modules/core/src/dxt.cpp             h2_re = t;
t                1077 modules/core/src/dxt.cpp             t = dst[n-j-1];
t                1088 modules/core/src/dxt.cpp             dst[n2] = -t*scale;
t                1119 modules/core/src/dxt.cpp     T t0, t1, t2, t3, t;
t                1150 modules/core/src/dxt.cpp         t = (src[0] + src[1])*scale;
t                1152 modules/core/src/dxt.cpp         dst[0] = t;
t                1185 modules/core/src/dxt.cpp         t = src[1];
t                1195 modules/core/src/dxt.cpp             h1_re = (t + src[n-j-1]);
t                1198 modules/core/src/dxt.cpp             h2_re = (t - src[n-j-1]);
t                1201 modules/core/src/dxt.cpp             t = h2_re*w->re + h2_im*w->im;
t                1203 modules/core/src/dxt.cpp             h2_re = t;
t                1205 modules/core/src/dxt.cpp             t = src[j+1];
t                1232 modules/core/src/dxt.cpp             t0 = t*2;
t                3224 modules/core/src/dxt.cpp     double t, scale;
t                3242 modules/core/src/dxt.cpp         t = 1./(2*n);
t                3243 modules/core/src/dxt.cpp         scale = (!inv ? 2 : 1)*std::sqrt(t);
t                3244 modules/core/src/dxt.cpp         w1.im = sin(-CV_PI*t);
t                3259 modules/core/src/dxt.cpp             t = w.re*w1.re - w.im*w1.im;
t                3261 modules/core/src/dxt.cpp             w.re = t;
t                3276 modules/core/src/dxt.cpp             t = w.re*w1.re - w.im*w1.im;
t                3278 modules/core/src/dxt.cpp             w.re = t;
t                 423 modules/core/src/kmeans.cpp                             double t = center[j] - old_center[j];
t                 424 modules/core/src/kmeans.cpp                             dist += t*t;
t                 161 modules/core/src/lapack.cpp         _Tp t = std::abs(y) + hypot(p, y);
t                 162 modules/core/src/lapack.cpp         _Tp s = hypot(p, t);
t                 163 modules/core/src/lapack.cpp         _Tp c = t/s;
t                 164 modules/core/src/lapack.cpp         s = p/s; t = (p/t)*p;
t                 166 modules/core/src/lapack.cpp             s = -s, t = -t;
t                 169 modules/core/src/lapack.cpp         W[k] -= t;
t                 170 modules/core/src/lapack.cpp         W[l] += t;
t                 409 modules/core/src/lapack.cpp             _Tp t = At[i*astep + k];
t                 410 modules/core/src/lapack.cpp             sd += (double)t*t;
t                 486 modules/core/src/lapack.cpp             _Tp t = At[i*astep + k];
t                 487 modules/core/src/lapack.cpp             sd += (double)t*t;
t                 546 modules/core/src/lapack.cpp                         _Tp t = (_Tp)(At[i*astep + k] - sd*At[j*astep + k]);
t                 547 modules/core/src/lapack.cpp                         At[i*astep + k] = t;
t                 548 modules/core/src/lapack.cpp                         asum += std::abs(t);
t                 558 modules/core/src/lapack.cpp                 _Tp t = At[i*astep + k];
t                 559 modules/core/src/lapack.cpp                 sd += (double)t*t;
t                 947 modules/core/src/lapack.cpp                     double t[12];
t                 951 modules/core/src/lapack.cpp                     t[0] = (((double)Sf(1,1) * Sf(2,2) - (double)Sf(1,2) * Sf(2,1)) * d);
t                 952 modules/core/src/lapack.cpp                     t[1] = (((double)Sf(0,2) * Sf(2,1) - (double)Sf(0,1) * Sf(2,2)) * d);
t                 953 modules/core/src/lapack.cpp                     t[2] = (((double)Sf(0,1) * Sf(1,2) - (double)Sf(0,2) * Sf(1,1)) * d);
t                 955 modules/core/src/lapack.cpp                     t[3] = (((double)Sf(1,2) * Sf(2,0) - (double)Sf(1,0) * Sf(2,2)) * d);
t                 956 modules/core/src/lapack.cpp                     t[4] = (((double)Sf(0,0) * Sf(2,2) - (double)Sf(0,2) * Sf(2,0)) * d);
t                 957 modules/core/src/lapack.cpp                     t[5] = (((double)Sf(0,2) * Sf(1,0) - (double)Sf(0,0) * Sf(1,2)) * d);
t                 959 modules/core/src/lapack.cpp                     t[6] = (((double)Sf(1,0) * Sf(2,1) - (double)Sf(1,1) * Sf(2,0)) * d);
t                 960 modules/core/src/lapack.cpp                     t[7] = (((double)Sf(0,1) * Sf(2,0) - (double)Sf(0,0) * Sf(2,1)) * d);
t                 961 modules/core/src/lapack.cpp                     t[8] = (((double)Sf(0,0) * Sf(1,1) - (double)Sf(0,1) * Sf(1,0)) * d);
t                 963 modules/core/src/lapack.cpp                     Df(0,0) = (float)t[0]; Df(0,1) = (float)t[1]; Df(0,2) = (float)t[2];
t                 964 modules/core/src/lapack.cpp                     Df(1,0) = (float)t[3]; Df(1,1) = (float)t[4]; Df(1,2) = (float)t[5];
t                 965 modules/core/src/lapack.cpp                     Df(2,0) = (float)t[6]; Df(2,1) = (float)t[7]; Df(2,2) = (float)t[8];
t                 975 modules/core/src/lapack.cpp                     double t[9];
t                 977 modules/core/src/lapack.cpp                     t[0] = (Sd(1,1) * Sd(2,2) - Sd(1,2) * Sd(2,1)) * d;
t                 978 modules/core/src/lapack.cpp                     t[1] = (Sd(0,2) * Sd(2,1) - Sd(0,1) * Sd(2,2)) * d;
t                 979 modules/core/src/lapack.cpp                     t[2] = (Sd(0,1) * Sd(1,2) - Sd(0,2) * Sd(1,1)) * d;
t                 981 modules/core/src/lapack.cpp                     t[3] = (Sd(1,2) * Sd(2,0) - Sd(1,0) * Sd(2,2)) * d;
t                 982 modules/core/src/lapack.cpp                     t[4] = (Sd(0,0) * Sd(2,2) - Sd(0,2) * Sd(2,0)) * d;
t                 983 modules/core/src/lapack.cpp                     t[5] = (Sd(0,2) * Sd(1,0) - Sd(0,0) * Sd(1,2)) * d;
t                 985 modules/core/src/lapack.cpp                     t[6] = (Sd(1,0) * Sd(2,1) - Sd(1,1) * Sd(2,0)) * d;
t                 986 modules/core/src/lapack.cpp                     t[7] = (Sd(0,1) * Sd(2,0) - Sd(0,0) * Sd(2,1)) * d;
t                 987 modules/core/src/lapack.cpp                     t[8] = (Sd(0,0) * Sd(1,1) - Sd(0,1) * Sd(1,0)) * d;
t                 989 modules/core/src/lapack.cpp                     Dd(0,0) = t[0]; Dd(0,1) = t[1]; Dd(0,2) = t[2];
t                 990 modules/core/src/lapack.cpp                     Dd(1,0) = t[3]; Dd(1,1) = t[4]; Dd(1,2) = t[5];
t                 991 modules/core/src/lapack.cpp                     Dd(2,0) = t[6]; Dd(2,1) = t[7]; Dd(2,2) = t[8];
t                1087 modules/core/src/lapack.cpp                     double t;
t                1089 modules/core/src/lapack.cpp                     t = (float)(((double)bf(0)*Sf(1,1) - (double)bf(1)*Sf(0,1))*d);
t                1091 modules/core/src/lapack.cpp                     Df(0,0) = (float)t;
t                1101 modules/core/src/lapack.cpp                     double t;
t                1103 modules/core/src/lapack.cpp                     t = (bd(0)*Sd(1,1) - bd(1)*Sd(0,1))*d;
t                1105 modules/core/src/lapack.cpp                     Dd(0,0) = t;
t                1118 modules/core/src/lapack.cpp                     float t[3];
t                1121 modules/core/src/lapack.cpp                     t[0] = (float)(d*
t                1126 modules/core/src/lapack.cpp                     t[1] = (float)(d*
t                1131 modules/core/src/lapack.cpp                     t[2] = (float)(d*
t                1136 modules/core/src/lapack.cpp                     Df(0,0) = t[0];
t                1137 modules/core/src/lapack.cpp                     Df(1,0) = t[1];
t                1138 modules/core/src/lapack.cpp                     Df(2,0) = t[2];
t                1148 modules/core/src/lapack.cpp                     double t[9];
t                1152 modules/core/src/lapack.cpp                     t[0] = ((Sd(1,1) * Sd(2,2) - Sd(1,2) * Sd(2,1))*bd(0) +
t                1156 modules/core/src/lapack.cpp                     t[1] = ((Sd(1,2) * Sd(2,0) - Sd(1,0) * Sd(2,2))*bd(0) +
t                1160 modules/core/src/lapack.cpp                     t[2] = ((Sd(1,0) * Sd(2,1) - Sd(1,1) * Sd(2,0))*bd(0) +
t                1164 modules/core/src/lapack.cpp                     Dd(0,0) = t[0];
t                1165 modules/core/src/lapack.cpp                     Dd(1,0) = t[1];
t                1166 modules/core/src/lapack.cpp                     Dd(2,0) = t[2];
t                1585 modules/core/src/lapack.cpp             cv::Mat(evals.t()).convertTo(evals0, evals0.type());
t                 330 modules/core/src/lda.cpp         double p = 0, q = 0, r = 0, s = 0, z = 0, t, w, x, y;
t                 633 modules/core/src/lda.cpp                             t = (x * s - z * r) / q;
t                 634 modules/core/src/lda.cpp                             H[i][n1] = t;
t                 636 modules/core/src/lda.cpp                                 H[i + 1][n1] = (-r - w * t) / x;
t                 638 modules/core/src/lda.cpp                                 H[i + 1][n1] = (-s - y * t) / z;
t                 644 modules/core/src/lda.cpp                         t = std::abs(H[i][n1]);
t                 645 modules/core/src/lda.cpp                         if ((eps * t) * t > 1) {
t                 647 modules/core/src/lda.cpp                                 H[j][n1] = H[j][n1] / t;
t                 719 modules/core/src/lda.cpp                         t = std::max(std::abs(H[i][n1 - 1]), std::abs(H[i][n1]));
t                 720 modules/core/src/lda.cpp                         if ((eps * t) * t > 1) {
t                 722 modules/core/src/lda.cpp                                 H[j][n1 - 1] = H[j][n1 - 1] / t;
t                 723 modules/core/src/lda.cpp                                 H[j][n1] = H[j][n1] / t;
t                1111 modules/core/src/lda.cpp    return subspaceProject(_eigenvectors, Mat(), _dataAsRow ? src : src.getMat().t());
t                1116 modules/core/src/lda.cpp    return subspaceReconstruct(_eigenvectors, Mat(), _dataAsRow ? src : src.getMat().t());
t                 109 modules/core/src/lpsolver.cpp         Mat FuncT=Func.t();
t                 562 modules/core/src/mathfuncs.cpp         double t = angle[i]*k1;
t                 563 modules/core/src/mathfuncs.cpp         int it = cvRound(t);
t                 564 modules/core/src/mathfuncs.cpp         t -= it;
t                 568 modules/core/src/mathfuncs.cpp         double sin_b = (sin_a0*t*t + sin_a2)*t;
t                 569 modules/core/src/mathfuncs.cpp         double cos_b = cos_a0*t*t + 1;
t                 371 modules/core/src/matmul.cpp                     WT t = d_buf[j]*alpha;
t                 372 modules/core/src/matmul.cpp                     d_data[j] = T(t + WT(c_data[0])*beta);
t                 829 modules/core/src/matmul.cpp         A = A.t();
t                 832 modules/core/src/matmul.cpp         B = B.t();
t                 338 modules/core/src/matrix.cpp     uint64 t = (uint64)m.step[0]*m.size[0];
t                 339 modules/core/src/matrix.cpp     if( j <= i && t == (size_t)t )
t                1151 modules/core/src/matrix.cpp         int t = CV_MAT_TYPE(flags);
t                1154 modules/core/src/matrix.cpp         return !v.empty() ? Mat(size(), t, (void*)&v[0]) : Mat();
t                1160 modules/core/src/matrix.cpp         int t = CV_8U;
t                1165 modules/core/src/matrix.cpp         Mat m(1, n, t);
t                1177 modules/core/src/matrix.cpp         int t = type(i);
t                1182 modules/core/src/matrix.cpp         return !v.empty() ? Mat(size(i), t, (void*)&v[0]) : Mat();
t                1303 modules/core/src/matrix.cpp         int t = CV_MAT_DEPTH(flags), cn = CV_MAT_CN(flags);
t                1307 modules/core/src/matrix.cpp             mv[i] = Mat(1, cn, t, (void*)(&v[0] + esz*i));
t                1321 modules/core/src/matrix.cpp         int t = CV_MAT_TYPE(flags);
t                1327 modules/core/src/matrix.cpp             mv[i] = Mat(size(i), t, (void*)&v[0]);
t                4423 modules/core/src/matrix.cpp                 int szi = A.size[j], t = _idx/szi;
t                4424 modules/core/src/matrix.cpp                 data += (_idx - t * szi)*A.step[j];
t                4425 modules/core/src/matrix.cpp                 _idx = t;
t                4532 modules/core/src/matrix.cpp     ptrdiff_t t = ofs/szi;
t                4533 modules/core/src/matrix.cpp     int v = (int)(ofs - t*szi);
t                4534 modules/core/src/matrix.cpp     ofs = t;
t                4541 modules/core/src/matrix.cpp         t = ofs/szi;
t                4542 modules/core/src/matrix.cpp         v = (int)(ofs - t*szi);
t                4543 modules/core/src/matrix.cpp         ofs = t;
t                2328 modules/core/src/ocl.cpp     for (size_t t = 0; t < deviceTypes.size(); t++)
t                2331 modules/core/src/ocl.cpp         std::string tempStrDeviceType = deviceTypes[t];
t                2344 modules/core/src/ocl.cpp             std::cerr << "ERROR: Unsupported device type for OpenCL device (GPU, CPU, ACCELERATOR): " << deviceTypes[t] << std::endl;
t                2392 modules/core/src/ocl.cpp     for (size_t t = 0; t < deviceTypes.size(); t++)
t                2393 modules/core/src/ocl.cpp         std::cerr << deviceTypes[t] << " ";
t                 127 modules/core/src/opencl/fft.cl void fft_radix2(__local CT* smem, __global const CT* twiddles, const int x, const int block_size, const int t)
t                 131 modules/core/src/opencl/fft.cl     if (x < t)
t                 134 modules/core/src/opencl/fft.cl         a1 = smem[x+t];
t                 139 modules/core/src/opencl/fft.cl     if (x < t)
t                 146 modules/core/src/opencl/fft.cl void fft_radix2_B2(__local CT* smem, __global const CT* twiddles, const int x1, const int block_size, const int t)
t                 148 modules/core/src/opencl/fft.cl     const int x2 = x1 + t/2;
t                 151 modules/core/src/opencl/fft.cl     if (x1 < t/2)
t                 153 modules/core/src/opencl/fft.cl         a0 = smem[x1]; a1 = smem[x1+t];
t                 154 modules/core/src/opencl/fft.cl         a2 = smem[x2]; a3 = smem[x2+t];
t                 159 modules/core/src/opencl/fft.cl     if (x1 < t/2)
t                 169 modules/core/src/opencl/fft.cl void fft_radix2_B3(__local CT* smem, __global const CT* twiddles, const int x1, const int block_size, const int t)
t                 171 modules/core/src/opencl/fft.cl     const int x2 = x1 + t/3;
t                 172 modules/core/src/opencl/fft.cl     const int x3 = x1 + 2*t/3;
t                 175 modules/core/src/opencl/fft.cl     if (x1 < t/3)
t                 177 modules/core/src/opencl/fft.cl         a0 = smem[x1]; a1 = smem[x1+t];
t                 178 modules/core/src/opencl/fft.cl         a2 = smem[x2]; a3 = smem[x2+t];
t                 179 modules/core/src/opencl/fft.cl         a4 = smem[x3]; a5 = smem[x3+t];
t                 184 modules/core/src/opencl/fft.cl     if (x1 < t/3)
t                 195 modules/core/src/opencl/fft.cl void fft_radix2_B4(__local CT* smem, __global const CT* twiddles, const int x1, const int block_size, const int t)
t                 197 modules/core/src/opencl/fft.cl     const int thread_block = t/4;
t                 203 modules/core/src/opencl/fft.cl     if (x1 < t/4)
t                 205 modules/core/src/opencl/fft.cl         a0 = smem[x1]; a1 = smem[x1+t];
t                 206 modules/core/src/opencl/fft.cl         a2 = smem[x2]; a3 = smem[x2+t];
t                 207 modules/core/src/opencl/fft.cl         a4 = smem[x3]; a5 = smem[x3+t];
t                 208 modules/core/src/opencl/fft.cl         a6 = smem[x4]; a7 = smem[x4+t];
t                 213 modules/core/src/opencl/fft.cl     if (x1 < t/4)
t                 225 modules/core/src/opencl/fft.cl void fft_radix2_B5(__local CT* smem, __global const CT* twiddles, const int x1, const int block_size, const int t)
t                 227 modules/core/src/opencl/fft.cl     const int thread_block = t/5;
t                 234 modules/core/src/opencl/fft.cl     if (x1 < t/5)
t                 236 modules/core/src/opencl/fft.cl         a0 = smem[x1]; a1 = smem[x1+t];
t                 237 modules/core/src/opencl/fft.cl         a2 = smem[x2]; a3 = smem[x2+t];
t                 238 modules/core/src/opencl/fft.cl         a4 = smem[x3]; a5 = smem[x3+t];
t                 239 modules/core/src/opencl/fft.cl         a6 = smem[x4]; a7 = smem[x4+t];
t                 240 modules/core/src/opencl/fft.cl         a8 = smem[x5]; a9 = smem[x5+t];
t                 245 modules/core/src/opencl/fft.cl     if (x1 < t/5)
t                 258 modules/core/src/opencl/fft.cl void fft_radix4(__local CT* smem, __global const CT* twiddles, const int x, const int block_size, const int t)
t                 262 modules/core/src/opencl/fft.cl     if (x < t)
t                 264 modules/core/src/opencl/fft.cl         a0 = smem[x]; a1 = smem[x+t]; a2 = smem[x+2*t]; a3 = smem[x+3*t];
t                 269 modules/core/src/opencl/fft.cl     if (x < t)
t                 276 modules/core/src/opencl/fft.cl void fft_radix4_B2(__local CT* smem, __global const CT* twiddles, const int x1, const int block_size, const int t)
t                 278 modules/core/src/opencl/fft.cl     const int x2 = x1 + t/2;
t                 281 modules/core/src/opencl/fft.cl     if (x1 < t/2)
t                 283 modules/core/src/opencl/fft.cl         a0 = smem[x1]; a1 = smem[x1+t]; a2 = smem[x1+2*t]; a3 = smem[x1+3*t];
t                 284 modules/core/src/opencl/fft.cl         a4 = smem[x2]; a5 = smem[x2+t]; a6 = smem[x2+2*t]; a7 = smem[x2+3*t];
t                 289 modules/core/src/opencl/fft.cl     if (x1 < t/2)
t                 299 modules/core/src/opencl/fft.cl void fft_radix4_B3(__local CT* smem, __global const CT* twiddles, const int x1, const int block_size, const int t)
t                 301 modules/core/src/opencl/fft.cl     const int x2 = x1 + t/3;
t                 302 modules/core/src/opencl/fft.cl     const int x3 = x2 + t/3;
t                 305 modules/core/src/opencl/fft.cl     if (x1 < t/3)
t                 307 modules/core/src/opencl/fft.cl         a0 = smem[x1]; a1 = smem[x1+t]; a2 = smem[x1+2*t]; a3 = smem[x1+3*t];
t                 308 modules/core/src/opencl/fft.cl         a4 = smem[x2]; a5 = smem[x2+t]; a6 = smem[x2+2*t]; a7 = smem[x2+3*t];
t                 309 modules/core/src/opencl/fft.cl         a8 = smem[x3]; a9 = smem[x3+t]; a10 = smem[x3+2*t]; a11 = smem[x3+3*t];
t                 314 modules/core/src/opencl/fft.cl     if (x1 < t/3)
t                 325 modules/core/src/opencl/fft.cl void fft_radix8(__local CT* smem, __global const CT* twiddles, const int x, const int block_size, const int t)
t                 330 modules/core/src/opencl/fft.cl     if (x < t)
t                 335 modules/core/src/opencl/fft.cl         a1 = mul_complex(twiddles[k], smem[x + t]);
t                 336 modules/core/src/opencl/fft.cl         a2 = mul_complex(twiddles[k + block_size],smem[x+2*t]);
t                 337 modules/core/src/opencl/fft.cl         a3 = mul_complex(twiddles[k+2*block_size],smem[x+3*t]);
t                 338 modules/core/src/opencl/fft.cl         a4 = mul_complex(twiddles[k+3*block_size],smem[x+4*t]);
t                 339 modules/core/src/opencl/fft.cl         a5 = mul_complex(twiddles[k+4*block_size],smem[x+5*t]);
t                 340 modules/core/src/opencl/fft.cl         a6 = mul_complex(twiddles[k+5*block_size],smem[x+6*t]);
t                 341 modules/core/src/opencl/fft.cl         a7 = mul_complex(twiddles[k+6*block_size],smem[x+7*t]);
t                 369 modules/core/src/opencl/fft.cl     if (x < t)
t                 388 modules/core/src/opencl/fft.cl void fft_radix3(__local CT* smem, __global const CT* twiddles, const int x, const int block_size, const int t)
t                 392 modules/core/src/opencl/fft.cl     if (x < t)
t                 394 modules/core/src/opencl/fft.cl         a0 = smem[x]; a1 = smem[x+t]; a2 = smem[x+2*t];
t                 399 modules/core/src/opencl/fft.cl     if (x < t)
t                 406 modules/core/src/opencl/fft.cl void fft_radix3_B2(__local CT* smem, __global const CT* twiddles, const int x1, const int block_size, const int t)
t                 408 modules/core/src/opencl/fft.cl     const int x2 = x1 + t/2;
t                 411 modules/core/src/opencl/fft.cl     if (x1 < t/2)
t                 413 modules/core/src/opencl/fft.cl         a0 = smem[x1]; a1 = smem[x1+t]; a2 = smem[x1+2*t];
t                 414 modules/core/src/opencl/fft.cl         a3 = smem[x2]; a4 = smem[x2+t]; a5 = smem[x2+2*t];
t                 419 modules/core/src/opencl/fft.cl     if (x1 < t/2)
t                 429 modules/core/src/opencl/fft.cl void fft_radix3_B3(__local CT* smem, __global const CT* twiddles, const int x1, const int block_size, const int t)
t                 431 modules/core/src/opencl/fft.cl     const int x2 = x1 + t/3;
t                 432 modules/core/src/opencl/fft.cl     const int x3 = x2 + t/3;
t                 435 modules/core/src/opencl/fft.cl     if (x1 < t/3)
t                 437 modules/core/src/opencl/fft.cl         a0 = smem[x1]; a1 = smem[x1+t]; a2 = smem[x1+2*t];
t                 438 modules/core/src/opencl/fft.cl         a3 = smem[x2]; a4 = smem[x2+t]; a5 = smem[x2+2*t];
t                 439 modules/core/src/opencl/fft.cl         a6 = smem[x3]; a7 = smem[x3+t]; a8 = smem[x3+2*t];
t                 444 modules/core/src/opencl/fft.cl     if (x1 < t/3)
t                 455 modules/core/src/opencl/fft.cl void fft_radix3_B4(__local CT* smem, __global const CT* twiddles, const int x1, const int block_size, const int t)
t                 457 modules/core/src/opencl/fft.cl     const int thread_block = t/4;
t                 463 modules/core/src/opencl/fft.cl     if (x1 < t/4)
t                 465 modules/core/src/opencl/fft.cl         a0 = smem[x1]; a1 = smem[x1+t]; a2 = smem[x1+2*t];
t                 466 modules/core/src/opencl/fft.cl         a3 = smem[x2]; a4 = smem[x2+t]; a5 = smem[x2+2*t];
t                 467 modules/core/src/opencl/fft.cl         a6 = smem[x3]; a7 = smem[x3+t]; a8 = smem[x3+2*t];
t                 468 modules/core/src/opencl/fft.cl         a9 = smem[x4]; a10 = smem[x4+t]; a11 = smem[x4+2*t];
t                 473 modules/core/src/opencl/fft.cl     if (x1 < t/4)
t                 485 modules/core/src/opencl/fft.cl void fft_radix5(__local CT* smem, __global const CT* twiddles, const int x, const int block_size, const int t)
t                 490 modules/core/src/opencl/fft.cl     if (x < t)
t                 492 modules/core/src/opencl/fft.cl         a0 = smem[x]; a1 = smem[x + t]; a2 = smem[x+2*t]; a3 = smem[x+3*t]; a4 = smem[x+4*t];
t                 497 modules/core/src/opencl/fft.cl     if (x < t)
t                 504 modules/core/src/opencl/fft.cl void fft_radix5_B2(__local CT* smem, __global const CT* twiddles, const int x1, const int block_size, const int t)
t                 506 modules/core/src/opencl/fft.cl     const int x2 = x1+t/2;
t                 509 modules/core/src/opencl/fft.cl     if (x1 < t/2)
t                 511 modules/core/src/opencl/fft.cl         a0 = smem[x1]; a1 = smem[x1 + t]; a2 = smem[x1+2*t]; a3 = smem[x1+3*t]; a4 = smem[x1+4*t];
t                 512 modules/core/src/opencl/fft.cl         a5 = smem[x2]; a6 = smem[x2 + t]; a7 = smem[x2+2*t]; a8 = smem[x2+3*t]; a9 = smem[x2+4*t];
t                 517 modules/core/src/opencl/fft.cl     if (x1 < t/2)
t                 534 modules/core/src/opencl/fft.cl                                    __global CT* twiddles_ptr, int twiddles_step, int twiddles_offset, const int t, const int nz)
t                 613 modules/core/src/opencl/fft.cl                                    __global CT* twiddles_ptr, int twiddles_step, int twiddles_offset, const int t, const int nz)
t                 674 modules/core/src/opencl/fft.cl                                     __global CT* twiddles_ptr, int twiddles_step, int twiddles_offset, const int t, const int nz)
t                 780 modules/core/src/opencl/fft.cl                               __global CT* twiddles_ptr, int twiddles_step, int twiddles_offset, const int t, const int nz)
t                5631 modules/core/src/persistence.cpp     int t = type();
t                5632 modules/core/src/persistence.cpp     return t == MAP ? (size_t)((CvSet*)node->data.map)->active_count :
t                5633 modules/core/src/persistence.cpp         t == SEQ ? (size_t)node->data.seq->total : (size_t)!isNone();
t                 105 modules/core/src/precomp.hpp #define CV_FAST_CAST_8U(t)   (assert(-256 <= (t) && (t) <= 512), cv::g_Saturate8u[(t)+256])
t                 114 modules/core/src/rand.cpp             int t0, t1, t;
t                 116 modules/core/src/rand.cpp             t = (int)temp;
t                 117 modules/core/src/rand.cpp             t0 = (t & p[i][0]) + p[i][1];
t                 118 modules/core/src/rand.cpp             t1 = ((t >> 8) & p[i+1][0]) + p[i+1][1];
t                 122 modules/core/src/rand.cpp             t0 = ((t >> 16) & p[i+2][0]) + p[i+2][1];
t                 123 modules/core/src/rand.cpp             t1 = ((t >> 24) & p[i+3][0]) + p[i+3][1];
t                  66 modules/core/test/test_ds.cpp     schar *data = seq->array, t;
t                  73 modules/core/test/test_ds.cpp             CV_SWAP( a[k], b[k], t );
t                 234 modules/core/test/test_ds.cpp     int i, t, n = graph->oriented ? 1 : 2;
t                 247 modules/core/test/test_ds.cpp         CV_SWAP( idx1, idx2, t );
t                 254 modules/core/test/test_ds.cpp     int i, t, n = graph->oriented ? 1 : 2;
t                 264 modules/core/test/test_ds.cpp         CV_SWAP( idx1, idx2, t );
t                 425 modules/core/test/test_ds.cpp     int64 t;
t                 434 modules/core/test/test_ds.cpp     t = cv::getTickCount();
t                 435 modules/core/test/test_ds.cpp     test_progress = update_progress( test_progress, 0, 0, (double)(t - start_time)/cpu_freq );
t                 528 modules/core/test/test_ds.cpp         double t;
t                 534 modules/core/test/test_ds.cpp         t = cvtest::randReal(rng)*(max_log_elem_size - min_log_elem_size) + min_log_elem_size;
t                 535 modules/core/test/test_ds.cpp         elem_size = cvRound( exp(t * CV_LOG2) );
t                 984 modules/core/test/test_ds.cpp         double t;
t                 998 modules/core/test/test_ds.cpp                 t = cvtest::randReal(rng)*(max_log_storage_block_size - min_log_storage_block_size)
t                1000 modules/core/test/test_ds.cpp                 storage.reset(cvCreateMemStorage( cvRound( exp(t * CV_LOG2) ) ));
t                1070 modules/core/test/test_ds.cpp         double t;
t                1086 modules/core/test/test_ds.cpp                 t = cvtest::randReal(rng)*(max_log_storage_block_size - min_log_storage_block_size)
t                1088 modules/core/test/test_ds.cpp                 storage.reset(cvCreateMemStorage( cvRound( exp(t * CV_LOG2) ) ));
t                1373 modules/core/test/test_ds.cpp         double t;
t                1384 modules/core/test/test_ds.cpp             t = cvtest::randReal(rng)*(max_log_storage_block_size - min_log_storage_block_size) + min_log_storage_block_size;
t                1385 modules/core/test/test_ds.cpp             storage.reset(cvCreateMemStorage( cvRound( exp(t * CV_LOG2) ) ));
t                1389 modules/core/test/test_ds.cpp                 t = cvtest::randReal(rng)*(max_log_elem_size - min_log_elem_size) + min_log_elem_size;
t                1390 modules/core/test/test_ds.cpp                 int pure_elem_size = cvRound( exp(t * CV_LOG2) );
t                1797 modules/core/test/test_ds.cpp         double t;
t                1808 modules/core/test/test_ds.cpp             t = cvtest::randReal(rng)*(max_log_storage_block_size - min_log_storage_block_size) + min_log_storage_block_size;
t                1809 modules/core/test/test_ds.cpp             int block_size = cvRound( exp(t * CV_LOG2) );
t                1820 modules/core/test/test_ds.cpp                     t = cvtest::randReal(rng)*(max_log_elem_size - min_log_elem_size) + min_log_elem_size;
t                1821 modules/core/test/test_ds.cpp                     int pe = cvRound( exp(t * CV_LOG2) ) - 1; // pure_elem_size==0 does also make sense
t                1914 modules/core/test/test_ds.cpp         double t;
t                1925 modules/core/test/test_ds.cpp             t = cvtest::randReal(rng)*(max_log_storage_block_size - min_log_storage_block_size) + min_log_storage_block_size;
t                1926 modules/core/test/test_ds.cpp             int storage_blocksize = cvRound( exp(t * CV_LOG2) );
t                  24 modules/core/test/test_dxt.cpp         double t = wi.re*w1.re - wi.im*w1.im;
t                  26 modules/core/test/test_dxt.cpp         wi.re = t;
t                  70 modules/core/test/test_hal_core.cpp             double t = (double)getTickCount();
t                  94 modules/core/test/test_hal_core.cpp             t = (double)getTickCount() - t;
t                  95 modules/core/test/test_hal_core.cpp             min_hal_t = std::min(min_hal_t, t);
t                  97 modules/core/test/test_hal_core.cpp             t = (double)getTickCount();
t                 112 modules/core/test/test_hal_core.cpp             t = (double)getTickCount() - t;
t                 113 modules/core/test/test_hal_core.cpp             min_ocv_t = std::min(min_ocv_t, t);
t                 145 modules/core/test/test_hal_core.cpp         a0 = a0*a0.t();
t                 157 modules/core/test/test_hal_core.cpp             double t = (double)getTickCount();
t                 175 modules/core/test/test_hal_core.cpp             t = (double)getTickCount() - t;
t                 176 modules/core/test/test_hal_core.cpp             min_hal_t = std::min(min_hal_t, t);
t                 178 modules/core/test/test_hal_core.cpp             t = (double)getTickCount();
t                 180 modules/core/test/test_hal_core.cpp             t = (double)getTickCount() - t;
t                 181 modules/core/test/test_hal_core.cpp             min_ocv_t = std::min(min_ocv_t, t);
t                 317 modules/core/test/test_mat.cpp         Mat Q = rPoints - repeat( avg, rPoints.rows, 1 ), Qt = Q.t(), eval, evec;
t                 330 modules/core/test/test_mat.cpp         Mat prjTestPoints, backPrjTestPoints, cPoints = rPoints.t(), cTestPoints = rTestPoints.t();
t                 339 modules/core/test/test_mat.cpp             Mat v = evec.row(i).t();
t                 391 modules/core/test/test_mat.cpp             Mat subEvec_t = subEvec.t();
t                 412 modules/core/test/test_mat.cpp         cPCA( rPoints.t(), Mat(), CV_PCA_DATA_AS_COL, maxComponents );
t                 414 modules/core/test/test_mat.cpp         Mat ocvPrjTestPoints = cPCA.project(rTestPoints.t());
t                 415 modules/core/test/test_mat.cpp         err = cvtest::norm(cv::abs(ocvPrjTestPoints), cv::abs(rPrjTestPoints.t()), CV_RELATIVE_L2 );
t                 422 modules/core/test/test_mat.cpp         err = cvtest::norm(cPCA.backProject(ocvPrjTestPoints), rBackPrjTestPoints.t(), CV_RELATIVE_L2 );
t                 431 modules/core/test/test_mat.cpp         cPCA( rPoints.t(), Mat(), CV_PCA_DATA_AS_COL, retainedVariance );
t                 433 modules/core/test/test_mat.cpp         Mat rvPrjTestPoints = cPCA.project(rTestPoints.t());
t                 436 modules/core/test/test_mat.cpp             err = cvtest::norm(cv::abs(rvPrjTestPoints.rowRange(0,maxComponents)), cv::abs(rPrjTestPoints.t()), CV_RELATIVE_L2 );
t                 438 modules/core/test/test_mat.cpp             err = cvtest::norm(cv::abs(rvPrjTestPoints), cv::abs(rPrjTestPoints.colRange(0,cPCA.eigenvectors.rows).t()), CV_RELATIVE_L2 );
t                 446 modules/core/test/test_mat.cpp         err = cvtest::norm(cPCA.backProject(rvPrjTestPoints), rBackPrjTestPoints.t(), CV_RELATIVE_L2 );
t                 488 modules/core/test/test_mat.cpp         avg = avg.t(); _avg = avg;
t                 489 modules/core/test/test_mat.cpp         eval = eval.t(); _eval = eval;
t                 490 modules/core/test/test_mat.cpp         evec = evec.t(); _evec = evec;
t                 491 modules/core/test/test_mat.cpp         prjTestPoints = prjTestPoints.t(); _prjTestPoints = prjTestPoints;
t                 492 modules/core/test/test_mat.cpp         backPrjTestPoints = backPrjTestPoints.t(); _backPrjTestPoints = backPrjTestPoints;
t                 498 modules/core/test/test_mat.cpp         err = cvtest::norm(cv::abs(prjTestPoints), cv::abs(rPrjTestPoints.t()), CV_RELATIVE_L2 );
t                 505 modules/core/test/test_mat.cpp         err = cvtest::norm(backPrjTestPoints, rBackPrjTestPoints.t(), CV_RELATIVE_L2);
t                1247 modules/core/test/test_mat.cpp         mat_U *= mat_U.t();
t                1400 modules/core/test/test_math.cpp     double t, det = 1.;
t                1412 modules/core/test/test_math.cpp             t = fabs(a0[j*step + i]);
t                1413 modules/core/test/test_math.cpp             if( max_val < t )
t                1415 modules/core/test/test_math.cpp                 max_val = t;
t                1423 modules/core/test/test_math.cpp                 CV_SWAP( a0[i*step + j], a0[k*step + j], t );
t                1426 modules/core/test/test_math.cpp                 CV_SWAP( b0[i*b_step + j], b0[k*b_step + j], t );
t                1444 modules/core/test/test_math.cpp             t = a2[i]/a1[i];
t                1446 modules/core/test/test_math.cpp                 a2[k] -= t*a1[k];
t                1449 modules/core/test/test_math.cpp                 b2[k] -= t*b1[k];
t                1465 modules/core/test/test_math.cpp                 t = b1[j];
t                1467 modules/core/test/test_math.cpp                     t -= a1[k]*x0[k*x_step + j];
t                1468 modules/core/test/test_math.cpp                 x0[i*x_step + j] = t/a1[i];
t                2567 modules/core/test/test_math.cpp     cv::Mat b = a.t()*a;
t                  31 modules/core/test/test_misc.cpp static double maxAbsDiff(const T &t, const U &u)
t                  34 modules/core/test/test_misc.cpp   absdiff(t, u, d);
t                 352 modules/core/test/test_operations.cpp         MatExpr mt_tr = mt.t();
t                 353 modules/core/test/test_operations.cpp         MatExpr mi_tr = mi.t();
t                 374 modules/core/test/test_operations.cpp         m = mi.clone(); m*=mt_tr.t(); CHECK_DIFF_FLT(m, d1);
t                 378 modules/core/test/test_operations.cpp         CHECK_DIFF_FLT( mt.t() * mi_tr, d1 );
t                 379 modules/core/test/test_operations.cpp         CHECK_DIFF_FLT( mt_tr * mi.t(), d1 );
t                 382 modules/core/test/test_operations.cpp         CHECK_DIFF_FLT( mt.t() * (mi_tr * 2), d2 );
t                 383 modules/core/test/test_operations.cpp         CHECK_DIFF_FLT( (mt_tr * 2) * mi.t(), d2 );
t                 385 modules/core/test/test_operations.cpp         CHECK_DIFF_FLT(mt.t() * mi.t(), d1);
t                 399 modules/core/test/test_operations.cpp         CHECK_DIFF_FLT( (mt * 2.0 + 1.0) * mi.t(), mt_mul_2_plus_1 * mi_tr); // (A*alpha + beta)*B^t
t                 400 modules/core/test/test_operations.cpp         CHECK_DIFF_FLT( mi.t() * (mt * 2.0 + 1.0), mi_tr * mt_mul_2_plus_1); // A^t*(B*alpha + beta)
t                 415 modules/core/test/test_operations.cpp         CHECK_DIFF_FLT( (mi * mt) + mi.t(), mi_tr + d1);
t                 416 modules/core/test/test_operations.cpp         CHECK_DIFF_FLT( mi.t() + (mi * mt), mi_tr + d1);
t                 417 modules/core/test/test_operations.cpp         CHECK_DIFF_FLT( (mi * mt) - mi.t(), d1 - mi_tr);
t                 418 modules/core/test/test_operations.cpp         CHECK_DIFF_FLT( mi.t() - (mi * mt), mi_tr - d1);
t                 729 modules/core/test/test_operations.cpp         Mat_<float> mt_tr = mt.t();
t                 730 modules/core/test/test_operations.cpp         Mat_<float> mi_tr = mi.t();
t                 785 modules/core/test/test_operations.cpp         Mat c = (a*b.t()).t();
t                1073 modules/core/test/test_operations.cpp         if( cvtest::norm(A*svd.vt.row(3).t(), CV_C) > FLT_EPSILON )
t                1089 modules/core/test/test_operations.cpp         Q=Dp*Dc.t();
t                1097 modules/core/test/test_operations.cpp         if( cvtest::norm(U*U.t(), I, CV_C) > FLT_EPSILON ||
t                1098 modules/core/test/test_operations.cpp             cvtest::norm(Vt*Vt.t(), I, CV_C) > FLT_EPSILON ||
t                 520 modules/core/test/test_umat.cpp     EXPECT_MAT_NEAR(ua.diag(), new_diag.t(), 0);
t                 816 modules/core/test/test_umat.cpp     Mat t(1, 9000, CV_32FC2, Scalar::all(-200)), t2(1, 9000, CV_32FC2, Scalar::all(-1));
t                 817 modules/core/test/test_umat.cpp     m.colRange(0, 9000).copyTo(t);
t                 819 modules/core/test/test_umat.cpp     EXPECT_MAT_NEAR(t, t2, 0);
t                 300 modules/cudaimgproc/perf/perf_hough.cpp             obj = obj.t();
t                  83 modules/cudaimgproc/test/test_histogram.cpp     hist_gold = hist_gold.t();
t                 406 modules/cudalegacy/include/opencv2/cudalegacy/NCV.hpp CV_EXPORTS double ncvEndQueryTimerUs(NcvTimer t);
t                 408 modules/cudalegacy/include/opencv2/cudalegacy/NCV.hpp CV_EXPORTS double ncvEndQueryTimerMs(NcvTimer t);
t                 227 modules/cudalegacy/include/opencv2/cudalegacy/NCVHaarObjectDetection.hpp     __host__ NCVStatus setThreshold(Ncv32f t)
t                 229 modules/cudalegacy/include/opencv2/cudalegacy/NCVHaarObjectDetection.hpp         this->_ui4.y = *(Ncv32u_a *)&t;
t                 275 modules/cudalegacy/include/opencv2/cudalegacy/NCVHaarObjectDetection.hpp     __host__ NCVStatus setStageThreshold(Ncv32f t)
t                 277 modules/cudalegacy/include/opencv2/cudalegacy/NCVHaarObjectDetection.hpp         this->_ui2.x = *(Ncv32u_a *)&t;
t                 623 modules/cudalegacy/src/NCV.cpp     static void _ncvQueryMoment(NcvTimeMoment *t)
t                 625 modules/cudalegacy/src/NCV.cpp         QueryPerformanceFrequency((LARGE_INTEGER *)&(t->freq));
t                 626 modules/cudalegacy/src/NCV.cpp         QueryPerformanceCounter((LARGE_INTEGER *)&(t->moment));
t                 630 modules/cudalegacy/src/NCV.cpp     double _ncvMomentToMicroseconds(NcvTimeMoment *t)
t                 632 modules/cudalegacy/src/NCV.cpp         return 1000000.0 * t->moment / t->freq;
t                 658 modules/cudalegacy/src/NCV.cpp     void _ncvQueryMoment(NcvTimeMoment *t)
t                 660 modules/cudalegacy/src/NCV.cpp         gettimeofday(& t->tv, & t->tz);
t                 664 modules/cudalegacy/src/NCV.cpp     double _ncvMomentToMicroseconds(NcvTimeMoment *t)
t                 666 modules/cudalegacy/src/NCV.cpp         return 1000000.0 * t->tv.tv_sec + (double)t->tv.tv_usec;
t                 691 modules/cudalegacy/src/NCV.cpp     struct _NcvTimer *t;
t                 692 modules/cudalegacy/src/NCV.cpp     t = (struct _NcvTimer *)malloc(sizeof(struct _NcvTimer));
t                 693 modules/cudalegacy/src/NCV.cpp     _ncvQueryMoment(&t->t1);
t                 694 modules/cudalegacy/src/NCV.cpp     return t;
t                 698 modules/cudalegacy/src/NCV.cpp double ncvEndQueryTimerUs(NcvTimer t)
t                 701 modules/cudalegacy/src/NCV.cpp     _ncvQueryMoment(&t->t2);
t                 702 modules/cudalegacy/src/NCV.cpp     res = _ncvMomentsDiffToMicroseconds(&t->t1, &t->t2);
t                 703 modules/cudalegacy/src/NCV.cpp     free(t);
t                 708 modules/cudalegacy/src/NCV.cpp double ncvEndQueryTimerMs(NcvTimer t)
t                 711 modules/cudalegacy/src/NCV.cpp     _ncvQueryMoment(&t->t2);
t                 712 modules/cudalegacy/src/NCV.cpp     res = _ncvMomentsDiffToMilliseconds(&t->t1, &t->t2);
t                 713 modules/cudalegacy/src/NCV.cpp     free(t);
t                  78 modules/cudev/include/opencv2/cudev/block/block.hpp     It t = beg + Block::threadLineId();
t                  80 modules/cudev/include/opencv2/cudev/block/block.hpp     for(; t < end; t += STRIDE)
t                  81 modules/cudev/include/opencv2/cudev/block/block.hpp         *t = value;
t                  91 modules/cudev/include/opencv2/cudev/block/block.hpp     for(OutIt t = beg + tid; t < end; t += STRIDE, value += STRIDE)
t                  92 modules/cudev/include/opencv2/cudev/block/block.hpp         *t = value;
t                  99 modules/cudev/include/opencv2/cudev/block/block.hpp     InIt  t = beg + Block::threadLineId();
t                 100 modules/cudev/include/opencv2/cudev/block/block.hpp     OutIt o = out + (t - beg);
t                 102 modules/cudev/include/opencv2/cudev/block/block.hpp     for(; t < end; t += STRIDE, o += STRIDE)
t                 103 modules/cudev/include/opencv2/cudev/block/block.hpp         *o = *t;
t                 110 modules/cudev/include/opencv2/cudev/block/block.hpp     InIt  t = beg + Block::threadLineId();
t                 111 modules/cudev/include/opencv2/cudev/block/block.hpp     OutIt o = out + (t - beg);
t                 113 modules/cudev/include/opencv2/cudev/block/block.hpp     for(; t < end; t += STRIDE, o += STRIDE)
t                 114 modules/cudev/include/opencv2/cudev/block/block.hpp         *o = op(*t);
t                 266 modules/cudev/include/opencv2/cudev/functional/detail/color_cvt.hpp             const int t = src >> 3;
t                 267 modules/cudev/include/opencv2/cudev/functional/detail/color_cvt.hpp             return (ushort)(t | (t << 5) | (t << 10));
t                 276 modules/cudev/include/opencv2/cudev/functional/detail/color_cvt.hpp             const int t = src;
t                 277 modules/cudev/include/opencv2/cudev/functional/detail/color_cvt.hpp             return (ushort)((t >> 3) | ((t & ~3) << 3) | ((t & ~7) << 8));
t                  64 modules/cudev/include/opencv2/cudev/functional/tuple_adapter.hpp     __device__ __forceinline__ typename Op::result_type operator ()(const Tuple& t) const
t                  66 modules/cudev/include/opencv2/cudev/functional/tuple_adapter.hpp         return op(get<n>(t));
t                  85 modules/cudev/include/opencv2/cudev/functional/tuple_adapter.hpp     __device__ __forceinline__ typename Op::result_type operator ()(const Tuple& t) const
t                  87 modules/cudev/include/opencv2/cudev/functional/tuple_adapter.hpp         return op(get<n0>(t), get<n1>(t));
t                  67 modules/cudev/include/opencv2/cudev/ptr2d/zip.hpp     __host__ __device__ __forceinline__ ZipPtr(const tuple<Ptr0, Ptr1>& t) : tuple<Ptr0, Ptr1>(t) {}
t                  83 modules/cudev/include/opencv2/cudev/ptr2d/zip.hpp     __host__ __device__ __forceinline__ ZipPtr(const tuple<Ptr0, Ptr1, Ptr2>& t) : tuple<Ptr0, Ptr1, Ptr2>(t) {}
t                 100 modules/cudev/include/opencv2/cudev/ptr2d/zip.hpp     __host__ __device__ __forceinline__ ZipPtr(const tuple<Ptr0, Ptr1, Ptr2, Ptr3>& t) : tuple<Ptr0, Ptr1, Ptr2, Ptr3>(t) {}
t                 113 modules/cudev/include/opencv2/cudev/ptr2d/zip.hpp     __host__ __device__ __forceinline__ ZipPtrSz(const PtrTuple& t) : ZipPtr<PtrTuple>(t) {}
t                 188 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     uint s, t, u, v;
t                 195 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     t = ::max(r, s);    // maximum of high halfwords
t                 197 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     r = u | t;          // maximum of both halfwords
t                 488 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     uint s, t, u;
t                 491 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     t = ::max(r, s);    // maximum of low halfwords
t                 495 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     r = t | u;          // combine halfword maximums
t                 511 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     uint s, t, u;
t                 514 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     t = ::min(r, s);    // minimum of low halfwords
t                 518 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     r = t | u;          // combine halfword minimums
t                 538 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     uint s, t;
t                 541 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     t = b & 0x7f7f7f7f; // clear msbs
t                 543 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     r = r + t;          // add without msbs, record carry-out in msbs
t                 562 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     uint s, t;
t                 565 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     t = b & 0x7f7f7f7f; // clear msbs
t                 567 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     r = r - t;          // subtract w/o msbs, record inverted borrows in msb
t                 632 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     uint r, t;
t                 636 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     t = r << 8;         // convert bool
t                 637 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     r = t - r;          //  to mask
t                 641 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     t = a ^ b;          // 0x00 if a == b
t                 642 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     r = t | 0x80808080; // set msbs, to catch carry out
t                 643 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     t = t ^ r;          // extract msbs, msb = 1 if t < 0x80
t                 645 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     r = t & ~r;         // msb = 1, if t was 0x00
t                 646 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     t = r >> 7;         // build mask
t                 647 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     t = r - t;          //  from
t                 648 modules/cudev/include/opencv2/cudev/util/simd_functions.hpp     r = t | r;          //   msbs
t                  81 modules/cudev/include/opencv2/cudev/warp/warp.hpp     for(It t = beg + Warp::laneId(); t < end; t += WARP_SIZE)
t                  82 modules/cudev/include/opencv2/cudev/warp/warp.hpp         *t = value;
t                  88 modules/cudev/include/opencv2/cudev/warp/warp.hpp     for(InIt t = beg + Warp::laneId(); t < end; t += WARP_SIZE, out += WARP_SIZE)
t                  89 modules/cudev/include/opencv2/cudev/warp/warp.hpp         *out = *t;
t                  96 modules/cudev/include/opencv2/cudev/warp/warp.hpp     for(InIt t = beg + Warp::laneId(); t < end; t += WARP_SIZE, out += WARP_SIZE)
t                  97 modules/cudev/include/opencv2/cudev/warp/warp.hpp         *out = op(*t);
t                 119 modules/cudev/include/opencv2/cudev/warp/warp.hpp     for(OutIt t = beg + lane; t < end; t += WARP_SIZE, value += WARP_SIZE)
t                 120 modules/cudev/include/opencv2/cudev/warp/warp.hpp         *t = value;
t                7581 modules/features2d/src/agast.cpp             int t;
t                7616 modules/features2d/src/agast.cpp             t = (int)curr_idx - 1;
t                7617 modules/features2d/src/agast.cpp             if( (curr_idx != 0) && (keypoints[t].pt.y == currCorner->pt.y)
t                7618 modules/features2d/src/agast.cpp              && (keypoints[t].pt.x + 1 == currCorner->pt.x) )
t                7622 modules/features2d/src/agast.cpp                 while(nmsFlags[t] != -1)
t                7623 modules/features2d/src/agast.cpp                     t = nmsFlags[t];
t                7627 modules/features2d/src/agast.cpp                     if((size_t)t != curr_idx)
t                7629 modules/features2d/src/agast.cpp                         if ( keypoints[curr_idx].response < keypoints[t].response )
t                7630 modules/features2d/src/agast.cpp                             nmsFlags[curr_idx] = t;
t                7632 modules/features2d/src/agast.cpp                             nmsFlags[t] = (int)curr_idx;
t                7637 modules/features2d/src/agast.cpp                     if(t != currCornerMaxAbove_ind)
t                7639 modules/features2d/src/agast.cpp                         if(keypoints[currCornerMaxAbove_ind].response < keypoints[t].response)
t                7641 modules/features2d/src/agast.cpp                             nmsFlags[currCornerMaxAbove_ind] = t;
t                7642 modules/features2d/src/agast.cpp                             nmsFlags[curr_idx] = t;
t                7646 modules/features2d/src/agast.cpp                             nmsFlags[t] = currCornerMaxAbove_ind;
t                 115 modules/features2d/src/akaze.cpp                     int t = (6 + 36 + 120) * descriptor_channels;
t                 116 modules/features2d/src/akaze.cpp                     return (int)ceil(t / 8.);
t                 175 modules/features2d/src/evaluation.cpp     Mat_<double> dstM; invert(Aff*invM*Aff.t(), dstM);
t                  72 modules/features2d/src/fast.cpp     __m128i delta = _mm_set1_epi8(-128), t = _mm_set1_epi8((char)threshold), K16 = _mm_set1_epi8((char)K);
t                  75 modules/features2d/src/fast.cpp     (void)t;
t                 108 modules/features2d/src/fast.cpp                     __m128i v1 = _mm_xor_si128(_mm_subs_epu8(v0, t), delta);
t                 109 modules/features2d/src/fast.cpp                     v0 = _mm_xor_si128(_mm_adds_epu8(v0, t), delta);
t                 722 modules/features2d/src/kaze/AKAZEFeatures.cpp       int t = (6 + 36 + 120)*options_.descriptor_channels;
t                 723 modules/features2d/src/kaze/AKAZEFeatures.cpp       desc = Mat::zeros((int)kpts.size(), (int)ceil(t / 8.), CV_8UC1);
t                  69 modules/features2d/src/kaze/fed.cpp int fed_tau_by_cycle_time(const float& t, const float& tau_max,
t                  75 modules/features2d/src/kaze/fed.cpp   n = (int)(ceilf(sqrtf(3.0f*t/tau_max+0.25f)-0.5f-1.0e-8f)+ 0.5f);
t                  76 modules/features2d/src/kaze/fed.cpp   scale = 3.0f*t/(tau_max*(float)(n*(n+1)));
t                  16 modules/features2d/src/kaze/fed.h int fed_tau_by_cycle_time(const float& t, const float& tau_max,
t                 221 modules/features2d/src/opencl/brute_force_match.cl     for (int t = 0, endt = (train_rows + BLOCK_SIZE - 1) / BLOCK_SIZE; t < endt; t++)
t                 225 modules/features2d/src/opencl/brute_force_match.cl         const int trainOffset = min(mad24(BLOCK_SIZE, t, lidy), train_rows - 1) * step;
t                 267 modules/features2d/src/opencl/brute_force_match.cl         const int trainIdx = mad24(BLOCK_SIZE, t, lidx);
t                 425 modules/features2d/src/opencl/brute_force_match.cl     for (int t = 0, endt = (train_rows + BLOCK_SIZE - 1) / BLOCK_SIZE; t < endt ; t++)
t                 429 modules/features2d/src/opencl/brute_force_match.cl         int trainOffset = min(mad24(BLOCK_SIZE, t, lidy), train_rows - 1) * step;
t                 471 modules/features2d/src/opencl/brute_force_match.cl         const int trainIdx = mad24(BLOCK_SIZE, t, lidx);
t                 213 modules/features2d/test/test_descriptors_regression.cpp             double t = (double)getTickCount();
t                 215 modules/features2d/test/test_descriptors_regression.cpp             t = getTickCount() - t;
t                 216 modules/features2d/test/test_descriptors_regression.cpp             ts->printf(cvtest::TS::LOG, "\nAverage time of computing one descriptor = %g ms.\n", t/((double)getTickFrequency()*1000.)/calcDescriptors.rows);
t                 224 modules/flann/include/opencv2/flann/autotuned_index.h         StartStopTimer t;
t                 233 modules/flann/include/opencv2/flann/autotuned_index.h         t.start();
t                 235 modules/flann/include/opencv2/flann/autotuned_index.h         t.stop();
t                 236 modules/flann/include/opencv2/flann/autotuned_index.h         float buildTime = (float)t.value;
t                 251 modules/flann/include/opencv2/flann/autotuned_index.h         StartStopTimer t;
t                 258 modules/flann/include/opencv2/flann/autotuned_index.h         t.start();
t                 260 modules/flann/include/opencv2/flann/autotuned_index.h         t.stop();
t                 261 modules/flann/include/opencv2/flann/autotuned_index.h         float buildTime = (float)t.value;
t                 435 modules/flann/include/opencv2/flann/autotuned_index.h         StartStopTimer t;
t                 436 modules/flann/include/opencv2/flann/autotuned_index.h         t.start();
t                 438 modules/flann/include/opencv2/flann/autotuned_index.h         t.stop();
t                 441 modules/flann/include/opencv2/flann/autotuned_index.h         linear_cost.searchTimeCost = (float)t.value;
t                 506 modules/flann/include/opencv2/flann/autotuned_index.h             StartStopTimer t;
t                 507 modules/flann/include/opencv2/flann/autotuned_index.h             t.start();
t                 509 modules/flann/include/opencv2/flann/autotuned_index.h             t.stop();
t                 510 modules/flann/include/opencv2/flann/autotuned_index.h             float linear = (float)t.value;
t                 107 modules/flann/include/opencv2/flann/index_testing.h     StartStopTimer t;
t                 109 modules/flann/include/opencv2/flann/index_testing.h     while (t.value<0.2) {
t                 111 modules/flann/include/opencv2/flann/index_testing.h         t.start();
t                 121 modules/flann/include/opencv2/flann/index_testing.h         t.stop();
t                 123 modules/flann/include/opencv2/flann/index_testing.h     time = float(t.value/repeats);
t                1042 modules/flann/include/opencv2/flann/kmeans_index.h             DistanceType t = c[i]-p[i];
t                1043 modules/flann/include/opencv2/flann/kmeans_index.h             sum += t*(q[i]-(c[i]+p[i])/2);
t                1044 modules/flann/include/opencv2/flann/kmeans_index.h             sum2 += t*t;
t                 368 modules/hal/include/opencv2/hal/defs.h     __m128d t = _mm_set_sd( value );
t                 369 modules/hal/include/opencv2/hal/defs.h     return _mm_cvtsd_si32(t);
t                 371 modules/hal/include/opencv2/hal/defs.h     int t;
t                 375 modules/hal/include/opencv2/hal/defs.h         fistp t;
t                 377 modules/hal/include/opencv2/hal/defs.h     return t;
t                 405 modules/hal/include/opencv2/hal/defs.h     __m128d t = _mm_set_sd( value );
t                 406 modules/hal/include/opencv2/hal/defs.h     int i = _mm_cvtsd_si32(t);
t                 407 modules/hal/include/opencv2/hal/defs.h     return i - _mm_movemask_pd(_mm_cmplt_sd(t, _mm_cvtsi32_sd(t,i)));
t                 428 modules/hal/include/opencv2/hal/defs.h     __m128d t = _mm_set_sd( value );
t                 429 modules/hal/include/opencv2/hal/defs.h     int i = _mm_cvtsd_si32(t);
t                 430 modules/hal/include/opencv2/hal/defs.h     return i + _mm_movemask_pd(_mm_cmplt_sd(_mm_cvtsi32_sd(t,i), t));
t                 476 modules/hal/include/opencv2/hal/defs.h     __m128 t = _mm_set_ss( value );
t                 477 modules/hal/include/opencv2/hal/defs.h     return _mm_cvtss_si32(t);
t                 479 modules/hal/include/opencv2/hal/defs.h     int t;
t                 483 modules/hal/include/opencv2/hal/defs.h         fistp t;
t                 485 modules/hal/include/opencv2/hal/defs.h     return t;
t                 512 modules/hal/include/opencv2/hal/defs.h     __m128 t = _mm_set_ss( value );
t                 513 modules/hal/include/opencv2/hal/defs.h     int i = _mm_cvtss_si32(t);
t                 514 modules/hal/include/opencv2/hal/defs.h     return i - _mm_movemask_ps(_mm_cmplt_ss(t, _mm_cvtsi32_ss(t,i)));
t                 535 modules/hal/include/opencv2/hal/defs.h     __m128 t = _mm_set_ss( value );
t                 536 modules/hal/include/opencv2/hal/defs.h     int i = _mm_cvtss_si32(t);
t                 537 modules/hal/include/opencv2/hal/defs.h     return i + _mm_movemask_ps(_mm_cmplt_ss(_mm_cvtsi32_ss(t,i), t));
t                 686 modules/hal/include/opencv2/hal/intrin_sse.hpp     __m128 t = x.val;
t                 687 modules/hal/include/opencv2/hal/intrin_sse.hpp     __m128 h = _mm_mul_ps(t, _0_5);
t                 688 modules/hal/include/opencv2/hal/intrin_sse.hpp     t = _mm_rsqrt_ps(t);
t                 689 modules/hal/include/opencv2/hal/intrin_sse.hpp     t = _mm_mul_ps(t, _mm_sub_ps(_1_5, _mm_mul_ps(_mm_mul_ps(t, t), h)));
t                 690 modules/hal/include/opencv2/hal/intrin_sse.hpp     return v_float32x4(t);
t                 571 modules/hal/src/mathfuncs.cpp             int val0, val1, val2, val3, t;
t                 595 modules/hal/src/mathfuncs.cpp             t = (val0 >> EXPTAB_SCALE) + 127;
t                 596 modules/hal/src/mathfuncs.cpp             t = !(t & ~255) ? t : t < 0 ? 0 : 255;
t                 597 modules/hal/src/mathfuncs.cpp             buf[0].i = t << 23;
t                 599 modules/hal/src/mathfuncs.cpp             t = (val1 >> EXPTAB_SCALE) + 127;
t                 600 modules/hal/src/mathfuncs.cpp             t = !(t & ~255) ? t : t < 0 ? 0 : 255;
t                 601 modules/hal/src/mathfuncs.cpp             buf[1].i = t << 23;
t                 603 modules/hal/src/mathfuncs.cpp             t = (val2 >> EXPTAB_SCALE) + 127;
t                 604 modules/hal/src/mathfuncs.cpp             t = !(t & ~255) ? t : t < 0 ? 0 : 255;
t                 605 modules/hal/src/mathfuncs.cpp             buf[2].i = t << 23;
t                 607 modules/hal/src/mathfuncs.cpp             t = (val3 >> EXPTAB_SCALE) + 127;
t                 608 modules/hal/src/mathfuncs.cpp             t = !(t & ~255) ? t : t < 0 ? 0 : 255;
t                 609 modules/hal/src/mathfuncs.cpp             buf[3].i = t << 23;
t                 627 modules/hal/src/mathfuncs.cpp         int val0, t;
t                 633 modules/hal/src/mathfuncs.cpp         t = (val0 >> EXPTAB_SCALE) + 127;
t                 634 modules/hal/src/mathfuncs.cpp         t = !(t & ~255) ? t : t < 0 ? 0 : 255;
t                 636 modules/hal/src/mathfuncs.cpp         buf[0].i = t << 23;
t                 735 modules/hal/src/mathfuncs.cpp         int val0, val1, val2, val3, t;
t                 737 modules/hal/src/mathfuncs.cpp         t = (int)(x[i].i >> 52);
t                 738 modules/hal/src/mathfuncs.cpp         if( (t & 2047) > 1023 + 10 )
t                 739 modules/hal/src/mathfuncs.cpp             x0 = t < 0 ? -exp_max_val : exp_max_val;
t                 741 modules/hal/src/mathfuncs.cpp         t = (int)(x[i+1].i >> 52);
t                 742 modules/hal/src/mathfuncs.cpp         if( (t & 2047) > 1023 + 10 )
t                 743 modules/hal/src/mathfuncs.cpp             x1 = t < 0 ? -exp_max_val : exp_max_val;
t                 745 modules/hal/src/mathfuncs.cpp         t = (int)(x[i+2].i >> 52);
t                 746 modules/hal/src/mathfuncs.cpp         if( (t & 2047) > 1023 + 10 )
t                 747 modules/hal/src/mathfuncs.cpp             x2 = t < 0 ? -exp_max_val : exp_max_val;
t                 749 modules/hal/src/mathfuncs.cpp         t = (int)(x[i+3].i >> 52);
t                 750 modules/hal/src/mathfuncs.cpp         if( (t & 2047) > 1023 + 10 )
t                 751 modules/hal/src/mathfuncs.cpp             x3 = t < 0 ? -exp_max_val : exp_max_val;
t                 763 modules/hal/src/mathfuncs.cpp         t = (val0 >> EXPTAB_SCALE) + 1023;
t                 764 modules/hal/src/mathfuncs.cpp         t = !(t & ~2047) ? t : t < 0 ? 0 : 2047;
t                 765 modules/hal/src/mathfuncs.cpp         buf[0].i = (int64)t << 52;
t                 767 modules/hal/src/mathfuncs.cpp         t = (val1 >> EXPTAB_SCALE) + 1023;
t                 768 modules/hal/src/mathfuncs.cpp         t = !(t & ~2047) ? t : t < 0 ? 0 : 2047;
t                 769 modules/hal/src/mathfuncs.cpp         buf[1].i = (int64)t << 52;
t                 771 modules/hal/src/mathfuncs.cpp         t = (val2 >> EXPTAB_SCALE) + 1023;
t                 772 modules/hal/src/mathfuncs.cpp         t = !(t & ~2047) ? t : t < 0 ? 0 : 2047;
t                 773 modules/hal/src/mathfuncs.cpp         buf[2].i = (int64)t << 52;
t                 775 modules/hal/src/mathfuncs.cpp         t = (val3 >> EXPTAB_SCALE) + 1023;
t                 776 modules/hal/src/mathfuncs.cpp         t = !(t & ~2047) ? t : t < 0 ? 0 : 2047;
t                 777 modules/hal/src/mathfuncs.cpp         buf[3].i = (int64)t << 52;
t                 795 modules/hal/src/mathfuncs.cpp         int val0, t;
t                 797 modules/hal/src/mathfuncs.cpp         t = (int)(x[i].i >> 52);
t                 798 modules/hal/src/mathfuncs.cpp         if( (t & 2047) > 1023 + 10 )
t                 799 modules/hal/src/mathfuncs.cpp             x0 = t < 0 ? -exp_max_val : exp_max_val;
t                 802 modules/hal/src/mathfuncs.cpp         t = (val0 >> EXPTAB_SCALE) + 1023;
t                 803 modules/hal/src/mathfuncs.cpp         t = !(t & ~2047) ? t : t < 0 ? 0 : 2047;
t                 805 modules/hal/src/mathfuncs.cpp         buf[0].i = (int64)t << 52;
t                 145 modules/hal/src/matrix.cpp             double t = L[i*astep + k];
t                 146 modules/hal/src/matrix.cpp             s -= t*t;
t                 211 modules/hal/src/stat.cpp         float t = a[j] - b[j];
t                 212 modules/hal/src/stat.cpp         d += t*t;
t                3641 modules/highgui/src/ppltasks_winrt.h         return[=](_Type t, _Unit_type* retVal) -> HRESULT { HRESULT hr = _Func(t); *retVal = _Unit_type(); return hr;  };
t                 408 modules/highgui/src/window_QT.cpp         CvBar* t = (CvBar*) layout->layout()->itemAt(i);
t                 410 modules/highgui/src/window_QT.cpp         if (t->type == type && t->name_bar == name_bar)
t                 411 modules/highgui/src/window_QT.cpp             return t;
t                 642 modules/highgui/src/window_QT.cpp     QPointer<CvTrackbar> t = icvFindTrackBarByName(name_bar, window_name);
t                 644 modules/highgui/src/window_QT.cpp     if (t)
t                 645 modules/highgui/src/window_QT.cpp         result = t->slider->value();
t                 653 modules/highgui/src/window_QT.cpp     QPointer<CvTrackbar> t = icvFindTrackBarByName(name_bar, window_name);
t                 655 modules/highgui/src/window_QT.cpp     if (t)
t                 656 modules/highgui/src/window_QT.cpp         t->slider->setValue(pos);
t                 664 modules/highgui/src/window_QT.cpp         QPointer<CvTrackbar> t = icvFindTrackBarByName(name_bar, window_name);
t                 665 modules/highgui/src/window_QT.cpp         if (t)
t                 667 modules/highgui/src/window_QT.cpp             t->slider->setMaximum(maxval);
t                1154 modules/highgui/src/window_QT.cpp     QPointer<CvTrackbar> t = icvFindTrackBarByName(bar_name.toLatin1().data(), window_name.toLatin1().data(), layout);
t                1156 modules/highgui/src/window_QT.cpp     if (t) //trackbar exists
t                1187 modules/highgui/src/window_QT.cpp     QPointer<CvTrackbar> t = icvFindTrackBarByName(bar_name.toLatin1().data(), window_name.toLatin1().data(), layout);
t                1189 modules/highgui/src/window_QT.cpp     if (t) //trackbar exists
t                1795 modules/highgui/src/window_QT.cpp     QPointer<CvButtonbar> t = new CvButtonbar(global_control_panel, name_bar);
t                1796 modules/highgui/src/window_QT.cpp     t->setAlignment(Qt::AlignHCenter);
t                1800 modules/highgui/src/window_QT.cpp     myLayout->insertLayout(myLayout->count(), t);
t                1802 modules/highgui/src/window_QT.cpp     return t;
t                1808 modules/highgui/src/window_QT.cpp     QPointer<CvTrackbar> t = new CvTrackbar(w, name, value, count, on_change);
t                1809 modules/highgui/src/window_QT.cpp     t->setAlignment(Qt::AlignHCenter);
t                1826 modules/highgui/src/window_QT.cpp     myLayout->insertLayout(myLayout->count(), t);
t                1832 modules/highgui/src/window_QT.cpp     QPointer<CvTrackbar> t = new CvTrackbar(w, name, value, count, on_change, userdata);
t                1833 modules/highgui/src/window_QT.cpp     t->setAlignment(Qt::AlignHCenter);
t                1850 modules/highgui/src/window_QT.cpp     myLayout->insertLayout(myLayout->count(), t);
t                2121 modules/highgui/src/window_QT.cpp             CvBar* t = (CvBar*) global_control_panel->myLayout->layout()->itemAt(i);
t                2123 modules/highgui/src/window_QT.cpp             if (t->type == type_CvTrackbar)
t                2125 modules/highgui/src/window_QT.cpp                 if (t->name_bar == settings.value("namebar").toString())
t                2127 modules/highgui/src/window_QT.cpp                     ((CvTrackbar*)t)->slider->setValue(settings.value("valuebar").toInt());
t                2130 modules/highgui/src/window_QT.cpp             if (t->type == type_CvButtonbar)
t                2134 modules/highgui/src/window_QT.cpp                 if ( subsize == ((CvButtonbar*)t)->layout()->count() )
t                2135 modules/highgui/src/window_QT.cpp                     icvLoadButtonbar((CvButtonbar*)t,&settings);
t                2154 modules/highgui/src/window_QT.cpp         CvBar* t = (CvBar*) global_control_panel->myLayout->layout()->itemAt(i);
t                2156 modules/highgui/src/window_QT.cpp         if (t->type == type_CvTrackbar)
t                2158 modules/highgui/src/window_QT.cpp             settings.setValue("namebar", QString(t->name_bar));
t                2159 modules/highgui/src/window_QT.cpp             settings.setValue("valuebar",((CvTrackbar*)t)->slider->value());
t                2161 modules/highgui/src/window_QT.cpp         if (t->type == type_CvButtonbar)
t                2164 modules/highgui/src/window_QT.cpp             icvSaveButtonbar((CvButtonbar*)t,&settings);
t                2251 modules/highgui/src/window_QT.cpp             CvTrackbar* t = (CvTrackbar*) myBarLayout->layout()->itemAt(i);
t                2253 modules/highgui/src/window_QT.cpp             if (t->name_bar == settings->value("name").toString())
t                2254 modules/highgui/src/window_QT.cpp                 t->slider->setValue(settings->value("value").toInt());
t                2271 modules/highgui/src/window_QT.cpp         CvTrackbar* t = (CvTrackbar*) myBarLayout->layout()->itemAt(i);
t                2273 modules/highgui/src/window_QT.cpp         settings->setValue("name", t->name_bar);
t                2274 modules/highgui/src/window_QT.cpp         settings->setValue("value", t->slider->value());
t                 349 modules/highgui/src/window_QT.h     void icvLoadButtonbar(CvButtonbar* t,QSettings *settings);
t                 350 modules/highgui/src/window_QT.h     void icvSaveButtonbar(CvButtonbar* t,QSettings *settings);
t                1056 modules/highgui/src/window_carbon.cpp             CvTrackbar *t;
t                1059 modules/highgui/src/window_carbon.cpp             for ( t = window->toolbar.first; t != 0; t = t->next )
t                1060 modules/highgui/src/window_carbon.cpp                 SizeControl(t->trackbar,bounds.right - bounds.left - INTERWIDGETSPACE*3 - LABELWIDTH , WIDGETHEIGHT);
t                 263 modules/imgcodecs/src/grfmt_bmp.cpp                         int t = 0;
t                 275 modules/imgcodecs/src/grfmt_bmp.cpp                                 WRITE_PIX( data, clr[t] );
t                 277 modules/imgcodecs/src/grfmt_bmp.cpp                                 *data = gray_clr[t];
t                 278 modules/imgcodecs/src/grfmt_bmp.cpp                             t ^= 1;
t                 500 modules/imgcodecs/src/grfmt_exr.cpp                 int t = cvRound(b);
t                 501 modules/imgcodecs/src/grfmt_exr.cpp                 ((unsigned *)data)[y * step + x * 3 + 0] = (unsigned)MAX(t, 0);
t                 502 modules/imgcodecs/src/grfmt_exr.cpp                 t = cvRound(Y);
t                 503 modules/imgcodecs/src/grfmt_exr.cpp                 ((unsigned *)data)[y * step + x * 3 + 1] = (unsigned)MAX(t, 0);
t                 504 modules/imgcodecs/src/grfmt_exr.cpp                 t = cvRound(r);
t                 505 modules/imgcodecs/src/grfmt_exr.cpp                 ((unsigned *)data)[y * step + x * 3 + 2] = (unsigned)MAX(t, 0);
t                 390 modules/imgcodecs/src/grfmt_pxm.cpp         int t = CV_MAKETYPE(img.depth(), channels);
t                 392 modules/imgcodecs/src/grfmt_pxm.cpp             ((t == CV_8UC1 ? 4 : t == CV_8UC3 ? 4*3+2 :
t                 393 modules/imgcodecs/src/grfmt_pxm.cpp             t == CV_16UC1 ? 6 : 6*3+2)*width+1)*height), 256));
t                  60 modules/imgcodecs/src/utils.cpp             int t = descale( rgb[swap_rb]*cB + rgb[1]*cG + rgb[swap_rb^2]*cR, SCALE );
t                  61 modules/imgcodecs/src/utils.cpp             gray[i] = (uchar)t;
t                  79 modules/imgcodecs/src/utils.cpp             int t = descale( rgb[swap_rb]*cB + rgb[1]*cG + rgb[swap_rb^2]*cR, SCALE );
t                  80 modules/imgcodecs/src/utils.cpp             gray[i] = (ushort)t;
t                  98 modules/imgcodecs/src/utils.cpp             int t = descale( rgba[swap_rb]*cB + rgba[1]*cG + rgba[swap_rb^2]*cR, SCALE );
t                  99 modules/imgcodecs/src/utils.cpp             gray[i] = (uchar)t;
t                 259 modules/imgcodecs/src/utils.cpp             int t = descale( ((((ushort*)bgr555)[i] << 3) & 0xf8)*cB +
t                 262 modules/imgcodecs/src/utils.cpp             gray[i] = (uchar)t;
t                 276 modules/imgcodecs/src/utils.cpp             int t = descale( ((((ushort*)bgr565)[i] << 3) & 0xf8)*cB +
t                 279 modules/imgcodecs/src/utils.cpp             gray[i] = (uchar)t;
t                 353 modules/imgcodecs/src/utils.cpp             int t = descale( y*cB + m*cG + c*cR, SCALE );
t                 354 modules/imgcodecs/src/utils.cpp             gray[i] = (uchar)t;
t                 118 modules/imgproc/src/color.cpp         _Tp t = 3*(f[i+1] - 2*f[i] + f[i-1]);
t                 120 modules/imgproc/src/color.cpp         tab[i*4] = l; tab[i*4+1] = (t - tab[(i-1)*4+1])*l;
t                 778 modules/imgproc/src/color.cpp                 unsigned t = ((const ushort*)src)[i];
t                 779 modules/imgproc/src/color.cpp                 dst[bidx] = (uchar)(t << 3);
t                 780 modules/imgproc/src/color.cpp                 dst[1] = (uchar)((t >> 3) & ~3);
t                 781 modules/imgproc/src/color.cpp                 dst[bidx ^ 2] = (uchar)((t >> 8) & ~7);
t                 819 modules/imgproc/src/color.cpp                 unsigned t = ((const ushort*)src)[i];
t                 820 modules/imgproc/src/color.cpp                 dst[bidx] = (uchar)(t << 3);
t                 821 modules/imgproc/src/color.cpp                 dst[1] = (uchar)((t >> 2) & ~7);
t                 822 modules/imgproc/src/color.cpp                 dst[bidx ^ 2] = (uchar)((t >> 7) & ~7);
t                 824 modules/imgproc/src/color.cpp                     dst[3] = t & 0x8000 ? 255 : 0;
t                1014 modules/imgproc/src/color.cpp                 int t = src[i];
t                1015 modules/imgproc/src/color.cpp                 ((ushort*)dst)[i] = (ushort)((t >> 3)|((t & ~3) << 3)|((t & ~7) << 8));
t                1050 modules/imgproc/src/color.cpp                 int t = src[i] >> 3;
t                1051 modules/imgproc/src/color.cpp                 ((ushort*)dst)[i] = (ushort)(t|(t << 5)|(t << 10));
t                1166 modules/imgproc/src/color.cpp                 int t = ((ushort*)src)[i];
t                1167 modules/imgproc/src/color.cpp                 dst[i] = (uchar)CV_DESCALE(((t << 3) & 0xf8)*B2Y +
t                1168 modules/imgproc/src/color.cpp                                            ((t >> 3) & 0xfc)*G2Y +
t                1169 modules/imgproc/src/color.cpp                                            ((t >> 8) & 0xf8)*R2Y, yuv_shift);
t                1230 modules/imgproc/src/color.cpp                 int t = ((ushort*)src)[i];
t                1231 modules/imgproc/src/color.cpp                 dst[i] = (uchar)CV_DESCALE(((t << 3) & 0xf8)*B2Y +
t                1232 modules/imgproc/src/color.cpp                                            ((t >> 2) & 0xf8)*G2Y +
t                1233 modules/imgproc/src/color.cpp                                            ((t >> 7) & 0xf8)*R2Y, yuv_shift);
t                 655 modules/imgproc/src/convhull.cpp             int t = *(int*)hull_reader.ptr;
t                 656 modules/imgproc/src/convhull.cpp             hull_next = CV_GET_SEQ_ELEM( CvPoint, ptseq, t );
t                  79 modules/imgproc/src/corner.cpp                 __m128 a, b, c, t;
t                  80 modules/imgproc/src/corner.cpp                 t = _mm_unpacklo_ps(t0, t1); // a0 a1 b0 b1
t                  84 modules/imgproc/src/corner.cpp                 a = _mm_movelh_ps(t, b);
t                  85 modules/imgproc/src/corner.cpp                 b = _mm_movehl_ps(b, t);
t                  88 modules/imgproc/src/corner.cpp                 t = _mm_sub_ps(a, c);
t                  89 modules/imgproc/src/corner.cpp                 t = _mm_add_ps(_mm_mul_ps(t, t), _mm_mul_ps(b,b));
t                  90 modules/imgproc/src/corner.cpp                 a = _mm_sub_ps(_mm_add_ps(a, c), _mm_sqrt_ps(t));
t                 149 modules/imgproc/src/corner.cpp                 __m128 a, b, c, t;
t                 150 modules/imgproc/src/corner.cpp                 t = _mm_unpacklo_ps(t0, t1); // a0 a1 b0 b1
t                 154 modules/imgproc/src/corner.cpp                 a = _mm_movelh_ps(t, b);
t                 155 modules/imgproc/src/corner.cpp                 b = _mm_movehl_ps(b, t);
t                 156 modules/imgproc/src/corner.cpp                 t = _mm_add_ps(a, c);
t                 158 modules/imgproc/src/corner.cpp                 t = _mm_mul_ps(_mm_mul_ps(k4, t), t);
t                 159 modules/imgproc/src/corner.cpp                 a = _mm_sub_ps(a, t);
t                 104 modules/imgproc/src/distransform.cpp                 int t = tmp[j-step] + HV_DIST;
t                 105 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 106 modules/imgproc/src/distransform.cpp                 t = tmp[j-step+1] + DIAG_DIST;
t                 107 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 108 modules/imgproc/src/distransform.cpp                 t = tmp[j-1] + HV_DIST;
t                 109 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 126 modules/imgproc/src/distransform.cpp                 int t = tmp[j+step+1] + DIAG_DIST;
t                 127 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 128 modules/imgproc/src/distransform.cpp                 t = tmp[j+step] + HV_DIST;
t                 129 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 130 modules/imgproc/src/distransform.cpp                 t = tmp[j+step-1] + DIAG_DIST;
t                 131 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 132 modules/imgproc/src/distransform.cpp                 t = tmp[j+1] + HV_DIST;
t                 133 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 178 modules/imgproc/src/distransform.cpp                 int t = tmp[j-step*2+1] + LONG_DIST;
t                 179 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 180 modules/imgproc/src/distransform.cpp                 t = tmp[j-step-2] + LONG_DIST;
t                 181 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 182 modules/imgproc/src/distransform.cpp                 t = tmp[j-step-1] + DIAG_DIST;
t                 183 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 184 modules/imgproc/src/distransform.cpp                 t = tmp[j-step] + HV_DIST;
t                 185 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 186 modules/imgproc/src/distransform.cpp                 t = tmp[j-step+1] + DIAG_DIST;
t                 187 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 188 modules/imgproc/src/distransform.cpp                 t = tmp[j-step+2] + LONG_DIST;
t                 189 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 190 modules/imgproc/src/distransform.cpp                 t = tmp[j-1] + HV_DIST;
t                 191 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 208 modules/imgproc/src/distransform.cpp                 int t = tmp[j+step*2+1] + LONG_DIST;
t                 209 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 210 modules/imgproc/src/distransform.cpp                 t = tmp[j+step*2-1] + LONG_DIST;
t                 211 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 212 modules/imgproc/src/distransform.cpp                 t = tmp[j+step+2] + LONG_DIST;
t                 213 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 214 modules/imgproc/src/distransform.cpp                 t = tmp[j+step+1] + DIAG_DIST;
t                 215 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 216 modules/imgproc/src/distransform.cpp                 t = tmp[j+step] + HV_DIST;
t                 217 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 218 modules/imgproc/src/distransform.cpp                 t = tmp[j+step-1] + DIAG_DIST;
t                 219 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 220 modules/imgproc/src/distransform.cpp                 t = tmp[j+step-2] + LONG_DIST;
t                 221 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 222 modules/imgproc/src/distransform.cpp                 t = tmp[j+1] + HV_DIST;
t                 223 modules/imgproc/src/distransform.cpp                 if( t0 > t ) t0 = t;
t                 274 modules/imgproc/src/distransform.cpp                 int t0 = INIT_DIST0, t;
t                 277 modules/imgproc/src/distransform.cpp                 t = tmp[j-step*2-1] + LONG_DIST;
t                 278 modules/imgproc/src/distransform.cpp                 if( t0 > t )
t                 280 modules/imgproc/src/distransform.cpp                     t0 = t;
t                 283 modules/imgproc/src/distransform.cpp                 t = tmp[j-step*2+1] + LONG_DIST;
t                 284 modules/imgproc/src/distransform.cpp                 if( t0 > t )
t                 286 modules/imgproc/src/distransform.cpp                     t0 = t;
t                 289 modules/imgproc/src/distransform.cpp                 t = tmp[j-step-2] + LONG_DIST;
t                 290 modules/imgproc/src/distransform.cpp                 if( t0 > t )
t                 292 modules/imgproc/src/distransform.cpp                     t0 = t;
t                 295 modules/imgproc/src/distransform.cpp                 t = tmp[j-step-1] + DIAG_DIST;
t                 296 modules/imgproc/src/distransform.cpp                 if( t0 > t )
t                 298 modules/imgproc/src/distransform.cpp                     t0 = t;
t                 301 modules/imgproc/src/distransform.cpp                 t = tmp[j-step] + HV_DIST;
t                 302 modules/imgproc/src/distransform.cpp                 if( t0 > t )
t                 304 modules/imgproc/src/distransform.cpp                     t0 = t;
t                 307 modules/imgproc/src/distransform.cpp                 t = tmp[j-step+1] + DIAG_DIST;
t                 308 modules/imgproc/src/distransform.cpp                 if( t0 > t )
t                 310 modules/imgproc/src/distransform.cpp                     t0 = t;
t                 313 modules/imgproc/src/distransform.cpp                 t = tmp[j-step+2] + LONG_DIST;
t                 314 modules/imgproc/src/distransform.cpp                 if( t0 > t )
t                 316 modules/imgproc/src/distransform.cpp                     t0 = t;
t                 319 modules/imgproc/src/distransform.cpp                 t = tmp[j-1] + HV_DIST;
t                 320 modules/imgproc/src/distransform.cpp                 if( t0 > t )
t                 322 modules/imgproc/src/distransform.cpp                     t0 = t;
t                 345 modules/imgproc/src/distransform.cpp                 int t = tmp[j+step*2+1] + LONG_DIST;
t                 346 modules/imgproc/src/distransform.cpp                 if( t0 > t )
t                 348 modules/imgproc/src/distransform.cpp                     t0 = t;
t                 351 modules/imgproc/src/distransform.cpp                 t = tmp[j+step*2-1] + LONG_DIST;
t                 352 modules/imgproc/src/distransform.cpp                 if( t0 > t )
t                 354 modules/imgproc/src/distransform.cpp                     t0 = t;
t                 357 modules/imgproc/src/distransform.cpp                 t = tmp[j+step+2] + LONG_DIST;
t                 358 modules/imgproc/src/distransform.cpp                 if( t0 > t )
t                 360 modules/imgproc/src/distransform.cpp                     t0 = t;
t                 363 modules/imgproc/src/distransform.cpp                 t = tmp[j+step+1] + DIAG_DIST;
t                 364 modules/imgproc/src/distransform.cpp                 if( t0 > t )
t                 366 modules/imgproc/src/distransform.cpp                     t0 = t;
t                 369 modules/imgproc/src/distransform.cpp                 t = tmp[j+step] + HV_DIST;
t                 370 modules/imgproc/src/distransform.cpp                 if( t0 > t )
t                 372 modules/imgproc/src/distransform.cpp                     t0 = t;
t                 375 modules/imgproc/src/distransform.cpp                 t = tmp[j+step-1] + DIAG_DIST;
t                 376 modules/imgproc/src/distransform.cpp                 if( t0 > t )
t                 378 modules/imgproc/src/distransform.cpp                     t0 = t;
t                 381 modules/imgproc/src/distransform.cpp                 t = tmp[j+step-2] + LONG_DIST;
t                 382 modules/imgproc/src/distransform.cpp                 if( t0 > t )
t                 384 modules/imgproc/src/distransform.cpp                     t0 = t;
t                 387 modules/imgproc/src/distransform.cpp                 t = tmp[j+1] + HV_DIST;
t                 388 modules/imgproc/src/distransform.cpp                 if( t0 > t )
t                 390 modules/imgproc/src/distransform.cpp                     t0 = t;
t                1350 modules/imgproc/src/drawing.cpp                         int t = x1;
t                1353 modules/imgproc/src/drawing.cpp                         x2 = t;
t                1102 modules/imgproc/src/emd.cpp         double t = x[i] - y[i];
t                1104 modules/imgproc/src/emd.cpp         s += fabs( t );
t                1117 modules/imgproc/src/emd.cpp         double t = x[i] - y[i];
t                1119 modules/imgproc/src/emd.cpp         s += t * t;
t                1132 modules/imgproc/src/emd.cpp         double t = fabs( x[i] - y[i] );
t                1134 modules/imgproc/src/emd.cpp         if( s < t )
t                1135 modules/imgproc/src/emd.cpp             s = t;
t                2643 modules/imgproc/src/filter.cpp                     int16x4_t t;
t                2644 modules/imgproc/src/filter.cpp                     t = vqmovn_s32(y3);
t                2646 modules/imgproc/src/filter.cpp                     vst1_s16((int16_t *)(dst + i), t);
t                2664 modules/imgproc/src/filter.cpp                     int16x4_t t;
t                2665 modules/imgproc/src/filter.cpp                     t = vqmovn_s32(y3);
t                2667 modules/imgproc/src/filter.cpp                     vst1_s16((int16_t *)(dst + i), t);
t                2685 modules/imgproc/src/filter.cpp                     int16x4_t t;
t                2686 modules/imgproc/src/filter.cpp                     t = vqmovn_s32(y0);
t                2688 modules/imgproc/src/filter.cpp                     vst1_s16((int16_t *)(dst + i), t);
t                2737 modules/imgproc/src/filter.cpp                     int16x4_t t;
t                2738 modules/imgproc/src/filter.cpp                     t = vqmovn_s32(y1);
t                2740 modules/imgproc/src/filter.cpp                     vst1_s16((int16_t *)(dst + i), t);
t                  67 modules/imgproc/src/gcgraph.hpp         uchar t;
t                 174 modules/imgproc/src/gcgraph.hpp             v->t = v->weight < 0;
t                 197 modules/imgproc/src/gcgraph.hpp                 vt = v->t;
t                 205 modules/imgproc/src/gcgraph.hpp                         u->t = vt;
t                 217 modules/imgproc/src/gcgraph.hpp                     if( u->t != vt )
t                 298 modules/imgproc/src/gcgraph.hpp             vt = v2->t;
t                 305 modules/imgproc/src/gcgraph.hpp                 if( u->t != vt || u->parent == 0 )
t                 360 modules/imgproc/src/gcgraph.hpp                 if( u->t != vt || !ej )
t                 382 modules/imgproc/src/gcgraph.hpp     return vtcs[i].t == 0;
t                 332 modules/imgproc/src/geometry.cpp     double  s, t;       // The two parameters of the parametric eqns.
t                 355 modules/imgproc/src/geometry.cpp     t = num / denom;
t                 358 modules/imgproc/src/geometry.cpp              (0.0 < t) && (t < 1.0) )
t                 361 modules/imgproc/src/geometry.cpp              (0.0 > t) || (t > 1.0) )
t                 192 modules/imgproc/src/histogram.cpp             double t = histSize[i]/(high - low);
t                 193 modules/imgproc/src/histogram.cpp             uniranges[i*2] = t;
t                 194 modules/imgproc/src/histogram.cpp             uniranges[i*2+1] = -t*low;
t                2810 modules/imgproc/src/histogram.cpp                     int t = imin / size[i];
t                2811 modules/imgproc/src/histogram.cpp                     idx_min[i] = imin - t*size[i];
t                2812 modules/imgproc/src/histogram.cpp                     imin = t;
t                2817 modules/imgproc/src/histogram.cpp                     int t = imax / size[i];
t                2818 modules/imgproc/src/histogram.cpp                     idx_max[i] = imax - t*size[i];
t                2819 modules/imgproc/src/histogram.cpp                     imax = t;
t                2927 modules/imgproc/src/histogram.cpp         CvSparseMat* t;
t                2928 modules/imgproc/src/histogram.cpp         CV_SWAP( mat1, mat2, t );
t                 210 modules/imgproc/src/hough.cpp     float r, t;                 /* Current rho and theta */
t                 288 modules/imgproc/src/hough.cpp                 t = (float) fabs( cvFastArctan( yc, xc ) * d2r );
t                 291 modules/imgproc/src/hough.cpp                 ti0 = cvFloor( (t + CV_PI*0.5) * itheta );
t                 299 modules/imgproc/src/hough.cpp                 for( ti1 = 1, phi = theta_it - (float)(CV_PI*0.5), phi1 = (theta_it + t) * itheta;
t                 356 modules/imgproc/src/hough.cpp                     t = (float) fabs( cvFastArctan( yc, xc ) * d2r );
t                 358 modules/imgproc/src/hough.cpp                     ti0 = cvFloor( (t + CV_PI * 0.5) * istheta );
t                  53 modules/imgproc/src/linefit.cpp     float t;
t                  91 modules/imgproc/src/linefit.cpp     t = (float) atan2( 2 * dxy, dx2 - dy2 ) / 2;
t                  92 modules/imgproc/src/linefit.cpp     line[0] = (float) cos( t );
t                  93 modules/imgproc/src/linefit.cpp     line[1] = (float) sin( t );
t                 256 modules/imgproc/src/linefit.cpp         double t = fabs( (double) d[i] );
t                 257 modules/imgproc/src/linefit.cpp         w[i] = (float)(1. / MAX(t, eps));
t                 392 modules/imgproc/src/linefit.cpp                 double t = _line[0] * _lineprev[0] + _line[1] * _lineprev[1];
t                 393 modules/imgproc/src/linefit.cpp                 t = MAX(t,-1.);
t                 394 modules/imgproc/src/linefit.cpp                 t = MIN(t,1.);
t                 395 modules/imgproc/src/linefit.cpp                 if( fabs(acos(t)) < adelta )
t                 527 modules/imgproc/src/linefit.cpp                 double t = _line[0] * _lineprev[0] + _line[1] * _lineprev[1] + _line[2] * _lineprev[2];
t                 528 modules/imgproc/src/linefit.cpp                 t = MAX(t,-1.);
t                 529 modules/imgproc/src/linefit.cpp                 t = MIN(t,1.);
t                 530 modules/imgproc/src/linefit.cpp                 if( fabs(acos(t)) < adelta )
t                 364 modules/imgproc/src/moments.cpp                 __m128i t = _mm_add_epi32(_mm_mullo_epi32(v_2ix0, v_x1_0), _mm_mullo_epi32(v_2ix1, v_x1_1));
t                 365 modules/imgproc/src/moments.cpp                 v_x3 = _mm_add_epi64(v_x3, _mm_add_epi64(_mm_unpacklo_epi32(t, v_zero), _mm_unpackhi_epi32(t, v_zero)));
t                 891 modules/imgproc/src/opencl/cvtcolor.cl                 ushort t = *((__global const ushort*)(src + src_index));
t                 894 modules/imgproc/src/opencl/cvtcolor.cl                 dst[dst_index + bidx] = (uchar)(t << 3);
t                 895 modules/imgproc/src/opencl/cvtcolor.cl                 dst[dst_index + 1] = (uchar)((t >> 3) & ~3);
t                 896 modules/imgproc/src/opencl/cvtcolor.cl                 dst[dst_index + (bidx^2)] = (uchar)((t >> 8) & ~7);
t                 898 modules/imgproc/src/opencl/cvtcolor.cl                 dst[dst_index + bidx] = (uchar)(t << 3);
t                 899 modules/imgproc/src/opencl/cvtcolor.cl                 dst[dst_index + 1] = (uchar)((t >> 2) & ~7);
t                 900 modules/imgproc/src/opencl/cvtcolor.cl                 dst[dst_index + (bidx^2)] = (uchar)((t >> 7) & ~7);
t                 907 modules/imgproc/src/opencl/cvtcolor.cl                 dst[dst_index + 3] = t & 0x8000 ? 255 : 0;
t                 974 modules/imgproc/src/opencl/cvtcolor.cl                 int t = *((__global const ushort*)(src + src_index));
t                 977 modules/imgproc/src/opencl/cvtcolor.cl                 dst[dst_index] = (uchar)CV_DESCALE(mad24((t << 3) & 0xf8, B2Y, mad24((t >> 3) & 0xfc, G2Y, ((t >> 8) & 0xf8) * R2Y)), yuv_shift);
t                 979 modules/imgproc/src/opencl/cvtcolor.cl                 dst[dst_index] = (uchar)CV_DESCALE(mad24((t << 3) & 0xf8, B2Y, mad24((t >> 2) & 0xf8, G2Y, ((t >> 7) & 0xf8) * R2Y)), yuv_shift);
t                1006 modules/imgproc/src/opencl/cvtcolor.cl                 int t = src[src_index];
t                1009 modules/imgproc/src/opencl/cvtcolor.cl                 *((__global ushort*)(dst + dst_index)) = (ushort)((t >> 3) | ((t & ~3) << 3) | ((t & ~7) << 8));
t                1011 modules/imgproc/src/opencl/cvtcolor.cl                 t >>= 3;
t                1012 modules/imgproc/src/opencl/cvtcolor.cl                 *((__global ushort*)(dst + dst_index)) = (ushort)(t|(t << 5)|(t << 10));
t                  77 modules/imgproc/src/opencl/filterSepRow.cl         #define EXTRAPOLATE(t, minT, maxT) \
t                  79 modules/imgproc/src/opencl/filterSepRow.cl             t = max(min(t, (maxT) - 1), (minT)); \
t                  84 modules/imgproc/src/opencl/filterSepRow.cl             if (t < (minT)) \
t                  85 modules/imgproc/src/opencl/filterSepRow.cl                 t -= ((t - (maxT) + 1) / (maxT)) * (maxT); \
t                  86 modules/imgproc/src/opencl/filterSepRow.cl             if (t >= (maxT)) \
t                  87 modules/imgproc/src/opencl/filterSepRow.cl                 t %= (maxT); \
t                  90 modules/imgproc/src/opencl/filterSepRow.cl         #define EXTRAPOLATE_(t, minT, maxT, delta) \
t                  93 modules/imgproc/src/opencl/filterSepRow.cl                 t = (minT); \
t                  97 modules/imgproc/src/opencl/filterSepRow.cl                     if (t < (minT)) \
t                  98 modules/imgproc/src/opencl/filterSepRow.cl                         t = (minT) - (t - (minT)) - 1 + delta; \
t                 100 modules/imgproc/src/opencl/filterSepRow.cl                         t = (maxT) - 1 - (t - (maxT)) - delta; \
t                 102 modules/imgproc/src/opencl/filterSepRow.cl                 while (t >= (maxT) || t < (minT)); \
t                 106 modules/imgproc/src/opencl/filterSepRow.cl             #define EXTRAPOLATE(t, minT, maxT) EXTRAPOLATE_(t, minT, maxT, 0)
t                 108 modules/imgproc/src/opencl/filterSepRow.cl             #define EXTRAPOLATE(t, minT, maxT) EXTRAPOLATE_(t, minT, maxT, 1)
t                 117 modules/imgproc/src/opencl/filterSepRow.cl         #define EXTRAPOLATE(t, minT, maxT) \
t                 119 modules/imgproc/src/opencl/filterSepRow.cl             int _delta = t - (minT); \
t                 122 modules/imgproc/src/opencl/filterSepRow.cl             t = _delta + (minT); \
t                 558 modules/imgproc/src/phasecorr.cpp     Point2d t;
t                 559 modules/imgproc/src/phasecorr.cpp     t = weightedCentroid(C, peakLoc, Size(5, 5), response);
t                 568 modules/imgproc/src/phasecorr.cpp     return (center - t);
t                  69 modules/imgproc/src/precomp.hpp #define CV_FAST_CAST_8U(t)  (assert(-256 <= (t) && (t) <= 512), icvSaturate8u_cv[(t)+256])
t                 257 modules/imgproc/src/samplers.cpp                 float t = a12*src[j+1] + a22*src[j+1+src_step];
t                 258 modules/imgproc/src/samplers.cpp                 dst[j] = prev + t;
t                 259 modules/imgproc/src/samplers.cpp                 prev = (float)(t*s);
t                 196 modules/imgproc/src/segmentation.cpp                 int idx = 256, t;
t                 201 modules/imgproc/src/segmentation.cpp                     c_diff( ptr, ptr + 3, t );
t                 202 modules/imgproc/src/segmentation.cpp                     idx = ws_min( idx, t );
t                 206 modules/imgproc/src/segmentation.cpp                     c_diff( ptr, ptr - istep, t );
t                 207 modules/imgproc/src/segmentation.cpp                     idx = ws_min( idx, t );
t                 211 modules/imgproc/src/segmentation.cpp                     c_diff( ptr, ptr + istep, t );
t                 212 modules/imgproc/src/segmentation.cpp                     idx = ws_min( idx, t );
t                 240 modules/imgproc/src/segmentation.cpp         int lab = 0, t;
t                 265 modules/imgproc/src/segmentation.cpp         t = m[-1]; // Left
t                 266 modules/imgproc/src/segmentation.cpp         if( t > 0 ) lab = t;
t                 267 modules/imgproc/src/segmentation.cpp         t = m[1]; // Right
t                 268 modules/imgproc/src/segmentation.cpp         if( t > 0 )
t                 270 modules/imgproc/src/segmentation.cpp             if( lab == 0 ) lab = t;
t                 271 modules/imgproc/src/segmentation.cpp             else if( t != lab ) lab = WSHED;
t                 273 modules/imgproc/src/segmentation.cpp         t = m[-mstep]; // Top
t                 274 modules/imgproc/src/segmentation.cpp         if( t > 0 )
t                 276 modules/imgproc/src/segmentation.cpp             if( lab == 0 ) lab = t;
t                 277 modules/imgproc/src/segmentation.cpp             else if( t != lab ) lab = WSHED;
t                 279 modules/imgproc/src/segmentation.cpp         t = m[mstep]; // Bottom
t                 280 modules/imgproc/src/segmentation.cpp         if( t > 0 )
t                 282 modules/imgproc/src/segmentation.cpp             if( lab == 0 ) lab = t;
t                 283 modules/imgproc/src/segmentation.cpp             else if( t != lab ) lab = WSHED;
t                 296 modules/imgproc/src/segmentation.cpp             c_diff( ptr, ptr - 3, t );
t                 297 modules/imgproc/src/segmentation.cpp             ws_push( t, mofs - 1, iofs - 3 );
t                 298 modules/imgproc/src/segmentation.cpp             active_queue = ws_min( active_queue, t );
t                 303 modules/imgproc/src/segmentation.cpp             c_diff( ptr, ptr + 3, t );
t                 304 modules/imgproc/src/segmentation.cpp             ws_push( t, mofs + 1, iofs + 3 );
t                 305 modules/imgproc/src/segmentation.cpp             active_queue = ws_min( active_queue, t );
t                 310 modules/imgproc/src/segmentation.cpp             c_diff( ptr, ptr - istep, t );
t                 311 modules/imgproc/src/segmentation.cpp             ws_push( t, mofs - mstep, iofs - istep );
t                 312 modules/imgproc/src/segmentation.cpp             active_queue = ws_min( active_queue, t );
t                 317 modules/imgproc/src/segmentation.cpp             c_diff( ptr, ptr + istep, t );
t                 318 modules/imgproc/src/segmentation.cpp             ws_push( t, mofs + mstep, iofs + istep );
t                 319 modules/imgproc/src/segmentation.cpp             active_queue = ws_min( active_queue, t );
t                  71 modules/imgproc/src/shapedescr.cpp     double t = 0;
t                  73 modules/imgproc/src/shapedescr.cpp     if( intersectLines( x1, dx1, y1, dy1, x2, dx2, y2, dy2, &t ) >= 0 )
t                  75 modules/imgproc/src/shapedescr.cpp         center->x = (float) (x2 + dx2 * t);
t                  76 modules/imgproc/src/shapedescr.cpp         center->y = (float) (y2 + dy2 * t);
t                 283 modules/imgproc/src/shapedescr.cpp             float t = dx*dx + dy*dy;
t                 284 modules/imgproc/src/shapedescr.cpp             radius = MAX(radius, t);
t                 383 modules/imgproc/src/shapedescr.cpp     double gfp[5], rp[5], t;
t                 450 modules/imgproc/src/shapedescr.cpp         t = gfp[2]/sin(-2.0 * rp[4]);
t                 452 modules/imgproc/src/shapedescr.cpp         t = gfp[1] - gfp[0];
t                 453 modules/imgproc/src/shapedescr.cpp     rp[2] = fabs(gfp[0] + gfp[1] - t);
t                 456 modules/imgproc/src/shapedescr.cpp     rp[3] = fabs(gfp[0] + gfp[1] + t);
t                 763 modules/imgproc/src/shapedescr.cpp     double xi, yi, xi_1, yi_1, x0, y0, dxy, sk, sk1, t;
t                 849 modules/imgproc/src/shapedescr.cpp                         t = ((yi_1 - pt_s.y) * du + dv * (pt_s.x - xi_1)) /
t                 852 modules/imgproc/src/shapedescr.cpp                         t = (xi_1 - pt_s.x) / dx;
t                 853 modules/imgproc/src/shapedescr.cpp                     if( t > eps && t < 1 - eps )
t                 855 modules/imgproc/src/shapedescr.cpp                         x_s = pt_s.x + t * dx;
t                 856 modules/imgproc/src/shapedescr.cpp                         y_s = pt_s.y + t * dy;
t                1562 modules/imgproc/src/smooth.cpp         double t = fixed_kernel ? (double)fixed_kernel[i] : std::exp(scale2X*x*x);
t                1565 modules/imgproc/src/smooth.cpp             cf[i] = (float)t;
t                1570 modules/imgproc/src/smooth.cpp             cd[i] = t;
t                1899 modules/imgproc/src/smooth.cpp                         int t = 2*r*r + 2*r, b, sum = 0;
t                1908 modules/imgproc/src/smooth.cpp                             if ( sum > t )
t                1945 modules/imgproc/src/smooth.cpp                             if ( sum > t )
t                1962 modules/imgproc/src/smooth.cpp                         int t = 2*r*r + 2*r, b, sum = 0;
t                1971 modules/imgproc/src/smooth.cpp                             if ( sum > t )
t                2008 modules/imgproc/src/smooth.cpp                             if ( sum > t )
t                2097 modules/imgproc/src/smooth.cpp                     int t = s + zone0[c][k];
t                2098 modules/imgproc/src/smooth.cpp                     if( t > n2 ) break;
t                2099 modules/imgproc/src/smooth.cpp                     s = t;
t                2178 modules/imgproc/src/smooth.cpp         int t = CV_FAST_CAST_8U(a - b);
t                2179 modules/imgproc/src/smooth.cpp         b += t; a -= t;
t                2192 modules/imgproc/src/smooth.cpp         arg_type t = a;
t                2194 modules/imgproc/src/smooth.cpp         b = std::max(b, t);
t                2207 modules/imgproc/src/smooth.cpp         arg_type t = a;
t                2209 modules/imgproc/src/smooth.cpp         b = std::max(b, t);
t                2222 modules/imgproc/src/smooth.cpp         arg_type t = a;
t                2224 modules/imgproc/src/smooth.cpp         b = std::max(b, t);
t                2239 modules/imgproc/src/smooth.cpp         arg_type t = a;
t                2241 modules/imgproc/src/smooth.cpp         b = _mm_max_epu8(b, t);
t                2255 modules/imgproc/src/smooth.cpp         arg_type t = _mm_subs_epu16(a, b);
t                2256 modules/imgproc/src/smooth.cpp         a = _mm_subs_epu16(a, t);
t                2257 modules/imgproc/src/smooth.cpp         b = _mm_adds_epu16(b, t);
t                2271 modules/imgproc/src/smooth.cpp         arg_type t = a;
t                2273 modules/imgproc/src/smooth.cpp         b = _mm_max_epi16(b, t);
t                2287 modules/imgproc/src/smooth.cpp         arg_type t = a;
t                2289 modules/imgproc/src/smooth.cpp         b = _mm_max_ps(b, t);
t                2304 modules/imgproc/src/smooth.cpp         arg_type t = a;
t                2306 modules/imgproc/src/smooth.cpp         b = vmaxq_u8(b, t);
t                2320 modules/imgproc/src/smooth.cpp         arg_type t = a;
t                2322 modules/imgproc/src/smooth.cpp         b = vmaxq_u16(b, t);
t                2336 modules/imgproc/src/smooth.cpp         arg_type t = a;
t                2338 modules/imgproc/src/smooth.cpp         b = vmaxq_s16(b, t);
t                2352 modules/imgproc/src/smooth.cpp         arg_type t = a;
t                2354 modules/imgproc/src/smooth.cpp         b = vmaxq_f32(b, t);
t                 668 modules/imgproc/src/subdivision2d.cpp         Point2f t;
t                 672 modules/imgproc/src/subdivision2d.cpp             CV_Assert( edgeDst(edge, &t) > 0 );
t                 673 modules/imgproc/src/subdivision2d.cpp             if( isRightOf2( t, start, diff ) >= 0 )
t                 681 modules/imgproc/src/subdivision2d.cpp             CV_Assert( edgeOrg( edge, &t ) > 0 );
t                 683 modules/imgproc/src/subdivision2d.cpp             if( isRightOf2( t, start, diff ) < 0 )
t                 691 modules/imgproc/src/subdivision2d.cpp         edgeOrg(edge, &t);
t                 692 modules/imgproc/src/subdivision2d.cpp         tempDiff -= t;
t                 694 modules/imgproc/src/subdivision2d.cpp         if( isRightOf2( pt, t, tempDiff ) >= 0 )
t                 772 modules/imgproc/src/subdivision2d.cpp         int edge = rotateEdge(vtx[k].firstEdge, 1), t = edge;
t                 778 modules/imgproc/src/subdivision2d.cpp             buf.push_back(vtx[edgeOrg(t)].pt);
t                 779 modules/imgproc/src/subdivision2d.cpp             t = getEdge( t, NEXT_AROUND_LEFT );
t                 781 modules/imgproc/src/subdivision2d.cpp         while( t != edge );
t                 212 modules/imgproc/src/sumpixels.cpp                     ST t = sum[x - sumstep] + s;
t                 214 modules/imgproc/src/sumpixels.cpp                     sum[x] = t;
t                1039 modules/imgproc/src/templmatch.cpp             double num = rrow[j], t;
t                1046 modules/imgproc/src/templmatch.cpp                     t = p0[idx+k] - p1[idx+k] - p2[idx+k] + p3[idx+k];
t                1047 modules/imgproc/src/templmatch.cpp                     wndMean2 += t*t;
t                1048 modules/imgproc/src/templmatch.cpp                     num -= t*templMean[k];
t                1058 modules/imgproc/src/templmatch.cpp                     t = q0[idx2+k] - q1[idx2+k] - q2[idx2+k] + q3[idx2+k];
t                1059 modules/imgproc/src/templmatch.cpp                     wndSum2 += t;
t                1071 modules/imgproc/src/templmatch.cpp                 t = std::sqrt(MAX(wndSum2 - wndMean2,0))*templNorm;
t                1072 modules/imgproc/src/templmatch.cpp                 if( fabs(num) < t )
t                1073 modules/imgproc/src/templmatch.cpp                     num /= t;
t                1074 modules/imgproc/src/templmatch.cpp                 else if( fabs(num) < t*1.125 )
t                 115 modules/imgproc/src/undistort.cpp         distCoeffs = distCoeffs.t();
t                 240 modules/imgproc/test/test_color.cpp                     int t = cvRound( dst_buf[j] );
t                 241 modules/imgproc/test/test_color.cpp                     dst_row[j] = saturate_cast<uchar>(t);
t                 261 modules/imgproc/test/test_color.cpp                     int t = cvRound( dst_buf[j] );
t                 262 modules/imgproc/test/test_color.cpp                     dst_row[j] = saturate_cast<ushort>(t);
t                 700 modules/imgproc/test/test_color.cpp             float t = v*(1 - s*(1 - f));
t                 703 modules/imgproc/test/test_color.cpp                 r = v, g = t, b = p;
t                 707 modules/imgproc/test/test_color.cpp                 r = p, g = v, b = t;
t                 711 modules/imgproc/test/test_color.cpp                 r = t, g = p, b = v;
t                2121 modules/imgproc/test/test_color.cpp         for (int t = 0; t <= 1; ++t)
t                2123 modules/imgproc/test/test_color.cpp             if (t == 1)
t                2131 modules/imgproc/test/test_color.cpp             if (t == 0)
t                 117 modules/imgproc/test/test_contours.cpp     int t;
t                 133 modules/imgproc/test/test_contours.cpp         CV_SWAP( min_blob_size, max_blob_size, t );
t                 141 modules/imgproc/test/test_contours.cpp         CV_SWAP( min_log_img_size, max_log_img_size, t );
t                 196 modules/imgproc/test/test_contours.cpp             uchar* t = (uchar*)(img->imageData + img->widthStep*i + j);
t                 197 modules/imgproc/test/test_contours.cpp             if( *t == 1 && (t[-step] == 0 || t[-1] == 0 || t[1] == 0 || t[step] == 0))
t                 198 modules/imgproc/test/test_contours.cpp                 *t = (uchar)val;
t                 444 modules/imgproc/test/test_contours.cpp         int t  = *x;
t                 446 modules/imgproc/test/test_contours.cpp         *y = t;
t                 452 modules/imgproc/test/test_contours.cpp     int rx, ry, s, t=d;
t                 456 modules/imgproc/test/test_contours.cpp         rx = 1 & (t/2);
t                 457 modules/imgproc/test/test_contours.cpp         ry = 1 & (t ^ rx);
t                 461 modules/imgproc/test/test_contours.cpp         t /= 4;
t                 265 modules/imgproc/test/test_convhull.cpp         int t;
t                 266 modules/imgproc/test/test_convhull.cpp         CV_SWAP( min_log_size, max_log_size, t );
t                 373 modules/imgproc/test/test_convhull.cpp             double t;
t                 374 modules/imgproc/test/test_convhull.cpp             CV_SWAP( low.val[i], high.val[i], t );
t                 619 modules/imgproc/test/test_convhull.cpp             double t = (double)dx0*dy1 - (double)dx1*dy0;
t                 620 modules/imgproc/test/test_convhull.cpp             if( (t < 0) ^ (orientation != CV_COUNTER_CLOCKWISE) )
t                1175 modules/imgproc/test/test_convhull.cpp         float t;
t                1176 modules/imgproc/test/test_convhull.cpp         CV_SWAP( box0.size.width, box0.size.height, t );
t                1386 modules/imgproc/test/test_convhull.cpp         int t;
t                1387 modules/imgproc/test/test_convhull.cpp         CV_SWAP( width, height, t );
t                1491 modules/imgproc/test/test_convhull.cpp         float p[4], t;
t                1504 modules/imgproc/test/test_convhull.cpp         t = (float)((cvtest::randReal(rng)-0.5)*low_high_range*2);
t                1508 modules/imgproc/test/test_convhull.cpp             p[k] = (float)((cvtest::randReal(rng)-0.5)*max_noise*2 + t*line0[k] + line0[k+n]);
t                1555 modules/imgproc/test/test_convhull.cpp     double vec_diff = 0, t;
t                1599 modules/imgproc/test/test_convhull.cpp     t = (line[max_k+dims] - line0[max_k+dims])/line0[max_k];
t                1602 modules/imgproc/test/test_convhull.cpp         double p = line0[k+dims] + t*line0[k] - line[k+dims];
t                1606 modules/imgproc/test/test_convhull.cpp     if( sqrt(vec_diff) > 1*MAX(fabs(t),1) )
t                1672 modules/imgproc/test/test_convhull.cpp         double t = cvtest::randReal(rng)*max_r_scale + (1 - max_r_scale);
t                1673 modules/imgproc/test/test_convhull.cpp         double ta = axes.height*t;
t                1674 modules/imgproc/test/test_convhull.cpp         double tb = axes.width*t;
t                1796 modules/imgproc/test/test_convhull.cpp         double t = fabs((&moments0.m00)[i]);
t                1797 modules/imgproc/test/test_convhull.cpp         max_v0 = MAX(max_v0, t);
t                 242 modules/imgproc/test/test_distancetransform.cpp                     float t = tmp[j+ofs[k]] + delta[k];
t                 243 modules/imgproc/test/test_distancetransform.cpp                     if( min_dist > t )
t                 244 modules/imgproc/test/test_distancetransform.cpp                         min_dist = t;
t                 263 modules/imgproc/test/test_distancetransform.cpp                     float t = tmp[j-ofs[k]] + delta[k];
t                 264 modules/imgproc/test/test_distancetransform.cpp                     if( min_dist > t )
t                 265 modules/imgproc/test/test_distancetransform.cpp                         min_dist = t;
t                 510 modules/imgproc/test/test_filter.cpp         int t;
t                 511 modules/imgproc/test/test_filter.cpp         CV_SWAP( dx, dy, t );
t                 936 modules/imgproc/test/test_filter.cpp                     median_pair t;
t                 937 modules/imgproc/test/test_filter.cpp                     CV_SWAP( buf0[j], buf0[j+1], t );
t                 955 modules/imgproc/test/test_filter.cpp                     int t;
t                 958 modules/imgproc/test/test_filter.cpp                     CV_SWAP( col_buf[l], col_buf[l+1], t );
t                1042 modules/imgproc/test/test_filter.cpp     kernel = (kernel1d.t()*kernel1d)*((downsample ? 1 : 4)/256.);
t                1696 modules/imgproc/test/test_filter.cpp             double t = x > 0 ? data[x-1] : 0, ts = t;
t                1697 modules/imgproc/test/test_filter.cpp             s += t;
t                1698 modules/imgproc/test/test_filter.cpp             sq += t*t;
t                 497 modules/imgproc/test/test_floodfill.cpp         double t = area ? 1./area : 0;
t                 498 modules/imgproc/test/test_floodfill.cpp         s0 *= t;
t                 499 modules/imgproc/test/test_floodfill.cpp         s1 *= t;
t                 500 modules/imgproc/test/test_floodfill.cpp         s2 *= t;
t                 399 modules/imgproc/test/test_histograms.cpp                 int t = cvtest::randInt(rng) % dims[j];
t                 400 modules/imgproc/test/test_histograms.cpp                 idx[i*cdims + j] = t;
t                 401 modules/imgproc/test/test_histograms.cpp                 lin_idx = lin_idx*dims[j] + t;
t                1000 modules/imgproc/test/test_histograms.cpp     double s0 = 0, s1 = 0, sq0 = 0, sq1 = 0, t;
t                1076 modules/imgproc/test/test_histograms.cpp     t = (sq0 - s0*s0/total_size)*(sq1 - s1*s1/total_size);
t                1077 modules/imgproc/test/test_histograms.cpp     result0[CV_COMP_CORREL] = fabs(t) > DBL_EPSILON ?
t                1078 modules/imgproc/test/test_histograms.cpp         (result0[CV_COMP_CORREL] - s0*s1/total_size)/sqrt(t) : 1;
t                1285 modules/imgproc/test/test_histograms.cpp                     float* t = hist->thresh2[k];
t                1289 modules/imgproc/test/test_histograms.cpp                         if( v < t[j] )
t                1505 modules/imgproc/test/test_histograms.cpp                     float* t = hist->thresh2[k];
t                1509 modules/imgproc/test/test_histograms.cpp                         if( v < t[j] )
t                1522 modules/imgproc/test/test_histograms.cpp                 int t = cvRound(bin_val);
t                1523 modules/imgproc/test/test_histograms.cpp                 CV_IMAGE_ELEM( dst, uchar, y, x ) = saturate_cast<uchar>(t);
t                 289 modules/imgproc/test/test_imgwarp.cpp             int t = (j*src->cols*2 + MIN(src->cols,dcols) - 1)/(dcols*2);
t                 290 modules/imgproc/test/test_imgwarp.cpp             t -= t >= src->cols;
t                 291 modules/imgproc/test/test_imgwarp.cpp             x_idx->data.i[j] = t*elem_size;
t                 296 modules/imgproc/test/test_imgwarp.cpp             int t = (j*src->rows*2 + MIN(src->rows,drows) - 1)/(drows*2);
t                 297 modules/imgproc/test/test_imgwarp.cpp             t -= t >= src->rows;
t                 298 modules/imgproc/test/test_imgwarp.cpp             y_idx->data.i[j] = t;
t                 245 modules/imgproc/test/test_imgwarp_strict.cpp     float t = 1.0f;
t                 247 modules/imgproc/test/test_imgwarp_strict.cpp         t = 1.0f;
t                 249 modules/imgproc/test/test_imgwarp_strict.cpp         t = 1.0f;
t                 251 modules/imgproc/test/test_imgwarp_strict.cpp         t = 1.0f;
t                 253 modules/imgproc/test/test_imgwarp_strict.cpp         t = 2.0f;
t                 261 modules/imgproc/test/test_imgwarp_strict.cpp             if (fabs(rD[dx] - D[dx]) > t &&
t                 182 modules/imgproc/test/test_moments.cpp             double t = (double)getTickCount());
t                 185 modules/imgproc/test/test_moments.cpp             ttime += (double)getTickCount() - t;
t                1623 modules/java/generator/src/cpp/Mat.cpp         Mat _retval_ = me->t(  );
t                 413 modules/ml/src/ann_mlp.cpp                     double t = data[j] + bias[j];
t                 414 modules/ml/src/ann_mlp.cpp                     data[j] = t*t*scale;
t                 435 modules/ml/src/ann_mlp.cpp                         double t = scale2*(1. - data[j])/(1. + data[j]);
t                 436 modules/ml/src/ann_mlp.cpp                         data[j] = t;
t                 485 modules/ml/src/ann_mlp.cpp                     double t = xf[j] + bias[j];
t                 486 modules/ml/src/ann_mlp.cpp                     df[j] = t*2*scale2;
t                 487 modules/ml/src/ann_mlp.cpp                     xf[j] = t*t*scale;
t                 568 modules/ml/src/ann_mlp.cpp                     double t = type == CV_32F ? (double)f[j] : d[j];
t                 569 modules/ml/src/ann_mlp.cpp                     scale[j*2] += t;
t                 570 modules/ml/src/ann_mlp.cpp                     scale[j*2+1] += t*t;
t                 618 modules/ml/src/ann_mlp.cpp                 double t = type == CV_32F ? (double)f[j] : d[j];
t                 623 modules/ml/src/ann_mlp.cpp                     if( mj > t ) mj = t;
t                 624 modules/ml/src/ann_mlp.cpp                     if( Mj < t ) Mj = t;
t                 631 modules/ml/src/ann_mlp.cpp                     t = t*inv_scale[j*2] + inv_scale[2*j+1];
t                 632 modules/ml/src/ann_mlp.cpp                     if( t < m1 || t > M1 )
t                 822 modules/ml/src/ann_mlp.cpp                 double t = (otype == CV_32F ? (double)udata_f[k] : udata_d[k])*w[k*2] + w[k*2+1] - x[l_count-1][k];
t                 823 modules/ml/src/ann_mlp.cpp                 gdata[k] = t*sweight;
t                 824 modules/ml/src/ann_mlp.cpp                 E += t*t;
t                 941 modules/ml/src/ann_mlp.cpp                         double t = (otype == CV_32F ? (double)udata_f[j] : udata_d[j])*w[j*2] + w[j*2+1] - xdata[j];
t                 942 modules/ml/src/ann_mlp.cpp                         gdata[j] = t*sweight;
t                 943 modules/ml/src/ann_mlp.cpp                         E1 += t*t;
t                 711 modules/ml/src/em.cpp                     clusterCov += trainProbs.at<double>(sampleIndex, clusterIndex) * centeredSample.t() * centeredSample;
t                 789 modules/ml/src/gbt.cpp             int t;
t                 790 modules/ml/src/gbt.cpp             CV_SWAP( idx[a], idx[b], t );
t                 151 modules/ml/src/kdtree.cpp             double t = row[j], s = sums[j*2] + t, s2 = sums[j*2+1] + t*t;
t                 346 modules/ml/src/kdtree.cpp                         float t = vec[j] - row[j];
t                 347 modules/ml/src/kdtree.cpp                         d += t*t;
t                 194 modules/ml/src/lr.cpp         thetas = new_theta.t();
t                 210 modules/ml/src/lr.cpp             hconcat(new_theta.t(), thetas.row(ii));
t                 270 modules/ml/src/lr.cpp         temp_pred = calc_sigmoid(data_t*thetas.t());
t                 281 modules/ml/src/lr.cpp             temp_pred = calc_sigmoid(data_t * thetas.row(i).t());
t                 396 modules/ml/src/lr.cpp         pcal_a = (static_cast<double>(1/m)) * _data.t();
t                 482 modules/ml/src/lr.cpp         pcal_a = (static_cast<double>(1/m)) * data_d.t();
t                 207 modules/ml/src/svm.cpp             Qfloat t = results[j];
t                 208 modules/ml/src/svm.cpp             Qfloat e = std::exp(-std::abs(t));
t                 209 modules/ml/src/svm.cpp             if( t > 0 )
t                 613 modules/ml/src/svm.cpp                 Qfloat t = row[j];
t                 614 modules/ml/src/svm.cpp                 dst_pos[j] = t;
t                 615 modules/ml/src/svm.cpp                 dst_neg[j] = -t;
t                 817 modules/ml/src/svm.cpp                 double t;
t                 821 modules/ml/src/svm.cpp                     if( !is_upper_bound(i) && (t = -G[i]) > Gmax1 )  // d = +1
t                 823 modules/ml/src/svm.cpp                         Gmax1 = t;
t                 826 modules/ml/src/svm.cpp                     if( !is_lower_bound(i) && (t = G[i]) > Gmax2 )  // d = -1
t                 828 modules/ml/src/svm.cpp                         Gmax2 = t;
t                 834 modules/ml/src/svm.cpp                     if( !is_upper_bound(i) && (t = -G[i]) > Gmax2 )  // d = +1
t                 836 modules/ml/src/svm.cpp                         Gmax2 = t;
t                 839 modules/ml/src/svm.cpp                     if( !is_lower_bound(i) && (t = G[i]) > Gmax1 )  // d = -1
t                 841 modules/ml/src/svm.cpp                         Gmax1 = t;
t                 913 modules/ml/src/svm.cpp                 double t;
t                 917 modules/ml/src/svm.cpp                     if( !is_upper_bound(i) && (t = -G[i]) > Gmax1 )  // d = +1
t                 919 modules/ml/src/svm.cpp                         Gmax1 = t;
t                 922 modules/ml/src/svm.cpp                     if( !is_lower_bound(i) && (t = G[i]) > Gmax2 )  // d = -1
t                 924 modules/ml/src/svm.cpp                         Gmax2 = t;
t                 930 modules/ml/src/svm.cpp                     if( !is_upper_bound(i) && (t = -G[i]) > Gmax3 )  // d = +1
t                 932 modules/ml/src/svm.cpp                         Gmax3 = t;
t                 935 modules/ml/src/svm.cpp                     if( !is_lower_bound(i) && (t = G[i]) > Gmax4 )  // d = -1
t                 937 modules/ml/src/svm.cpp                         Gmax4 = t;
t                 587 modules/ml/src/tree.cpp                 double t = w->ord_responses[si];
t                 588 modules/ml/src/tree.cpp                 sum += t*wval;
t                 589 modules/ml/src/tree.cpp                 sum2 += t*t*wval;
t                 609 modules/ml/src/tree.cpp                 double t = w->ord_responses[si];
t                 610 modules/ml/src/tree.cpp                 cv_sum[j] += t*wval;
t                 611 modules/ml/src/tree.cpp                 cv_sum2[j] += t*t*wval;
t                 790 modules/ml/src/tree.cpp                     double t = v[j]*alpha - s[j]*beta;
t                 791 modules/ml/src/tree.cpp                     dist2 += t*t;
t                 923 modules/ml/src/tree.cpp                 double t = crow[k];
t                 924 modules/ml/src/tree.cpp                 double lval = lc[k] + t;
t                 925 modules/ml/src/tree.cpp                 double rval = rc[k] - t;
t                 937 modules/ml/src/tree.cpp                 double t = crow[k];
t                 938 modules/ml/src/tree.cpp                 double lval = lc[k] - t;
t                 939 modules/ml/src/tree.cpp                 double rval = rc[k] + t;
t                1020 modules/ml/src/tree.cpp         double t = responses[si]*wval;
t                1022 modules/ml/src/tree.cpp         lsum += t; rsum -= t;
t                1278 modules/ml/src/tree.cpp             double t = fold >= 0 ? w->cv_Tn[nidx*cv_n + fold] : node->Tn;
t                1279 modules/ml/src/tree.cpp             if( t <= T || node->left < 0 )
t                1334 modules/ml/src/tree.cpp             double t = fold >= 0 ? w->cv_Tn[nidx*cv_n + fold] : node->Tn;
t                1335 modules/ml/src/tree.cpp             if( t <= T || node->left < 0 )
t                 662 modules/objdetect/src/haar.cpp         __m256 t = _mm256_set1_ps(static_cast<float>(variance_norm_factor));
t                 664 modules/objdetect/src/haar.cpp         t = _mm256_mul_ps(t, _mm256_set_ps(nodes[7]->threshold,
t                 741 modules/objdetect/src/haar.cpp         _mm256_store_si256((__m256i*)idxV, _mm256_cvttps_epi32(_mm256_blendv_ps(right, left, _mm256_cmp_ps(sum, t, _CMP_LT_OQ))));
t                 801 modules/objdetect/src/haar.cpp             double t = node->threshold * variance_norm_factor;
t                 809 modules/objdetect/src/haar.cpp             idx = sum < t ? node->left : node->right;
t                 934 modules/objdetect/src/haar.cpp                         __m256 t = _mm256_set1_ps(static_cast<float>(variance_norm_factor));
t                 935 modules/objdetect/src/haar.cpp                         t = _mm256_mul_ps(t, _mm256_set_ps(nodes[7]->threshold,
t                1001 modules/objdetect/src/haar.cpp                         _mm256_store_ps(buf, _mm256_blendv_ps(alpha0, alpha1, _mm256_cmp_ps(t, sum, _CMP_LE_OQ)));
t                1010 modules/objdetect/src/haar.cpp                         double t = node->threshold*variance_norm_factor;
t                1013 modules/objdetect/src/haar.cpp                         stage_sum += classifier->alpha[sum >= t];
t                1039 modules/objdetect/src/haar.cpp                         __m256 t = _mm256_set1_ps(static_cast<float>(variance_norm_factor));
t                1041 modules/objdetect/src/haar.cpp                         t = _mm256_mul_ps(t, _mm256_set_ps(nodes[7]->threshold,
t                1126 modules/objdetect/src/haar.cpp                         __m256 outBuf = _mm256_blendv_ps(alpha0, alpha1, _mm256_cmp_ps(t, sum, _CMP_LE_OQ ));
t                1138 modules/objdetect/src/haar.cpp                         double t = node->threshold*variance_norm_factor;
t                1143 modules/objdetect/src/haar.cpp                         stage_sum += classifier->alpha[sum >= t];
t                1165 modules/objdetect/src/haar.cpp                         __m128d t = _mm_set_sd(node->threshold*variance_norm_factor);
t                1170 modules/objdetect/src/haar.cpp                         t = _mm_cmpgt_sd(t, sum);
t                1171 modules/objdetect/src/haar.cpp                         vstage_sum = _mm_add_sd(vstage_sum, _mm_blendv_pd(b, a, t));
t                1181 modules/objdetect/src/haar.cpp                         __m128d t = _mm_set_sd(node->threshold*variance_norm_factor);
t                1190 modules/objdetect/src/haar.cpp                         t = _mm_cmpgt_sd(t, sum);
t                1191 modules/objdetect/src/haar.cpp                         vstage_sum = _mm_add_sd(vstage_sum, _mm_blendv_pd(b, a, t));
t                1211 modules/objdetect/src/haar.cpp                         double t = node->threshold*variance_norm_factor;
t                1214 modules/objdetect/src/haar.cpp                         stage_sum += classifier->alpha[sum >= t];
t                1223 modules/objdetect/src/haar.cpp                         double t = node->threshold*variance_norm_factor;
t                1228 modules/objdetect/src/haar.cpp                         stage_sum += classifier->alpha[sum >= t];
t                 598 modules/objdetect/src/hog.cpp             __m128 t = _mm_sub_ps(_mm_cvtepi32_ps(idx), _bh);
t                 599 modules/objdetect/src/hog.cpp             t = _mm_mul_ps(t, t);
t                 601 modules/objdetect/src/hog.cpp             _mm_storeu_ps(_di + i, t);
t                 615 modules/objdetect/src/hog.cpp             __m128 t = _mm_sub_ps(_mm_cvtepi32_ps(idx), _bw);
t                 616 modules/objdetect/src/hog.cpp             t = _mm_mul_ps(t, t);
t                 618 modules/objdetect/src/hog.cpp             _mm_storeu_ps(_dj + j, t);
t                1048 modules/objdetect/src/hog.cpp         __m128 t = _mm_mul_ps(_scale2, _mm_loadu_ps(hist + i));
t                1049 modules/objdetect/src/hog.cpp         _mm_storeu_ps(hist + i, t);
t                 164 modules/photo/src/contrast_preserve.hpp     Mat d_trans=dest.t();
t                 165 modules/photo/src/contrast_preserve.hpp     Mat d1_trans=dest1.t();
t                 353 modules/photo/src/contrast_preserve.hpp     Mat P_trans = P.t();
t                 212 modules/photo/src/inpaint.cpp static float FastMarching_solve(int i1,int j1,int i2,int j2, const CvMat* f, const CvMat* t)
t                 215 modules/photo/src/inpaint.cpp     a11=CV_MAT_ELEM(*t,float,i1,j1);
t                 216 modules/photo/src/inpaint.cpp     a22=CV_MAT_ELEM(*t,float,i2,j2);
t                 239 modules/photo/src/inpaint.cpp icvCalcFMM(const CvMat *f, CvMat *t, CvPriorityQueueFloat *Heap, bool negate) {
t                 257 modules/photo/src/inpaint.cpp             dist = min4(FastMarching_solve(i-1,j,i,j-1,f,t),
t                 258 modules/photo/src/inpaint.cpp                         FastMarching_solve(i+1,j,i,j-1,f,t),
t                 259 modules/photo/src/inpaint.cpp                         FastMarching_solve(i-1,j,i,j+1,f,t),
t                 260 modules/photo/src/inpaint.cpp                         FastMarching_solve(i+1,j,i,j+1,f,t));
t                 261 modules/photo/src/inpaint.cpp             CV_MAT_ELEM(*t,float,i,j) = dist;
t                 273 modules/photo/src/inpaint.cpp                CV_MAT_ELEM(*t,float,i,j) = -CV_MAT_ELEM(*t,float,i,j);
t                 282 modules/photo/src/inpaint.cpp icvTeleaInpaintFMM(const CvMat *f, CvMat *t, CvMat *out, int range, CvPriorityQueueFloat *Heap ) {
t                 296 modules/photo/src/inpaint.cpp             if ((i<=1)||(j<=1)||(i>t->rows-1)||(j>t->cols-1)) continue;
t                 299 modules/photo/src/inpaint.cpp                dist = min4(FastMarching_solve(i-1,j,i,j-1,f,t),
t                 300 modules/photo/src/inpaint.cpp                            FastMarching_solve(i+1,j,i,j-1,f,t),
t                 301 modules/photo/src/inpaint.cpp                            FastMarching_solve(i-1,j,i,j+1,f,t),
t                 302 modules/photo/src/inpaint.cpp                            FastMarching_solve(i+1,j,i,j+1,f,t));
t                 303 modules/photo/src/inpaint.cpp                CV_MAT_ELEM(*t,float,i,j) = dist;
t                 311 modules/photo/src/inpaint.cpp                         gradT.x=(float)((CV_MAT_ELEM(*t,float,i,j+1)-CV_MAT_ELEM(*t,float,i,j-1)))*0.5f;
t                 313 modules/photo/src/inpaint.cpp                         gradT.x=(float)((CV_MAT_ELEM(*t,float,i,j+1)-CV_MAT_ELEM(*t,float,i,j)));
t                 317 modules/photo/src/inpaint.cpp                         gradT.x=(float)((CV_MAT_ELEM(*t,float,i,j)-CV_MAT_ELEM(*t,float,i,j-1)));
t                 324 modules/photo/src/inpaint.cpp                         gradT.y=(float)((CV_MAT_ELEM(*t,float,i+1,j)-CV_MAT_ELEM(*t,float,i-1,j)))*0.5f;
t                 326 modules/photo/src/inpaint.cpp                         gradT.y=(float)((CV_MAT_ELEM(*t,float,i+1,j)-CV_MAT_ELEM(*t,float,i,j)));
t                 330 modules/photo/src/inpaint.cpp                         gradT.y=(float)((CV_MAT_ELEM(*t,float,i,j)-CV_MAT_ELEM(*t,float,i-1,j)));
t                 336 modules/photo/src/inpaint.cpp                      int km=k-1+(k==1),kp=k-1-(k==t->rows-2);
t                 338 modules/photo/src/inpaint.cpp                         int lm=l-1+(l==1),lp=l-1-(l==t->cols-2);
t                 339 modules/photo/src/inpaint.cpp                         if (k>0&&l>0&&k<t->rows-1&&l<t->cols-1) {
t                 346 modules/photo/src/inpaint.cpp                               lev = (float)(1./(1+fabs(CV_MAT_ELEM(*t,float,k,l)-CV_MAT_ELEM(*t,float,i,j))));
t                 408 modules/photo/src/inpaint.cpp             if ((i<=1)||(j<=1)||(i>t->rows-1)||(j>t->cols-1)) continue;
t                 411 modules/photo/src/inpaint.cpp                dist = min4(FastMarching_solve(i-1,j,i,j-1,f,t),
t                 412 modules/photo/src/inpaint.cpp                            FastMarching_solve(i+1,j,i,j-1,f,t),
t                 413 modules/photo/src/inpaint.cpp                            FastMarching_solve(i-1,j,i,j+1,f,t),
t                 414 modules/photo/src/inpaint.cpp                            FastMarching_solve(i+1,j,i,j+1,f,t));
t                 415 modules/photo/src/inpaint.cpp                CV_MAT_ELEM(*t,float,i,j) = dist;
t                 423 modules/photo/src/inpaint.cpp                         gradT.x=(float)((CV_MAT_ELEM(*t,float,i,j+1)-CV_MAT_ELEM(*t,float,i,j-1)))*0.5f;
t                 425 modules/photo/src/inpaint.cpp                         gradT.x=(float)((CV_MAT_ELEM(*t,float,i,j+1)-CV_MAT_ELEM(*t,float,i,j)));
t                 429 modules/photo/src/inpaint.cpp                         gradT.x=(float)((CV_MAT_ELEM(*t,float,i,j)-CV_MAT_ELEM(*t,float,i,j-1)));
t                 436 modules/photo/src/inpaint.cpp                         gradT.y=(float)((CV_MAT_ELEM(*t,float,i+1,j)-CV_MAT_ELEM(*t,float,i-1,j)))*0.5f;
t                 438 modules/photo/src/inpaint.cpp                         gradT.y=(float)((CV_MAT_ELEM(*t,float,i+1,j)-CV_MAT_ELEM(*t,float,i,j)));
t                 442 modules/photo/src/inpaint.cpp                         gradT.y=(float)((CV_MAT_ELEM(*t,float,i,j)-CV_MAT_ELEM(*t,float,i-1,j)));
t                 448 modules/photo/src/inpaint.cpp                      int km=k-1+(k==1),kp=k-1-(k==t->rows-2);
t                 450 modules/photo/src/inpaint.cpp                         int lm=l-1+(l==1),lp=l-1-(l==t->cols-2);
t                 451 modules/photo/src/inpaint.cpp                         if (k>0&&l>0&&k<t->rows-1&&l<t->cols-1) {
t                 458 modules/photo/src/inpaint.cpp                               lev = (float)(1./(1+fabs(CV_MAT_ELEM(*t,float,k,l)-CV_MAT_ELEM(*t,float,i,j))));
t                 514 modules/photo/src/inpaint.cpp icvNSInpaintFMM(const CvMat *f, CvMat *t, CvMat *out, int range, CvPriorityQueueFloat *Heap) {
t                 528 modules/photo/src/inpaint.cpp             if ((i<=1)||(j<=1)||(i>t->rows-1)||(j>t->cols-1)) continue;
t                 531 modules/photo/src/inpaint.cpp                dist = min4(FastMarching_solve(i-1,j,i,j-1,f,t),
t                 532 modules/photo/src/inpaint.cpp                            FastMarching_solve(i+1,j,i,j-1,f,t),
t                 533 modules/photo/src/inpaint.cpp                            FastMarching_solve(i-1,j,i,j+1,f,t),
t                 534 modules/photo/src/inpaint.cpp                            FastMarching_solve(i+1,j,i,j+1,f,t));
t                 535 modules/photo/src/inpaint.cpp                CV_MAT_ELEM(*t,float,i,j) = dist;
t                 616 modules/photo/src/inpaint.cpp             if ((i<=1)||(j<=1)||(i>t->rows-1)||(j>t->cols-1)) continue;
t                 619 modules/photo/src/inpaint.cpp                dist = min4(FastMarching_solve(i-1,j,i,j-1,f,t),
t                 620 modules/photo/src/inpaint.cpp                            FastMarching_solve(i+1,j,i,j-1,f,t),
t                 621 modules/photo/src/inpaint.cpp                            FastMarching_solve(i-1,j,i,j+1,f,t),
t                 622 modules/photo/src/inpaint.cpp                            FastMarching_solve(i+1,j,i,j+1,f,t));
t                 623 modules/photo/src/inpaint.cpp                CV_MAT_ELEM(*t,float,i,j) = dist;
t                 630 modules/photo/src/inpaint.cpp                      int km=k-1+(k==1),kp=k-1-(k==t->rows-2);
t                 632 modules/photo/src/inpaint.cpp                         int lm=l-1+(l==1),lp=l-1-(l==t->cols-2);
t                 633 modules/photo/src/inpaint.cpp                         if (k>0&&l>0&&k<t->rows-1&&l<t->cols-1) {
t                 731 modules/photo/src/inpaint.cpp     cv::Ptr<CvMat> mask, band, f, t, out;
t                 763 modules/photo/src/inpaint.cpp     t.reset(cvCreateMat(erows, ecols, CV_32FC1));
t                 773 modules/photo/src/inpaint.cpp     cvSet(t,cvScalar(1.0e6f,0,0,0));
t                 784 modules/photo/src/inpaint.cpp     cvSet(t,cvScalar(0,0,0,0),band);
t                 800 modules/photo/src/inpaint.cpp         icvCalcFMM(out,t,Out,true);
t                 801 modules/photo/src/inpaint.cpp         icvTeleaInpaintFMM(mask,t,output_img,range,Heap);
t                 804 modules/photo/src/inpaint.cpp         icvNSInpaintFMM(mask,t,output_img,range,Heap);
t                 489 modules/photo/src/npr.hpp         Mat vert_t = vert.t();
t                 497 modules/photo/src/npr.hpp             O_t = O.t();
t                 501 modules/photo/src/npr.hpp             O = O_t.t();
t                 508 modules/photo/src/npr.hpp         Mat vert_t = ct_V.t();
t                 522 modules/photo/src/npr.hpp             O_t = O.t();
t                 526 modules/photo/src/npr.hpp             O = O_t.t();
t                 548 modules/photo/src/npr.hpp     Mat vert_t = ct_V.t();
t                 569 modules/photo/src/npr.hpp         O_t = O.t();
t                 573 modules/photo/src/npr.hpp         O = O_t.t();
t                 575 modules/photo/src/npr.hpp         peny_t = peny.t();
t                 149 modules/photo/src/seamless_cloning_impl.cpp     temp = planes2[1].t();
t                 506 modules/photo/src/tonemap.cpp             getGradient(layer.t(), y_contrast[i], 0);
t                 520 modules/photo/src/tonemap.cpp             sum += grad_x + grad_y.t();
t                 165 modules/photo/test/test_denoising.cpp     double t = (double)getTickCount();
t                 167 modules/photo/test/test_denoising.cpp     t = (double)getTickCount() - t;
t                 168 modules/photo/test/test_denoising.cpp     printf("execution time: %gms\n", t*1000./getTickFrequency());
t                 283 modules/shape/src/hist_cost.cpp                 sig1.col(0)=scd1.row(i).t();
t                 284 modules/shape/src/hist_cost.cpp                 sig2.col(0)=scd2.row(j).t();
t                 520 modules/shape/src/hist_cost.cpp                 sig1.col(0)=scd1.row(i).t();
t                 521 modules/shape/src/hist_cost.cpp                 sig2.col(0)=scd2.row(j).t();
t                 276 modules/shape/src/tps_trans.cpp     Mat Q=w.t()*matK*w;
t                  70 modules/stitching/include/opencv2/stitching/detail/camera.hpp     Mat t; // Translation
t                 135 modules/stitching/include/opencv2/stitching/detail/warpers.hpp     float t[3];
t                 220 modules/stitching/include/opencv2/stitching/detail/warpers_inl.hpp     x_ = t[0] + x_ / z_ * (1 - t[2]);
t                 221 modules/stitching/include/opencv2/stitching/detail/warpers_inl.hpp     y_ = t[1] + y_ / z_ * (1 - t[2]);
t                 231 modules/stitching/include/opencv2/stitching/detail/warpers_inl.hpp     u = u / scale - t[0];
t                 232 modules/stitching/include/opencv2/stitching/detail/warpers_inl.hpp     v = v / scale - t[1];
t                 235 modules/stitching/include/opencv2/stitching/detail/warpers_inl.hpp     x = k_rinv[0] * u + k_rinv[1] * v + k_rinv[2] * (1 - t[2]);
t                 236 modules/stitching/include/opencv2/stitching/detail/warpers_inl.hpp     y = k_rinv[3] * u + k_rinv[4] * v + k_rinv[5] * (1 - t[2]);
t                 237 modules/stitching/include/opencv2/stitching/detail/warpers_inl.hpp     z = k_rinv[6] * u + k_rinv[7] * v + k_rinv[8] * (1 - t[2]);
t                 737 modules/stitching/include/opencv2/stitching/detail/warpers_inl.hpp     x_ = t[0] + x_ / z_ * (1 - t[2]);
t                 738 modules/stitching/include/opencv2/stitching/detail/warpers_inl.hpp     y_ = t[1] + y_ / z_ * (1 - t[2]);
t                 756 modules/stitching/include/opencv2/stitching/detail/warpers_inl.hpp     u = u / scale - t[0];
t                 757 modules/stitching/include/opencv2/stitching/detail/warpers_inl.hpp     v = v / scale - t[1];
t                 760 modules/stitching/include/opencv2/stitching/detail/warpers_inl.hpp     x = k_rinv[0] * v + k_rinv[1] * u + k_rinv[2] * (1 - t[2]);
t                 761 modules/stitching/include/opencv2/stitching/detail/warpers_inl.hpp     y = k_rinv[3] * v + k_rinv[4] * u + k_rinv[5] * (1 - t[2]);
t                 762 modules/stitching/include/opencv2/stitching/detail/warpers_inl.hpp     z = k_rinv[6] * v + k_rinv[7] * u + k_rinv[8] * (1 - t[2]);
t                 192 modules/stitching/src/autocalib.cpp     K = W.t();
t                 278 modules/stitching/src/blenders.cpp     int64 t = getTickCount();
t                 319 modules/stitching/src/blenders.cpp     LOGLN("  Add border to the source image, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
t                 321 modules/stitching/src/blenders.cpp     t = getTickCount();
t                 330 modules/stitching/src/blenders.cpp     LOGLN("  Create the source image Laplacian pyramid, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
t                 332 modules/stitching/src/blenders.cpp     t = getTickCount();
t                 356 modules/stitching/src/blenders.cpp     LOGLN("  Create the weight map Gaussian pyramid, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
t                 358 modules/stitching/src/blenders.cpp     t = getTickCount();
t                 428 modules/stitching/src/blenders.cpp     LOGLN("  Add weighted layer of the source image to the final Laplacian pyramid layer, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
t                  60 modules/stitching/src/camera.cpp     t = other.t.clone();
t                  76 modules/stitching/src/exposure_compensate.cpp     int64 t = getTickCount();
t                 144 modules/stitching/src/exposure_compensate.cpp     LOGLN("Exposure compensation, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
t                 112 modules/stitching/src/motion_estimators.cpp     int64 t = getTickCount();
t                 169 modules/stitching/src/motion_estimators.cpp     LOGLN("Estimating rotations, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
t                 182 modules/stitching/src/motion_estimators.cpp     int64 t = getTickCount();
t                 275 modules/stitching/src/motion_estimators.cpp     LOGLN_CHAT("Bundle adjustment, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
t                 608 modules/stitching/src/motion_estimators.cpp     int64 t = getTickCount();
t                 612 modules/stitching/src/motion_estimators.cpp         LOGLN("Wave correcting, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
t                 620 modules/stitching/src/motion_estimators.cpp         moment += col * col.t();
t                 627 modules/stitching/src/motion_estimators.cpp         rg1 = eigen_vecs.row(2).t();
t                 629 modules/stitching/src/motion_estimators.cpp         rg1 = eigen_vecs.row(0).t();
t                 672 modules/stitching/src/motion_estimators.cpp     Mat(rg0.t()).copyTo(tmp);
t                 674 modules/stitching/src/motion_estimators.cpp     Mat(rg1.t()).copyTo(tmp);
t                 676 modules/stitching/src/motion_estimators.cpp     Mat(rg2.t()).copyTo(tmp);
t                 681 modules/stitching/src/motion_estimators.cpp     LOGLN("Wave correcting, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
t                  57 modules/stitching/src/seam_finders.cpp     int64 t = getTickCount();
t                  68 modules/stitching/src/seam_finders.cpp     LOGLN("Finding seams, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
t                  99 modules/stitching/src/seam_finders.cpp     int64 t = getTickCount();
t                 107 modules/stitching/src/seam_finders.cpp     LOGLN("Finding seams, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
t                 172 modules/stitching/src/seam_finders.cpp     int64 t = getTickCount();
t                 198 modules/stitching/src/seam_finders.cpp     LOGLN("Finding seams, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
t                 155 modules/stitching/src/stitcher.cpp     int64 t = getTickCount();
t                 192 modules/stitching/src/stitcher.cpp     LOGLN("Warping images, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
t                 206 modules/stitching/src/stitcher.cpp     t = getTickCount();
t                 351 modules/stitching/src/stitcher.cpp     LOGLN("Compositing, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
t                 399 modules/stitching/src/stitcher.cpp     int64 t = getTickCount();
t                 454 modules/stitching/src/stitcher.cpp     LOGLN("Finding features, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
t                 458 modules/stitching/src/stitcher.cpp     t = getTickCount();
t                 462 modules/stitching/src/stitcher.cpp     LOGLN("Pairwise matching, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
t                  62 modules/stitching/src/warpers.cpp     Mat_<float> Rinv = R.t();
t                  78 modules/stitching/src/warpers.cpp     t[0] = T_(0,0); t[1] = T_(1,0); t[2] = T_(2,0);
t                 119 modules/stitching/src/warpers.cpp             Mat k_rinv(1, 9, CV_32FC1, projector_.k_rinv), t(1, 3, CV_32FC1, projector_.t);
t                 121 modules/stitching/src/warpers.cpp                     uk_rinv = k_rinv.getUMat(ACCESS_READ), ut = t.getUMat(ACCESS_READ);
t                  56 modules/stitching/src/warpers_cuda.cpp                                 const float k_rinv[9], const float r_kinv[9], const float t[3], float scale,
t                  82 modules/stitching/src/warpers_cuda.cpp     Mat K_Rinv = K * R.t();
t                 108 modules/stitching/src/warpers_cuda.cpp     Mat K_Rinv = K * R.t();
t                 133 modules/stitching/src/warpers_cuda.cpp     Mat K_Rinv = K * R.t();
t                 905 modules/superres/src/btv_l1.cpp         for (int t = -temporalAreaRadius_; t <= temporalAreaRadius_; ++t)
t                 933 modules/superres/src/btv_l1.cpp         for (int t = -temporalAreaRadius_; t <= temporalAreaRadius_; ++t)
t                 485 modules/superres/src/btv_l1_cuda.cpp         for (int t = -temporalAreaRadius_; t <= temporalAreaRadius_; ++t)
t                 901 modules/ts/include/opencv2/ts/ts_gtest.h   tuple(const tuple& t) : f0_(t.f0_) {}
t                 904 modules/ts/include/opencv2/ts/ts_gtest.h   tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {}
t                 906 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& operator=(const tuple& t) { return CopyFrom(t); }
t                 909 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& operator=(const GTEST_1_TUPLE_(U)& t) {
t                 910 modules/ts/include/opencv2/ts/ts_gtest.h     return CopyFrom(t);
t                 916 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) {
t                 917 modules/ts/include/opencv2/ts/ts_gtest.h     f0_ = t.f0_;
t                 934 modules/ts/include/opencv2/ts/ts_gtest.h   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_) {}
t                 937 modules/ts/include/opencv2/ts/ts_gtest.h   tuple(const GTEST_2_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_) {}
t                 941 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& operator=(const tuple& t) { return CopyFrom(t); }
t                 944 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& operator=(const GTEST_2_TUPLE_(U)& t) {
t                 945 modules/ts/include/opencv2/ts/ts_gtest.h     return CopyFrom(t);
t                 957 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& CopyFrom(const GTEST_2_TUPLE_(U)& t) {
t                 958 modules/ts/include/opencv2/ts/ts_gtest.h     f0_ = t.f0_;
t                 959 modules/ts/include/opencv2/ts/ts_gtest.h     f1_ = t.f1_;
t                 977 modules/ts/include/opencv2/ts/ts_gtest.h   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
t                 980 modules/ts/include/opencv2/ts/ts_gtest.h   tuple(const GTEST_3_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
t                 982 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& operator=(const tuple& t) { return CopyFrom(t); }
t                 985 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& operator=(const GTEST_3_TUPLE_(U)& t) {
t                 986 modules/ts/include/opencv2/ts/ts_gtest.h     return CopyFrom(t);
t                 992 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& CopyFrom(const GTEST_3_TUPLE_(U)& t) {
t                 993 modules/ts/include/opencv2/ts/ts_gtest.h     f0_ = t.f0_;
t                 994 modules/ts/include/opencv2/ts/ts_gtest.h     f1_ = t.f1_;
t                 995 modules/ts/include/opencv2/ts/ts_gtest.h     f2_ = t.f2_;
t                1015 modules/ts/include/opencv2/ts/ts_gtest.h   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_) {}
t                1018 modules/ts/include/opencv2/ts/ts_gtest.h   tuple(const GTEST_4_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
t                1019 modules/ts/include/opencv2/ts/ts_gtest.h       f3_(t.f3_) {}
t                1021 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& operator=(const tuple& t) { return CopyFrom(t); }
t                1024 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& operator=(const GTEST_4_TUPLE_(U)& t) {
t                1025 modules/ts/include/opencv2/ts/ts_gtest.h     return CopyFrom(t);
t                1031 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& CopyFrom(const GTEST_4_TUPLE_(U)& t) {
t                1032 modules/ts/include/opencv2/ts/ts_gtest.h     f0_ = t.f0_;
t                1033 modules/ts/include/opencv2/ts/ts_gtest.h     f1_ = t.f1_;
t                1034 modules/ts/include/opencv2/ts/ts_gtest.h     f2_ = t.f2_;
t                1035 modules/ts/include/opencv2/ts/ts_gtest.h     f3_ = t.f3_;
t                1056 modules/ts/include/opencv2/ts/ts_gtest.h   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
t                1057 modules/ts/include/opencv2/ts/ts_gtest.h       f4_(t.f4_) {}
t                1060 modules/ts/include/opencv2/ts/ts_gtest.h   tuple(const GTEST_5_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
t                1061 modules/ts/include/opencv2/ts/ts_gtest.h       f3_(t.f3_), f4_(t.f4_) {}
t                1063 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& operator=(const tuple& t) { return CopyFrom(t); }
t                1066 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& operator=(const GTEST_5_TUPLE_(U)& t) {
t                1067 modules/ts/include/opencv2/ts/ts_gtest.h     return CopyFrom(t);
t                1073 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& CopyFrom(const GTEST_5_TUPLE_(U)& t) {
t                1074 modules/ts/include/opencv2/ts/ts_gtest.h     f0_ = t.f0_;
t                1075 modules/ts/include/opencv2/ts/ts_gtest.h     f1_ = t.f1_;
t                1076 modules/ts/include/opencv2/ts/ts_gtest.h     f2_ = t.f2_;
t                1077 modules/ts/include/opencv2/ts/ts_gtest.h     f3_ = t.f3_;
t                1078 modules/ts/include/opencv2/ts/ts_gtest.h     f4_ = t.f4_;
t                1101 modules/ts/include/opencv2/ts/ts_gtest.h   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
t                1102 modules/ts/include/opencv2/ts/ts_gtest.h       f4_(t.f4_), f5_(t.f5_) {}
t                1105 modules/ts/include/opencv2/ts/ts_gtest.h   tuple(const GTEST_6_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
t                1106 modules/ts/include/opencv2/ts/ts_gtest.h       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_) {}
t                1108 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& operator=(const tuple& t) { return CopyFrom(t); }
t                1111 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& operator=(const GTEST_6_TUPLE_(U)& t) {
t                1112 modules/ts/include/opencv2/ts/ts_gtest.h     return CopyFrom(t);
t                1118 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& CopyFrom(const GTEST_6_TUPLE_(U)& t) {
t                1119 modules/ts/include/opencv2/ts/ts_gtest.h     f0_ = t.f0_;
t                1120 modules/ts/include/opencv2/ts/ts_gtest.h     f1_ = t.f1_;
t                1121 modules/ts/include/opencv2/ts/ts_gtest.h     f2_ = t.f2_;
t                1122 modules/ts/include/opencv2/ts/ts_gtest.h     f3_ = t.f3_;
t                1123 modules/ts/include/opencv2/ts/ts_gtest.h     f4_ = t.f4_;
t                1124 modules/ts/include/opencv2/ts/ts_gtest.h     f5_ = t.f5_;
t                1148 modules/ts/include/opencv2/ts/ts_gtest.h   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
t                1149 modules/ts/include/opencv2/ts/ts_gtest.h       f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
t                1152 modules/ts/include/opencv2/ts/ts_gtest.h   tuple(const GTEST_7_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
t                1153 modules/ts/include/opencv2/ts/ts_gtest.h       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
t                1155 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& operator=(const tuple& t) { return CopyFrom(t); }
t                1158 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& operator=(const GTEST_7_TUPLE_(U)& t) {
t                1159 modules/ts/include/opencv2/ts/ts_gtest.h     return CopyFrom(t);
t                1165 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& CopyFrom(const GTEST_7_TUPLE_(U)& t) {
t                1166 modules/ts/include/opencv2/ts/ts_gtest.h     f0_ = t.f0_;
t                1167 modules/ts/include/opencv2/ts/ts_gtest.h     f1_ = t.f1_;
t                1168 modules/ts/include/opencv2/ts/ts_gtest.h     f2_ = t.f2_;
t                1169 modules/ts/include/opencv2/ts/ts_gtest.h     f3_ = t.f3_;
t                1170 modules/ts/include/opencv2/ts/ts_gtest.h     f4_ = t.f4_;
t                1171 modules/ts/include/opencv2/ts/ts_gtest.h     f5_ = t.f5_;
t                1172 modules/ts/include/opencv2/ts/ts_gtest.h     f6_ = t.f6_;
t                1198 modules/ts/include/opencv2/ts/ts_gtest.h   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
t                1199 modules/ts/include/opencv2/ts/ts_gtest.h       f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
t                1202 modules/ts/include/opencv2/ts/ts_gtest.h   tuple(const GTEST_8_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
t                1203 modules/ts/include/opencv2/ts/ts_gtest.h       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
t                1205 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& operator=(const tuple& t) { return CopyFrom(t); }
t                1208 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& operator=(const GTEST_8_TUPLE_(U)& t) {
t                1209 modules/ts/include/opencv2/ts/ts_gtest.h     return CopyFrom(t);
t                1215 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& CopyFrom(const GTEST_8_TUPLE_(U)& t) {
t                1216 modules/ts/include/opencv2/ts/ts_gtest.h     f0_ = t.f0_;
t                1217 modules/ts/include/opencv2/ts/ts_gtest.h     f1_ = t.f1_;
t                1218 modules/ts/include/opencv2/ts/ts_gtest.h     f2_ = t.f2_;
t                1219 modules/ts/include/opencv2/ts/ts_gtest.h     f3_ = t.f3_;
t                1220 modules/ts/include/opencv2/ts/ts_gtest.h     f4_ = t.f4_;
t                1221 modules/ts/include/opencv2/ts/ts_gtest.h     f5_ = t.f5_;
t                1222 modules/ts/include/opencv2/ts/ts_gtest.h     f6_ = t.f6_;
t                1223 modules/ts/include/opencv2/ts/ts_gtest.h     f7_ = t.f7_;
t                1250 modules/ts/include/opencv2/ts/ts_gtest.h   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
t                1251 modules/ts/include/opencv2/ts/ts_gtest.h       f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
t                1254 modules/ts/include/opencv2/ts/ts_gtest.h   tuple(const GTEST_9_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
t                1255 modules/ts/include/opencv2/ts/ts_gtest.h       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
t                1257 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& operator=(const tuple& t) { return CopyFrom(t); }
t                1260 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& operator=(const GTEST_9_TUPLE_(U)& t) {
t                1261 modules/ts/include/opencv2/ts/ts_gtest.h     return CopyFrom(t);
t                1267 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& CopyFrom(const GTEST_9_TUPLE_(U)& t) {
t                1268 modules/ts/include/opencv2/ts/ts_gtest.h     f0_ = t.f0_;
t                1269 modules/ts/include/opencv2/ts/ts_gtest.h     f1_ = t.f1_;
t                1270 modules/ts/include/opencv2/ts/ts_gtest.h     f2_ = t.f2_;
t                1271 modules/ts/include/opencv2/ts/ts_gtest.h     f3_ = t.f3_;
t                1272 modules/ts/include/opencv2/ts/ts_gtest.h     f4_ = t.f4_;
t                1273 modules/ts/include/opencv2/ts/ts_gtest.h     f5_ = t.f5_;
t                1274 modules/ts/include/opencv2/ts/ts_gtest.h     f6_ = t.f6_;
t                1275 modules/ts/include/opencv2/ts/ts_gtest.h     f7_ = t.f7_;
t                1276 modules/ts/include/opencv2/ts/ts_gtest.h     f8_ = t.f8_;
t                1305 modules/ts/include/opencv2/ts/ts_gtest.h   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
t                1306 modules/ts/include/opencv2/ts/ts_gtest.h       f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), f9_(t.f9_) {}
t                1309 modules/ts/include/opencv2/ts/ts_gtest.h   tuple(const GTEST_10_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
t                1310 modules/ts/include/opencv2/ts/ts_gtest.h       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_),
t                1311 modules/ts/include/opencv2/ts/ts_gtest.h       f9_(t.f9_) {}
t                1313 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& operator=(const tuple& t) { return CopyFrom(t); }
t                1316 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& operator=(const GTEST_10_TUPLE_(U)& t) {
t                1317 modules/ts/include/opencv2/ts/ts_gtest.h     return CopyFrom(t);
t                1323 modules/ts/include/opencv2/ts/ts_gtest.h   tuple& CopyFrom(const GTEST_10_TUPLE_(U)& t) {
t                1324 modules/ts/include/opencv2/ts/ts_gtest.h     f0_ = t.f0_;
t                1325 modules/ts/include/opencv2/ts/ts_gtest.h     f1_ = t.f1_;
t                1326 modules/ts/include/opencv2/ts/ts_gtest.h     f2_ = t.f2_;
t                1327 modules/ts/include/opencv2/ts/ts_gtest.h     f3_ = t.f3_;
t                1328 modules/ts/include/opencv2/ts/ts_gtest.h     f4_ = t.f4_;
t                1329 modules/ts/include/opencv2/ts/ts_gtest.h     f5_ = t.f5_;
t                1330 modules/ts/include/opencv2/ts/ts_gtest.h     f6_ = t.f6_;
t                1331 modules/ts/include/opencv2/ts/ts_gtest.h     f7_ = t.f7_;
t                1332 modules/ts/include/opencv2/ts/ts_gtest.h     f8_ = t.f8_;
t                1333 modules/ts/include/opencv2/ts/ts_gtest.h     f9_ = t.f9_;
t                1492 modules/ts/include/opencv2/ts/ts_gtest.h   Field(Tuple& t) { return t.f0_; }  // NOLINT
t                1496 modules/ts/include/opencv2/ts/ts_gtest.h   ConstField(const Tuple& t) { return t.f0_; }
t                1504 modules/ts/include/opencv2/ts/ts_gtest.h   Field(Tuple& t) { return t.f1_; }  // NOLINT
t                1508 modules/ts/include/opencv2/ts/ts_gtest.h   ConstField(const Tuple& t) { return t.f1_; }
t                1516 modules/ts/include/opencv2/ts/ts_gtest.h   Field(Tuple& t) { return t.f2_; }  // NOLINT
t                1520 modules/ts/include/opencv2/ts/ts_gtest.h   ConstField(const Tuple& t) { return t.f2_; }
t                1528 modules/ts/include/opencv2/ts/ts_gtest.h   Field(Tuple& t) { return t.f3_; }  // NOLINT
t                1532 modules/ts/include/opencv2/ts/ts_gtest.h   ConstField(const Tuple& t) { return t.f3_; }
t                1540 modules/ts/include/opencv2/ts/ts_gtest.h   Field(Tuple& t) { return t.f4_; }  // NOLINT
t                1544 modules/ts/include/opencv2/ts/ts_gtest.h   ConstField(const Tuple& t) { return t.f4_; }
t                1552 modules/ts/include/opencv2/ts/ts_gtest.h   Field(Tuple& t) { return t.f5_; }  // NOLINT
t                1556 modules/ts/include/opencv2/ts/ts_gtest.h   ConstField(const Tuple& t) { return t.f5_; }
t                1564 modules/ts/include/opencv2/ts/ts_gtest.h   Field(Tuple& t) { return t.f6_; }  // NOLINT
t                1568 modules/ts/include/opencv2/ts/ts_gtest.h   ConstField(const Tuple& t) { return t.f6_; }
t                1576 modules/ts/include/opencv2/ts/ts_gtest.h   Field(Tuple& t) { return t.f7_; }  // NOLINT
t                1580 modules/ts/include/opencv2/ts/ts_gtest.h   ConstField(const Tuple& t) { return t.f7_; }
t                1588 modules/ts/include/opencv2/ts/ts_gtest.h   Field(Tuple& t) { return t.f8_; }  // NOLINT
t                1592 modules/ts/include/opencv2/ts/ts_gtest.h   ConstField(const Tuple& t) { return t.f8_; }
t                1600 modules/ts/include/opencv2/ts/ts_gtest.h   Field(Tuple& t) { return t.f9_; }  // NOLINT
t                1604 modules/ts/include/opencv2/ts/ts_gtest.h   ConstField(const Tuple& t) { return t.f9_; }
t                1611 modules/ts/include/opencv2/ts/ts_gtest.h get(GTEST_10_TUPLE_(T)& t) {
t                1612 modules/ts/include/opencv2/ts/ts_gtest.h   return gtest_internal::Get<k>::Field(t);
t                1617 modules/ts/include/opencv2/ts/ts_gtest.h get(const GTEST_10_TUPLE_(T)& t) {
t                1618 modules/ts/include/opencv2/ts/ts_gtest.h   return gtest_internal::Get<k>::ConstField(t);
t                1654 modules/ts/include/opencv2/ts/ts_gtest.h inline bool operator==(const GTEST_10_TUPLE_(T)& t,
t                1658 modules/ts/include/opencv2/ts/ts_gtest.h       tuple_size<GTEST_10_TUPLE_(U)>::value>::Eq(t, u);
t                1662 modules/ts/include/opencv2/ts/ts_gtest.h inline bool operator!=(const GTEST_10_TUPLE_(T)& t,
t                1663 modules/ts/include/opencv2/ts/ts_gtest.h                        const GTEST_10_TUPLE_(U)& u) { return !(t == u); }
t                9742 modules/ts/include/opencv2/ts/ts_gtest.h void PrintTupleTo(const T& t, ::std::ostream* os);
t                9749 modules/ts/include/opencv2/ts/ts_gtest.h inline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) {
t                9750 modules/ts/include/opencv2/ts/ts_gtest.h   PrintTupleTo(t, os);
t                9754 modules/ts/include/opencv2/ts/ts_gtest.h void PrintTo(const ::std::tr1::tuple<T1>& t, ::std::ostream* os) {
t                9755 modules/ts/include/opencv2/ts/ts_gtest.h   PrintTupleTo(t, os);
t                9759 modules/ts/include/opencv2/ts/ts_gtest.h void PrintTo(const ::std::tr1::tuple<T1, T2>& t, ::std::ostream* os) {
t                9760 modules/ts/include/opencv2/ts/ts_gtest.h   PrintTupleTo(t, os);
t                9764 modules/ts/include/opencv2/ts/ts_gtest.h void PrintTo(const ::std::tr1::tuple<T1, T2, T3>& t, ::std::ostream* os) {
t                9765 modules/ts/include/opencv2/ts/ts_gtest.h   PrintTupleTo(t, os);
t                9769 modules/ts/include/opencv2/ts/ts_gtest.h void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4>& t, ::std::ostream* os) {
t                9770 modules/ts/include/opencv2/ts/ts_gtest.h   PrintTupleTo(t, os);
t                9774 modules/ts/include/opencv2/ts/ts_gtest.h void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5>& t,
t                9776 modules/ts/include/opencv2/ts/ts_gtest.h   PrintTupleTo(t, os);
t                9781 modules/ts/include/opencv2/ts/ts_gtest.h void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6>& t,
t                9783 modules/ts/include/opencv2/ts/ts_gtest.h   PrintTupleTo(t, os);
t                9788 modules/ts/include/opencv2/ts/ts_gtest.h void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7>& t,
t                9790 modules/ts/include/opencv2/ts/ts_gtest.h   PrintTupleTo(t, os);
t                9795 modules/ts/include/opencv2/ts/ts_gtest.h void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8>& t,
t                9797 modules/ts/include/opencv2/ts/ts_gtest.h   PrintTupleTo(t, os);
t                9802 modules/ts/include/opencv2/ts/ts_gtest.h void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>& t,
t                9804 modules/ts/include/opencv2/ts/ts_gtest.h   PrintTupleTo(t, os);
t                9810 modules/ts/include/opencv2/ts/ts_gtest.h     const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& t,
t                9812 modules/ts/include/opencv2/ts/ts_gtest.h   PrintTupleTo(t, os);
t                10026 modules/ts/include/opencv2/ts/ts_gtest.h   static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
t                10027 modules/ts/include/opencv2/ts/ts_gtest.h     TuplePrefixPrinter<N - 1>::PrintPrefixTo(t, os);
t                10030 modules/ts/include/opencv2/ts/ts_gtest.h         ::Print(::std::tr1::get<N - 1>(t), os);
t                10036 modules/ts/include/opencv2/ts/ts_gtest.h   static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) {
t                10037 modules/ts/include/opencv2/ts/ts_gtest.h     TuplePrefixPrinter<N - 1>::TersePrintPrefixToStrings(t, strings);
t                10039 modules/ts/include/opencv2/ts/ts_gtest.h     UniversalTersePrint(::std::tr1::get<N - 1>(t), &ss);
t                10061 modules/ts/include/opencv2/ts/ts_gtest.h   static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
t                10063 modules/ts/include/opencv2/ts/ts_gtest.h         Print(::std::tr1::get<0>(t), os);
t                10067 modules/ts/include/opencv2/ts/ts_gtest.h   static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) {
t                10069 modules/ts/include/opencv2/ts/ts_gtest.h     UniversalTersePrint(::std::tr1::get<0>(t), &ss);
t                10077 modules/ts/include/opencv2/ts/ts_gtest.h void PrintTupleTo(const T& t, ::std::ostream* os) {
t                10080 modules/ts/include/opencv2/ts/ts_gtest.h       PrintPrefixTo(t, os);
t                19219 modules/ts/include/opencv2/ts/ts_gtest.h     AssertHelperData(TestPartResult::Type t,
t                19223 modules/ts/include/opencv2/ts/ts_gtest.h         : type(t), file(srcfile), line(line_num), message(msg) { }
t                 124 modules/ts/include/opencv2/ts/ts_perf.hpp     inline void PrintTo(const class_name& t, std::ostream* os) { t.PrintTo(os); } }
t                 153 modules/ts/include/opencv2/ts/ts_perf.hpp     inline void PrintTo(const class_name& t, std::ostream* os) { t.PrintTo(os); } }
t                 460 modules/ts/include/opencv2/ts/ts_perf.hpp         _declareHelper(TestBase* t);
t                 486 modules/ts/include/opencv2/ts/ts_perf.hpp CV_EXPORTS void PrintTo(const MatType& t, std::ostream* os);
t                 317 modules/ts/src/ts.cpp         int t = cvRound( ((double)test_case_idx * width)/count );
t                 318 modules/ts/src/ts.cpp         if( t > progress )
t                 321 modules/ts/src/ts.cpp             progress = t;
t                 159 modules/ts/src/ts_arrtest.cpp             unsigned t = randInt(rng);
t                 164 modules/ts/src/ts_arrtest.cpp             is_image = !cvmat_allowed ? true : iplimage_allowed ? (t & 1) != 0 : false;
t                 165 modules/ts/src/ts_arrtest.cpp             create_mask = (t & 6) == 0; // ~ each of 3 tests will use mask
t                 166 modules/ts/src/ts_arrtest.cpp             use_roi = (t & 8) != 0;
t                1824 modules/ts/src/ts_perf.cpp TestBase::_declareHelper::_declareHelper(TestBase* t) : test(t)
t                1889 modules/ts/src/ts_perf.cpp void PrintTo(const MatType& t, ::std::ostream* os)
t                1891 modules/ts/src/ts_perf.cpp     switch( CV_MAT_DEPTH((int)t) )
t                1903 modules/ts/src/ts_perf.cpp     *os << 'C' << CV_MAT_CN((int)t);
t                 438 modules/video/src/ecc.cpp     filter2D(imageFloat, gradientY, -1, dx.t());
t                 116 modules/video/src/kalman.cpp     gain = temp4.t();
t                 427 modules/video/src/optflowgf.cpp         float t = (float)std::exp(-i*i/(2*sigma*sigma) );
t                 428 modules/video/src/optflowgf.cpp         kernel[i] = t;
t                 429 modules/video/src/optflowgf.cpp         s += t*2;
t                 107 modules/video/test/test_camshift.cpp         int t;
t                 108 modules/video/test/test_camshift.cpp         CV_SWAP( min_log_size, max_log_size, t );
t                 167 modules/video/test/test_camshift.cpp         float t;
t                 168 modules/video/test/test_camshift.cpp         CV_SWAP( box0.size.width, box0.size.height, t );
t                 120 modules/video/test/test_estimaterigid.cpp                 Mat B = A - repeat(A.row(0), 3, 1), Bt = B.t();
t                 101 modules/video/test/test_kalman.cpp             float t = 0;
t                 104 modules/video/test/test_kalman.cpp                 t += Dyn.data.fl[j*Dim+k]*Sample->data.fl[k];
t                 106 modules/video/test/test_kalman.cpp             Temp->data.fl[j]= (float)(t+(cvtest::randReal(rng)*2-1)*max_noise);
t                1069 modules/videoio/src/cap_gphoto2.cpp             float f, t, b, s;
t                1070 modules/videoio/src/cap_gphoto2.cpp             CR(gp_widget_get_range(widget, &b, &t, &s));
t                1072 modules/videoio/src/cap_gphoto2.cpp             os << "(" << b << ":" << t << ":" << s << "):" << f << separator;
t                1078 modules/videoio/src/cap_gphoto2.cpp             int t;
t                1079 modules/videoio/src/cap_gphoto2.cpp             CR(gp_widget_get_value(widget, &t));
t                1080 modules/videoio/src/cap_gphoto2.cpp             os << t << separator;
t                1120 modules/videoio/src/cap_gphoto2.cpp             int t;
t                1124 modules/videoio/src/cap_gphoto2.cpp             CR(gp_widget_get_value(widget, &t));
t                1125 modules/videoio/src/cap_gphoto2.cpp             xtime = t;
t                1128 modules/videoio/src/cap_gphoto2.cpp             os << t << ":" << timebuf << separator;
t                 124 modules/videoio/src/cap_pvapi.cpp     struct timespec t,r;
t                 126 modules/videoio/src/cap_pvapi.cpp     t.tv_sec    = time / 1000;
t                 127 modules/videoio/src/cap_pvapi.cpp     t.tv_nsec   = (time % 1000) * 1000000;
t                 129 modules/videoio/src/cap_pvapi.cpp     while(nanosleep(&t,&r)==-1)
t                 130 modules/videoio/src/cap_pvapi.cpp         t = r;
t                 159 modules/videoio/src/cap_winrt/CaptureFrameGrabber.cpp     task_completion_event<ComPtr<IMF2DBuffer2>> t;
t                 164 modules/videoio/src/cap_winrt/CaptureFrameGrabber.cpp         t = _videoSampleRequestQueue.front();
t                 172 modules/videoio/src/cap_winrt/CaptureFrameGrabber.cpp     t.set(As<IMF2DBuffer2>(buffer));
t                 522 modules/videoio/src/cap_xine.cpp static int icvSeekTimeAVI_XINE( CvCaptureAVI_XINE* capture, int t )
t                 546 modules/videoio/src/cap_xine.cpp         if ( xine_play( capture->stream, 0, t ) )
t                 548 modules/videoio/src/cap_xine.cpp             capture->frame_number = ( int ) ( ( float ) t * capture->frame_rate / 1000 );
t                 564 modules/videoio/src/cap_xine.cpp         int new_frame = ( int ) ( ( float ) t * capture->frame_rate / 1000 );
t                3641 modules/videoio/src/ppltasks_winrt.hpp         return[=](_Type t, _Unit_type* retVal) -> HRESULT { HRESULT hr = _Func(t); *retVal = _Unit_type(); return hr;  };
t                 167 modules/videostab/src/motion_stabilizing.cpp     for (int t = 0; t < N-1; ++t, c += 6)
t                 193 modules/videostab/src/motion_stabilizing.cpp     for (int t = 0; t < N-2; ++t, c += 6)
t                 219 modules/videostab/src/motion_stabilizing.cpp     for (int t = 0; t < N-3; ++t, c += 6)
t                 256 modules/videostab/src/motion_stabilizing.cpp     for (int t = 0; t < N; ++t)
t                 258 modules/videostab/src/motion_stabilizing.cpp         c = 4*t;
t                 273 modules/videostab/src/motion_stabilizing.cpp     for (int t = 0; t < N-1; ++t, r += 6)
t                 275 modules/videostab/src/motion_stabilizing.cpp         Mat_<float> M0 = at(t,M);
t                 277 modules/videostab/src/motion_stabilizing.cpp         c = 4*t;
t                 285 modules/videostab/src/motion_stabilizing.cpp         c = 4*(t+1);
t                 293 modules/videostab/src/motion_stabilizing.cpp         c = 4*N + 6*t;
t                 306 modules/videostab/src/motion_stabilizing.cpp     for (int t = 0; t < N-1; ++t, r += 6)
t                 308 modules/videostab/src/motion_stabilizing.cpp         Mat_<float> M0 = at(t,M);
t                 310 modules/videostab/src/motion_stabilizing.cpp         c = 4*t;
t                 318 modules/videostab/src/motion_stabilizing.cpp         c = 4*(t+1);
t                 326 modules/videostab/src/motion_stabilizing.cpp         c = 4*N + 6*t;
t                 339 modules/videostab/src/motion_stabilizing.cpp     for (int t = 0; t < N-2; ++t, r += 6)
t                 341 modules/videostab/src/motion_stabilizing.cpp         Mat_<float> M0 = at(t,M), M1 = at(t+1,M);
t                 343 modules/videostab/src/motion_stabilizing.cpp         c = 4*t;
t                 351 modules/videostab/src/motion_stabilizing.cpp         c = 4*(t+1);
t                 359 modules/videostab/src/motion_stabilizing.cpp         c = 4*(t+2);
t                 367 modules/videostab/src/motion_stabilizing.cpp         c = 4*N + 6*(N-1) + 6*t;
t                 380 modules/videostab/src/motion_stabilizing.cpp     for (int t = 0; t < N-2; ++t, r += 6)
t                 382 modules/videostab/src/motion_stabilizing.cpp         Mat_<float> M0 = at(t,M), M1 = at(t+1,M);
t                 384 modules/videostab/src/motion_stabilizing.cpp         c = 4*t;
t                 392 modules/videostab/src/motion_stabilizing.cpp         c = 4*(t+1);
t                 400 modules/videostab/src/motion_stabilizing.cpp         c = 4*(t+2);
t                 408 modules/videostab/src/motion_stabilizing.cpp         c = 4*N + 6*(N-1) + 6*t;
t                 421 modules/videostab/src/motion_stabilizing.cpp     for (int t = 0; t < N-3; ++t, r += 6)
t                 423 modules/videostab/src/motion_stabilizing.cpp         Mat_<float> M0 = at(t,M), M1 = at(t+1,M), M2 = at(t+2,M);
t                 425 modules/videostab/src/motion_stabilizing.cpp         c = 4*t;
t                 433 modules/videostab/src/motion_stabilizing.cpp         c = 4*(t+1);
t                 441 modules/videostab/src/motion_stabilizing.cpp         c = 4*(t+2);
t                 449 modules/videostab/src/motion_stabilizing.cpp         c = 4*(t+3);
t                 457 modules/videostab/src/motion_stabilizing.cpp         c = 4*N + 6*(N-1) + 6*(N-2) + 6*t;
t                 470 modules/videostab/src/motion_stabilizing.cpp     for (int t = 0; t < N-3; ++t, r += 6)
t                 472 modules/videostab/src/motion_stabilizing.cpp         Mat_<float> M0 = at(t,M), M1 = at(t+1,M), M2 = at(t+2,M);
t                 474 modules/videostab/src/motion_stabilizing.cpp         c = 4*t;
t                 482 modules/videostab/src/motion_stabilizing.cpp         c = 4*(t+1);
t                 490 modules/videostab/src/motion_stabilizing.cpp         c = 4*(t+2);
t                 498 modules/videostab/src/motion_stabilizing.cpp         c = 4*(t+3);
t                 506 modules/videostab/src/motion_stabilizing.cpp         c = 4*N + 6*(N-1) + 6*(N-2) + 6*t;
t                 556 modules/videostab/src/motion_stabilizing.cpp     for (int t = 0; t < N; ++t, c += 4)
t                 564 modules/videostab/src/motion_stabilizing.cpp         S[t] = S0;
t                 625 modules/videostab/src/motion_stabilizing.cpp static inline void relaxMotion(const float M[], float t, float res[])
t                 627 modules/videostab/src/motion_stabilizing.cpp     res[0] = M[0]*(1.f-t) + t;
t                 628 modules/videostab/src/motion_stabilizing.cpp     res[1] = M[1]*(1.f-t);
t                 629 modules/videostab/src/motion_stabilizing.cpp     res[2] = M[2]*(1.f-t);
t                 630 modules/videostab/src/motion_stabilizing.cpp     res[3] = M[3]*(1.f-t);
t                 631 modules/videostab/src/motion_stabilizing.cpp     res[4] = M[4]*(1.f-t) + t;
t                 632 modules/videostab/src/motion_stabilizing.cpp     res[5] = M[5]*(1.f-t);
t                 633 modules/videostab/src/motion_stabilizing.cpp     res[6] = M[6]*(1.f-t);
t                 634 modules/videostab/src/motion_stabilizing.cpp     res[7] = M[7]*(1.f-t);
t                 635 modules/videostab/src/motion_stabilizing.cpp     res[8] = M[8]*(1.f-t) + t;
t                 653 modules/videostab/src/motion_stabilizing.cpp     float t = 0;
t                 654 modules/videostab/src/motion_stabilizing.cpp     relaxMotion(srcM, t, curM);
t                 661 modules/videostab/src/motion_stabilizing.cpp         t = (l + r) * 0.5f;
t                 662 modules/videostab/src/motion_stabilizing.cpp         relaxMotion(srcM, t, curM);
t                 664 modules/videostab/src/motion_stabilizing.cpp             r = t;
t                 666 modules/videostab/src/motion_stabilizing.cpp             l = t;
t                 698 modules/videostab/src/motion_stabilizing.cpp         float t = (l + r) * 0.5f;
t                 699 modules/videostab/src/motion_stabilizing.cpp         float dx = floor(w * t);
t                 700 modules/videostab/src/motion_stabilizing.cpp         float dy = floor(h * t);
t                 706 modules/videostab/src/motion_stabilizing.cpp             r = t;
t                 708 modules/videostab/src/motion_stabilizing.cpp             l = t;
t                  75 modules/viz/src/vtk/vtkTrajectorySource.cpp         Matx33d R = dpath->rotation().t();  // transposed because of
t                 226 samples/cpp/calibration.cpp             Mat t = bigmat(Range(i, i+1), Range(3,6));
t                 231 samples/cpp/calibration.cpp             r = rvecs[i].t();
t                 232 samples/cpp/calibration.cpp             t = tvecs[i].t();
t                  33 samples/cpp/delaunay2.cpp         Vec6f t = triangleList[i];
t                  34 samples/cpp/delaunay2.cpp         pt[0] = Point(cvRound(t[0]), cvRound(t[1]));
t                  35 samples/cpp/delaunay2.cpp         pt[1] = Point(cvRound(t[2]), cvRound(t[3]));
t                  36 samples/cpp/delaunay2.cpp         pt[2] = Point(cvRound(t[4]), cvRound(t[5]));
t                 203 samples/cpp/facedetect.cpp     double t = 0;
t                 219 samples/cpp/facedetect.cpp     t = (double)cvGetTickCount();
t                 242 samples/cpp/facedetect.cpp     t = (double)cvGetTickCount() - t;
t                 243 samples/cpp/facedetect.cpp     printf( "detection time = %g ms\n", t/((double)cvGetTickFrequency()*1000.) );
t                  76 samples/cpp/logistic_regression.cpp     imshow(name, bigImage.t());
t                 156 samples/cpp/logistic_regression.cpp     cout << labels_test.t() << endl;
t                 157 samples/cpp/logistic_regression.cpp     cout << responses.t() << endl;
t                 176 samples/cpp/logistic_regression.cpp     cout << labels_test.t() << endl;
t                 177 samples/cpp/logistic_regression.cpp     cout << responses2.t() << endl;
t                  54 samples/cpp/openni_capture.cpp             float t = V * (1 - (1 - f) * S);
t                  59 samples/cpp/openni_capture.cpp                 res = Point3f( p, t, V );
t                  63 samples/cpp/openni_capture.cpp                 res = Point3f( t, V, p );
t                  67 samples/cpp/openni_capture.cpp                 res = Point3f( V, p, t );
t                 267 samples/cpp/stereo_match.cpp     int64 t = getTickCount();
t                 272 samples/cpp/stereo_match.cpp     t = getTickCount() - t;
t                 273 samples/cpp/stereo_match.cpp     printf("Time elapsed: %fms\n", t*1000/getTickFrequency());
t                 381 samples/cpp/stitching_detailed.cpp     int64 t = getTickCount();
t                 454 samples/cpp/stitching_detailed.cpp     LOGLN("Finding features, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
t                 458 samples/cpp/stitching_detailed.cpp     t = getTickCount();
t                 474 samples/cpp/stitching_detailed.cpp     LOGLN("Pairwise matching, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
t                 574 samples/cpp/stitching_detailed.cpp     t = getTickCount();
t                 664 samples/cpp/stitching_detailed.cpp     LOGLN("Warping images, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
t                 712 samples/cpp/stitching_detailed.cpp     t = getTickCount();
t                 841 samples/cpp/stitching_detailed.cpp         LOGLN("Compositing, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
t                  52 samples/cpp/tutorial_code/HighGUI/GDAL_IO/gdal-image.cpp cv::Point2d lerp( cv::Point2d const& p1, cv::Point2d const& p2, const double& t ){
t                  53 samples/cpp/tutorial_code/HighGUI/GDAL_IO/gdal-image.cpp     return cv::Point2d( ((1-t)*p1.x) + (t*p2.x),
t                  54 samples/cpp/tutorial_code/HighGUI/GDAL_IO/gdal-image.cpp                         ((1-t)*p1.y) + (t*p2.y));
t                  63 samples/cpp/tutorial_code/HighGUI/GDAL_IO/gdal-image.cpp                           double const& t ){
t                  67 samples/cpp/tutorial_code/HighGUI/GDAL_IO/gdal-image.cpp         output[i] = (uchar)(((1-t)*minColor[i]) + (t * maxColor[i]));
t                  88 samples/cpp/tutorial_code/HighGUI/GDAL_IO/gdal-image.cpp     double t = 0;
t                  95 samples/cpp/tutorial_code/HighGUI/GDAL_IO/gdal-image.cpp             t = (color_range[x+1].second - elevation)/
t                 103 samples/cpp/tutorial_code/HighGUI/GDAL_IO/gdal-image.cpp     return lerp( color_range[idx].first, color_range[idx+1].first, t);
t                  97 samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp       float r = s_lines[i][0], t = s_lines[i][1];
t                  98 samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp       double cos_t = cos(t), sin_t = sin(t);
t                 539 samples/cpp/tutorial_code/calib3d/camera_calibration/camera_calibration.cpp             Mat t = bigmat(Range(int(i), int(i+1)), Range(3,6));
t                 544 samples/cpp/tutorial_code/calib3d/camera_calibration/camera_calibration.cpp             r = rvecs[i].t();
t                 545 samples/cpp/tutorial_code/calib3d/camera_calibration/camera_calibration.cpp             t = tvecs[i].t();
t                 268 samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/PnPProblem.cpp   double t;
t                 309 samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/PnPProblem.cpp   t = DOT(e2, Q) * inv_det;
t                 311 samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/PnPProblem.cpp   if(t > EPSILON) { //ray intersection
t                 312 samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/PnPProblem.cpp     *out = t;
t                 173 samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Utils.cpp double get_translation_error(const cv::Mat &t_true, const cv::Mat &t)
t                 175 samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Utils.cpp   return cv::norm( t_true - t );
t                  49 samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Utils.h double get_translation_error(const cv::Mat &t_true, const cv::Mat &t);
t                  67 samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp     double t;
t                  69 samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp     t = (double)getTickCount();
t                  77 samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp     t = 1000*((double)getTickCount() - t)/getTickFrequency();
t                  78 samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp     t /= times;
t                  81 samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp          << times << " runs): " << t << " milliseconds."<< endl;
t                  83 samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp     t = (double)getTickCount();
t                  91 samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp     t = 1000*((double)getTickCount() - t)/getTickFrequency();
t                  92 samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp     t /= times;
t                  95 samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp         << times << " runs): " << t << " milliseconds."<< endl;
t                  97 samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp     t = (double)getTickCount();
t                 105 samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp     t = 1000*((double)getTickCount() - t)/getTickFrequency();
t                 106 samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp     t /= times;
t                 109 samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp         << times << " runs): " << t << " milliseconds."<< endl;
t                 118 samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp     t = (double)getTickCount();
t                 125 samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp     t = 1000*((double)getTickCount() - t)/getTickFrequency();
t                 126 samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp     t /= times;
t                 129 samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp         << times << " runs): " << t << " milliseconds."<< endl;
t                  39 samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp     double t = (double)getTickCount();
t                  43 samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp     t = ((double)getTickCount() - t)/getTickFrequency();
t                  44 samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp     cout << "Hand written function times passed in seconds: " << t << endl;
t                  52 samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp     t = (double)getTickCount();
t                  54 samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp     t = ((double)getTickCount() - t)/getTickFrequency();
t                  55 samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp     cout << "Built-in filter2D time passed in seconds:      " << t << endl;
t                 189 samples/cpp/ufacedetect.cpp     double t = 0, scale=1;
t                 204 samples/cpp/ufacedetect.cpp     t = (double)getTickCount();
t                 232 samples/cpp/ufacedetect.cpp     t = (double)getTickCount() - t;
t                 235 samples/cpp/ufacedetect.cpp     double fps = getTickFrequency()/t;
t                 112 samples/cpp/watershed.cpp             double t = (double)getTickCount();
t                 114 samples/cpp/watershed.cpp             t = (double)getTickCount() - t;
t                 115 samples/cpp/watershed.cpp             printf( "execution time = %gms\n", t*1000./getTickFrequency() );
t                  79 samples/gpu/farneback_optical_flow.cpp     int64 t, t0=0, t1=1, tc0, tc1;
t                  85 samples/gpu/farneback_optical_flow.cpp         t = getTickCount();
t                 134 samples/gpu/farneback_optical_flow.cpp         t0 = t;
t                  39 samples/winrt/ImageManipulations/MediaExtensions/Common/LinkList.h     void operator()(T& t)