1 /*M/////////////////////////////////////////////////////////////////////////////////////// 2 // 3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 // 5 // By downloading, copying, installing or using the software you agree to this license. 6 // If you do not agree to this license, do not download, install, 7 // copy or use the software. 8 // 9 // 10 // Intel License Agreement 11 // For Open Source Computer Vision Library 12 // 13 // Copyright (C) 2000, Intel Corporation, all rights reserved. 14 // Third party copyrights are property of their respective owners. 15 // 16 // Redistribution and use in source and binary forms, with or without modification, 17 // are permitted provided that the following conditions are met: 18 // 19 // * Redistribution's of source code must retain the above copyright notice, 20 // this list of conditions and the following disclaimer. 21 // 22 // * Redistribution's in binary form must reproduce the above copyright notice, 23 // this list of conditions and the following disclaimer in the documentation 24 // and/or other materials provided with the distribution. 25 // 26 // * The name of Intel Corporation may not be used to endorse or promote products 27 // derived from this software without specific prior written permission. 28 // 29 // This software is provided by the copyright holders and contributors "as is" and 30 // any express or implied warranties, including, but not limited to, the implied 31 // warranties of merchantability and fitness for a particular purpose are disclaimed. 32 // In no event shall the Intel Corporation or contributors be liable for any direct, 33 // indirect, incidental, special, exemplary, or consequential damages 34 // (including, but not limited to, procurement of substitute goods or services; 35 // loss of use, data, or profits; or business interruption) however caused 36 // and on any theory of liability, whether in contract, strict liability, 37 // or tort (including negligence or otherwise) arising in any way out of 38 // the use of this software, even if advised of the possibility of such damage. 39 // 40 //M*/ 41 42 #include "_cvaux.h" 43 44 // temporarily remove it from build 45 #if 0 && ((_MSC_VER>=1200) || defined __BORLANDC__) 46 47 double CvMAT::get( const uchar* ptr, int type, int coi ) 48 { 49 double t = 0; 50 assert( (unsigned)coi < (unsigned)CV_MAT_CN(type) ); 51 52 switch( CV_MAT_DEPTH(type) ) 53 { 54 case CV_8U: 55 t = ((uchar*)ptr)[coi]; 56 break; 57 case CV_8S: 58 t = ((char*)ptr)[coi]; 59 break; 60 case CV_16S: 61 t = ((short*)ptr)[coi]; 62 break; 63 case CV_32S: 64 t = ((int*)ptr)[coi]; 65 break; 66 case CV_32F: 67 t = ((float*)ptr)[coi]; 68 break; 69 case CV_64F: 70 t = ((double*)ptr)[coi]; 71 break; 72 } 73 74 return t; 75 } 76 77 void CvMAT::set( uchar* ptr, int type, int coi, double d ) 78 { 79 int i; 80 assert( (unsigned)coi < (unsigned)CV_MAT_CN(type) ); 81 82 switch( CV_MAT_DEPTH(type)) 83 { 84 case CV_8U: 85 i = cvRound(d); 86 ((uchar*)ptr)[coi] = CV_CAST_8U(i); 87 break; 88 case CV_8S: 89 i = cvRound(d); 90 ((char*)ptr)[coi] = CV_CAST_8S(i); 91 break; 92 case CV_16S: 93 i = cvRound(d); 94 ((short*)ptr)[coi] = CV_CAST_16S(i); 95 break; 96 case CV_32S: 97 i = cvRound(d); 98 ((int*)ptr)[coi] = CV_CAST_32S(i); 99 break; 100 case CV_32F: 101 ((float*)ptr)[coi] = (float)d; 102 break; 103 case CV_64F: 104 ((double*)ptr)[coi] = d; 105 break; 106 } 107 } 108 109 110 void CvMAT::set( uchar* ptr, int type, int coi, int i ) 111 { 112 assert( (unsigned)coi < (unsigned)CV_MAT_CN(type) ); 113 114 switch( CV_MAT_DEPTH(type)) 115 { 116 case CV_8U: 117 ((uchar*)ptr)[coi] = CV_CAST_8U(i); 118 break; 119 case CV_8S: 120 ((char*)ptr)[coi] = CV_CAST_8S(i); 121 break; 122 case CV_16S: 123 ((short*)ptr)[coi] = CV_CAST_16S(i); 124 break; 125 case CV_32S: 126 ((int*)ptr)[coi] = i; 127 break; 128 case CV_32F: 129 ((float*)ptr)[coi] = (float)i; 130 break; 131 case CV_64F: 132 ((double*)ptr)[coi] = (double)i; 133 break; 134 } 135 } 136 137 138 void CvMAT::set( uchar* ptr, int type, double d ) 139 { 140 int i, cn = CV_MAT_CN(type); 141 142 switch( CV_MAT_DEPTH(type)) 143 { 144 case CV_8U: 145 i = cvRound(d); 146 ((uchar*)ptr)[0] = CV_CAST_8U(i); 147 i = cn; 148 while( --i ) ((uchar*)ptr)[i] = 0; 149 break; 150 case CV_8S: 151 i = cvRound(d); 152 ((char*)ptr)[0] = CV_CAST_8S(i); 153 i = cn; 154 while( --i ) ((char*)ptr)[i] = 0; 155 break; 156 case CV_16S: 157 i = cvRound(d); 158 ((short*)ptr)[0] = CV_CAST_16S(i); 159 i = cn; 160 while( --i ) ((short*)ptr)[i] = 0; 161 break; 162 case CV_32S: 163 i = cvRound(d); 164 ((int*)ptr)[0] = i; 165 i = cn; 166 while( --i ) ((int*)ptr)[i] = 0; 167 break; 168 case CV_32F: 169 ((float*)ptr)[0] = (float)d; 170 i = cn; 171 while( --i ) ((float*)ptr)[i] = 0; 172 break; 173 case CV_64F: 174 ((double*)ptr)[0] = d; 175 i = cn; 176 while( --i ) ((double*)ptr)[i] = 0; 177 break; 178 } 179 } 180 181 182 void CvMAT::set( uchar* ptr, int type, int i ) 183 { 184 int cn = CV_MAT_CN(type); 185 186 switch( CV_MAT_DEPTH(type)) 187 { 188 case CV_8U: 189 ((uchar*)ptr)[0] = CV_CAST_8U(i); 190 i = cn; 191 while( --i ) ((uchar*)ptr)[i] = 0; 192 break; 193 case CV_8S: 194 ((char*)ptr)[0] = CV_CAST_8S(i); 195 i = cn; 196 while( --i ) ((char*)ptr)[i] = 0; 197 break; 198 case CV_16S: 199 ((short*)ptr)[0] = CV_CAST_16S(i); 200 i = cn; 201 while( --i ) ((short*)ptr)[i] = 0; 202 break; 203 case CV_32S: 204 ((int*)ptr)[0] = i; 205 i = cn; 206 while( --i ) ((int*)ptr)[i] = 0; 207 break; 208 case CV_32F: 209 ((float*)ptr)[0] = (float)i; 210 i = cn; 211 while( --i ) ((float*)ptr)[i] = 0; 212 break; 213 case CV_64F: 214 ((double*)ptr)[0] = (double)i; 215 i = cn; 216 while( --i ) ((double*)ptr)[i] = 0; 217 break; 218 } 219 } 220 221 222 CvMAT::CvMAT( const _CvMAT_T_& mat_t ) 223 { 224 data.ptr = 0; 225 type = 0; 226 refcount = 0; 227 *this = mat_t; 228 } 229 230 231 CvMAT::CvMAT( const _CvMAT_ADD_& mat_add ) 232 { 233 data.ptr = 0; 234 type = 0; 235 refcount = 0; 236 *this = mat_add; 237 } 238 239 240 CvMAT::CvMAT( const _CvMAT_ADD_EX_& mat_add ) 241 { 242 data.ptr = 0; 243 type = 0; 244 refcount = 0; 245 *this = mat_add; 246 } 247 248 249 CvMAT::CvMAT( const _CvMAT_SCALE_& scale_mat ) 250 { 251 data.ptr = 0; 252 type = 0; 253 refcount = 0; 254 *this = scale_mat; 255 } 256 257 258 CvMAT::CvMAT( const _CvMAT_SCALE_SHIFT_& scale_shift_mat ) 259 { 260 data.ptr = 0; 261 type = 0; 262 refcount = 0; 263 *this = scale_shift_mat; 264 } 265 266 267 CvMAT::CvMAT( const _CvMAT_MUL_& mmul ) 268 { 269 data.ptr = 0; 270 type = 0; 271 refcount = 0; 272 *this = mmul; 273 } 274 275 276 CvMAT::CvMAT( const _CvMAT_MUL_ADD_& mmuladd ) 277 { 278 data.ptr = 0; 279 type = 0; 280 refcount = 0; 281 *this = mmuladd; 282 } 283 284 285 CvMAT::CvMAT( const _CvMAT_INV_& inv_mat ) 286 { 287 data.ptr = 0; 288 type = 0; 289 refcount = 0; 290 *this = inv_mat; 291 } 292 293 294 CvMAT::CvMAT( const _CvMAT_NOT_& not_mat ) 295 { 296 type = 0; 297 data.ptr = 0; 298 refcount = 0; 299 *this = not_mat; 300 } 301 302 303 CvMAT::CvMAT( const _CvMAT_UN_LOGIC_& mat_logic ) 304 { 305 type = 0; 306 data.ptr = 0; 307 refcount = 0; 308 *this = mat_logic; 309 } 310 311 312 CvMAT::CvMAT( const _CvMAT_LOGIC_& mat_logic ) 313 { 314 type = 0; 315 data.ptr = 0; 316 refcount = 0; 317 *this = mat_logic; 318 } 319 320 321 CvMAT::CvMAT( const _CvMAT_COPY_& mat_copy ) 322 { 323 CvMAT* src = (CvMAT*)mat_copy.a; 324 create( src->height, src->width, src->type ); 325 cvCopy( src, this ); 326 } 327 328 329 CvMAT::CvMAT( const _CvMAT_CVT_& mat_cvt ) 330 { 331 type = 0; 332 data.ptr = 0; 333 refcount = 0; 334 *this = mat_cvt; 335 } 336 337 338 CvMAT::CvMAT( const _CvMAT_DOT_OP_& dot_op ) 339 { 340 data.ptr = 0; 341 type = 0; 342 refcount = 0; 343 *this = dot_op; 344 } 345 346 347 CvMAT::CvMAT( const _CvMAT_SOLVE_& solve_mat ) 348 { 349 type = 0; 350 data.ptr = 0; 351 refcount = 0; 352 *this = solve_mat; 353 } 354 355 356 CvMAT::CvMAT( const _CvMAT_CMP_& cmp_mat ) 357 { 358 type = 0; 359 data.ptr = 0; 360 refcount = 0; 361 *this = cmp_mat; 362 } 363 364 365 /****************************************************************************************\ 366 * CvMAT::operator = * 367 \****************************************************************************************/ 368 369 CvMAT& CvMAT::operator = ( const _CvMAT_T_& mat_t ) 370 { 371 CvMAT* src = (CvMAT*)&mat_t.a; 372 if( !data.ptr ) 373 { 374 create( src->width, src->height, src->type ); 375 } 376 377 cvTranspose( src, this ); 378 return *this; 379 } 380 381 382 CvMAT& CvMAT::operator = ( const _CvMAT_ADD_& mat_add ) 383 { 384 CvMAT* a = mat_add.a; 385 CvMAT* b = mat_add.b; 386 387 if( !data.ptr ) 388 { 389 create( a->height, a->width, a->type ); 390 } 391 392 if( mat_add.beta == 1 ) 393 { 394 cvAdd( a, b, this ); 395 return *this; 396 } 397 398 if( mat_add.beta == -1 ) 399 { 400 cvSub( a, b, this ); 401 return *this; 402 } 403 404 if( CV_MAT_DEPTH(a->type) >= CV_32F && CV_MAT_CN(a->type) <= 2 ) 405 cvScaleAdd( b, cvScalar(mat_add.beta), a, this ); 406 else 407 cvAddWeighted( a, 1, b, mat_add.beta, 0, this ); 408 return *this; 409 } 410 411 412 CvMAT& CvMAT::operator = ( const _CvMAT_ADD_EX_& mat_add ) 413 { 414 CvMAT* a = mat_add.a; 415 CvMAT* b = mat_add.b; 416 417 if( !data.ptr ) 418 { 419 create( a->height, a->width, a->type ); 420 } 421 422 cvAddWeighted( a, mat_add.alpha, b, mat_add.beta, mat_add.gamma, this ); 423 return *this; 424 } 425 426 427 CvMAT& CvMAT::operator = ( const _CvMAT_SCALE_& scale_mat ) 428 { 429 CvMAT* src = scale_mat.a; 430 431 if( !data.ptr ) 432 { 433 create( src->height, src->width, src->type ); 434 } 435 436 cvConvertScale( src, this, scale_mat.alpha, 0 ); 437 return *this; 438 } 439 440 441 CvMAT& CvMAT::operator = ( const _CvMAT_SCALE_SHIFT_& scale_shift_mat ) 442 { 443 CvMAT* src = scale_shift_mat.a; 444 445 if( !data.ptr ) 446 { 447 create( src->height, src->width, src->type ); 448 } 449 450 cvConvertScale( src, this, scale_shift_mat.alpha, scale_shift_mat.beta ); 451 return *this; 452 } 453 454 455 CvMAT& CvMAT::operator = ( const _CvMAT_MUL_& mmul ) 456 { 457 CvMAT* a = mmul.a; 458 CvMAT* b = mmul.b; 459 int t_a = mmul.t_ab & 1; 460 int t_b = (mmul.t_ab & 2) != 0; 461 int m = (&(a->rows))[t_a]; 462 int n = (&(b->rows))[t_b ^ 1]; 463 /* this(m x n) = (a^o1(t))(m x l) * (b^o2(t))(l x n) */ 464 465 if( !data.ptr ) 466 { 467 create( m, n, a->type ); 468 } 469 470 if( mmul.alpha == 1 ) 471 { 472 if( mmul.t_ab == 0 ) 473 { 474 cvMatMulAdd( a, b, 0, this ); 475 return *this; 476 } 477 478 if( a->data.ptr == b->data.ptr && mmul.t_ab < 3 && 479 a->rows == b->rows && a->cols == b->cols && 480 a->data.ptr != data.ptr ) 481 { 482 cvMulTransposed( a, this, mmul.t_ab & 1 ); 483 return *this; 484 } 485 } 486 487 cvGEMM( a, b, mmul.alpha, 0, 0, this, mmul.t_ab ); 488 return *this; 489 } 490 491 492 CvMAT& CvMAT::operator = ( const _CvMAT_MUL_ADD_& mmuladd ) 493 { 494 CvMAT* a = mmuladd.a; 495 CvMAT* b = mmuladd.b; 496 CvMAT* c = mmuladd.c; 497 int t_a = mmuladd.t_abc & 1; 498 int t_b = (mmuladd.t_abc & 2) != 0; 499 int m = (&(a->rows))[t_a]; 500 int n = (&(b->rows))[t_b ^ 1]; 501 /* this(m x n) = (a^o1(t))(m x l) * (b^o2(t))(l x n) */ 502 503 if( !data.ptr ) 504 { 505 create( m, n, a->type ); 506 } 507 508 if( mmuladd.t_abc == 0 && mmuladd.alpha == 1 && mmuladd.beta == 1 ) 509 cvMatMulAdd( a, b, c, this ); 510 else 511 cvGEMM( a, b, mmuladd.alpha, c, mmuladd.beta, this, mmuladd.t_abc ); 512 return *this; 513 } 514 515 516 CvMAT& CvMAT::operator = ( const _CvMAT_INV_& inv_mat ) 517 { 518 CvMAT* src = (CvMAT*)&inv_mat.a; 519 520 if( !data.ptr ) 521 { 522 create( src->height, src->width, src->type ); 523 } 524 525 if( inv_mat.method == 0 ) 526 cvInvert( src, this ); 527 else 528 cvPseudoInv( src, this ); 529 return *this; 530 } 531 532 533 CvMAT& CvMAT::operator = ( const _CvMAT_NOT_& not_mat ) 534 { 535 CvMAT* src = not_mat.a; 536 537 if( !data.ptr ) 538 { 539 create( src->height, src->width, src->type ); 540 } 541 542 cvNot( src, this ); 543 return *this; 544 } 545 546 547 CvMAT& CvMAT::operator = ( const _CvMAT_LOGIC_& mat_logic ) 548 { 549 CvMAT* a = mat_logic.a; 550 CvMAT* b = mat_logic.b; 551 int flags = mat_logic.flags; 552 _CvMAT_LOGIC_::Op op = mat_logic.op; 553 554 if( !data.ptr ) 555 { 556 create( a->height, a->width, a->type ); 557 } 558 559 switch( op ) 560 { 561 case _CvMAT_LOGIC_::AND: 562 563 if( flags == 0 ) 564 cvAnd( a, b, this ); 565 else if( flags == 3 ) 566 { 567 cvOr( a, b, this ); 568 cvNot( this, this ); 569 } 570 else if( flags == 1 ) 571 { 572 if( data.ptr == b->data.ptr ) 573 { 574 cvNot( b, this ); 575 cvOr( this, a, this ); 576 cvNot( this, this ); 577 } 578 else 579 { 580 cvNot( a, this ); 581 cvAnd( this, b, this ); 582 } 583 } 584 else 585 { 586 if( data.ptr == a->data.ptr ) 587 { 588 cvNot( a, this ); 589 cvOr( this, b, this ); 590 cvNot( this, this ); 591 } 592 else 593 { 594 cvNot( b, this ); 595 cvAnd( this, a, this ); 596 } 597 } 598 break; 599 600 case _CvMAT_LOGIC_::OR: 601 602 if( flags == 0 ) 603 cvOr( a, b, this ); 604 else if( flags == 3 ) 605 { 606 cvAnd( a, b, this ); 607 cvNot( this, this ); 608 } 609 else if( flags == 1 ) 610 { 611 if( data.ptr == b->data.ptr ) 612 { 613 cvNot( b, this ); 614 cvAnd( this, a, this ); 615 cvNot( this, this ); 616 } 617 else 618 { 619 cvNot( a, this ); 620 cvOr( this, b, this ); 621 } 622 } 623 else 624 { 625 if( data.ptr == a->data.ptr ) 626 { 627 cvNot( a, this ); 628 cvAnd( this, b, this ); 629 cvNot( this, this ); 630 } 631 else 632 { 633 cvNot( b, this ); 634 cvOr( this, a, this ); 635 } 636 } 637 break; 638 639 case _CvMAT_LOGIC_::XOR: 640 641 cvXor( a, b, this ); 642 if( flags == 1 || flags == 2 ) 643 cvNot( this, this ); 644 break; 645 } 646 647 return *this; 648 } 649 650 651 CvMAT& CvMAT::operator = ( const _CvMAT_UN_LOGIC_& mat_logic ) 652 { 653 CvMAT* a = mat_logic.a; 654 CvScalar scalar = cvScalarAll( mat_logic.alpha ); 655 int flags = mat_logic.flags; 656 _CvMAT_LOGIC_::Op op = mat_logic.op; 657 658 if( !data.ptr ) 659 { 660 create( a->height, a->width, a->type ); 661 } 662 663 switch( op ) 664 { 665 case _CvMAT_LOGIC_::AND: 666 667 if( flags == 0 ) 668 cvAndS( a, scalar, this ); 669 else 670 { 671 cvNot( a, this ); 672 cvAndS( this, scalar, this ); 673 } 674 break; 675 676 case _CvMAT_LOGIC_::OR: 677 678 if( flags == 0 ) 679 cvOrS( a, scalar, this ); 680 else 681 { 682 cvNot( a, this ); 683 cvOrS( this, scalar, this ); 684 } 685 break; 686 687 case _CvMAT_LOGIC_::XOR: 688 689 if( flags == 0 ) 690 cvXorS( a, scalar, this ); 691 else 692 cvXorS( a, ~scalar, this ); 693 break; 694 } 695 696 return *this; 697 } 698 699 700 CvMAT& CvMAT::operator = ( const _CvMAT_COPY_& mat_copy ) 701 { 702 CvMAT* src = (CvMAT*)mat_copy.a; 703 704 if( !data.ptr ) 705 { 706 create( src->height, src->width, src->type ); 707 } 708 709 if( src != this ) 710 cvCopy( src, this ); 711 712 return *this; 713 } 714 715 716 CvMAT& CvMAT::operator = ( const _CvMAT_CVT_& mat_cvt ) 717 { 718 CvMAT* src = (CvMAT*)&mat_cvt.a; 719 720 if( !data.ptr ) 721 { 722 int depth = mat_cvt.newdepth; 723 create( src->height, src->width, depth < 0 ? src->type : 724 CV_MAT_CN(src->type)|CV_MAT_DEPTH(depth)); 725 } 726 727 cvCvtScale( src, this, mat_cvt.scale, mat_cvt.shift ); 728 return *this; 729 } 730 731 732 CvMAT& CvMAT::operator = ( const _CvMAT_DOT_OP_& dot_op ) 733 { 734 CvMAT* a = (CvMAT*)&(dot_op.a); 735 CvMAT* b = dot_op.b; 736 737 if( !data.ptr ) 738 { 739 create( a->height, a->width, a->type ); 740 } 741 742 switch( dot_op.op ) 743 { 744 case '*': 745 cvMul( a, b, this, dot_op.alpha ); 746 break; 747 case '/': 748 if( b != 0 ) 749 cvDiv( a, b, this, dot_op.alpha ); 750 else 751 cvDiv( 0, a, this, dot_op.alpha ); 752 break; 753 case 'm': 754 if( b != 0 ) 755 cvMin( a, b, this ); 756 else 757 cvMinS( a, dot_op.alpha, this ); 758 break; 759 case 'M': 760 if( b != 0 ) 761 cvMax( a, b, this ); 762 else 763 cvMaxS( a, dot_op.alpha, this ); 764 break; 765 case 'a': 766 if( b != 0 ) 767 cvAbsDiff( a, b, this ); 768 else 769 cvAbsDiffS( a, this, cvScalar(dot_op.alpha) ); 770 break; 771 default: 772 assert(0); 773 } 774 775 return *this; 776 } 777 778 779 CvMAT& CvMAT::operator = ( const _CvMAT_SOLVE_& solve_mat ) 780 { 781 CvMAT* a = (CvMAT*)(solve_mat.a); 782 CvMAT* b = (CvMAT*)(solve_mat.b); 783 784 if( !data.ptr ) 785 { 786 create( a->height, b->width, a->type ); 787 } 788 789 if( solve_mat.method == 0 ) 790 cvSolve( a, b, this ); 791 else 792 { 793 CvMAT temp; 794 cvInitMatHeader( &temp, a->cols, a->rows, a->type ); 795 cvCreateData( &temp ); 796 797 cvPseudoInv( a, &temp ); 798 cvMatMul( &temp, b, this ); 799 } 800 801 return *this; 802 } 803 804 805 CvMAT& CvMAT::operator = ( const _CvMAT_CMP_& mat_cmp ) 806 { 807 CvMAT* a = mat_cmp.a; 808 CvMAT* b = mat_cmp.b; 809 810 if( !data.ptr ) 811 { 812 create( a->height, a->width, CV_8UC1 ); 813 } 814 815 if( b ) 816 cvCmp( a, b, this, mat_cmp.cmp_op ); 817 else 818 cvCmpS( a, mat_cmp.alpha, this, mat_cmp.cmp_op ); 819 return *this; 820 } 821 822 823 /****************************************************************************************\ 824 * CvMAT I/O operations * 825 \****************************************************************************************/ 826 827 void CvMAT::write( const char* name, FILE* f, const char* fmt ) 828 { 829 int i, j, w = width * CV_MAT_CN(type); 830 FILE* out = f ? f : stdout; 831 832 if( name ) 833 fprintf( stdout, "%s(%d x %d) =\n\t", name, rows, cols ); 834 835 for( i = 0; i < rows; i++ ) 836 { 837 switch( CV_MAT_DEPTH(type)) 838 { 839 case CV_8U: if( !fmt ) 840 fmt = "%4d"; 841 for( j = 0; j < w; j++ ) 842 fprintf( out, fmt, ((uchar*)(data.ptr + i*step))[j] ); 843 break; 844 case CV_8S: if( !fmt ) 845 fmt = "%5d"; 846 for( j = 0; j < w; j++ ) 847 fprintf( out, fmt, ((char*)(data.ptr + i*step))[j] ); 848 break; 849 case CV_16S: if( !fmt ) 850 fmt = "%7d"; 851 for( j = 0; j < w; j++ ) 852 fprintf( out, fmt, ((short*)(data.ptr + i*step))[j] ); 853 break; 854 case CV_32S: if( !fmt ) 855 fmt = " %08x"; 856 for( j = 0; j < w; j++ ) 857 fprintf( out, fmt, ((int*)(data.ptr + i*step))[j] ); 858 break; 859 case CV_32F: if( !fmt ) 860 fmt = "%15g"; 861 for( j = 0; j < w; j++ ) 862 fprintf( out, fmt, ((float*)(data.ptr + i*step))[j] ); 863 break; 864 case CV_64F: if( !fmt ) 865 fmt = "%15g"; 866 for( j = 0; j < w; j++ ) 867 fprintf( out, fmt, ((double*)(data.ptr + i*step))[j] ); 868 break; 869 } 870 fprintf( out, "\n%s", i < rows - 1 ? "\t" : "" ); 871 } 872 fprintf( out, "\n" ); 873 } 874 875 #endif /* _MSC_VER || __BORLANDC__ */ 876 877 /* End of file. */ 878 879 880