git.maemo.org Git - opencv/blob - cv/src/cvmotempl.cpp

   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 "_cv.h"
  43
  44 IPCVAPI_IMPL( CvStatus, icvUpdateMotionHistory_8u32f_C1IR,
  45     (const uchar * silIm, int silStep, float *mhiIm, int mhiStep,
  46      CvSize size, float timestamp, float mhi_duration),
  47      (silIm, silStep, mhiIm, mhiStep, size, timestamp, mhi_duration) )
  48 {
  49     int x, y;
  50
  51     /* function processes floating-point images using integer arithmetics */
  52     Cv32suf v;
  53     int ts, delbound;
  54     int *mhi = (int *) mhiIm;
  55
  56     v.f = timestamp;
  57     ts = v.i;
  58
  59     if( !silIm || !mhiIm )
  60         return CV_NULLPTR_ERR;
  61
  62     if( size.height <= 0 || size.width <= 0 ||
  63         silStep < size.width || mhiStep < size.width * CV_SIZEOF_FLOAT ||
  64         (mhiStep & (CV_SIZEOF_FLOAT - 1)) != 0 )
  65         return CV_BADSIZE_ERR;
  66
  67     if( mhi_duration < 0 )
  68         return CV_BADFACTOR_ERR;
  69
  70     mhi_duration = timestamp - mhi_duration;
  71
  72     v.f = mhi_duration;
  73     delbound = CV_TOGGLE_FLT( v.i );
  74
  75     mhiStep /= sizeof(mhi[0]);
  76
  77     if( mhiStep == size.width && silStep == size.width )
  78     {
  79         size.width *= size.height;
  80         size.height = 1;
  81     }
  82
  83     if( delbound > 0 )
  84         for( y = 0; y < size.height; y++, silIm += silStep, mhi += mhiStep )
  85             for( x = 0; x < size.width; x++ )
  86             {
  87                 int val = mhi[x];
  88
  89                 /* val = silIm[x] ? ts : val < delbound ? 0 : val; */
  90                 val &= (val < delbound) - 1;
  91                 val ^= (ts ^ val) & ((silIm[x] == 0) - 1);
  92                 mhi[x] = val;
  93             }
  94     else
  95         for( y = 0; y < size.height; y++, silIm += silStep, mhi += mhiStep )
  96             for( x = 0; x < size.width; x++ )
  97             {
  98                 int val = mhi[x];
  99
 100                 /* val = silIm[x] ? ts : val < delbound ? 0 : val; */
 101                 val &= (CV_TOGGLE_FLT( val ) < delbound) - 1;
 102                 val ^= (ts ^ val) & ((silIm[x] == 0) - 1);
 103                 mhi[x] = val;
 104             }
 105
 106     return CV_OK;
 107 }
 108
 109
 110 /* motion templates */
 111 CV_IMPL void
 112 cvUpdateMotionHistory( const void* silhouette, void* mhimg,
 113                        double timestamp, double mhi_duration )
 114 {
 115     CvSize size;
 116     CvMat  silhstub, *silh = (CvMat*)silhouette;
 117     CvMat  mhistub, *mhi = (CvMat*)mhimg;
 118     int mhi_step, silh_step;
 119
 120     CV_FUNCNAME( "cvUpdateMHIByTime" );
 121
 122     __BEGIN__;
 123
 124     CV_CALL( silh = cvGetMat( silh, &silhstub ));
 125     CV_CALL( mhi = cvGetMat( mhi, &mhistub ));
 126
 127     if( !CV_IS_MASK_ARR( silh ))
 128         CV_ERROR( CV_StsBadMask, "" );
 129
 130     if( CV_MAT_CN( mhi->type ) > 1 )
 131         CV_ERROR( CV_BadNumChannels, "" );
 132
 133     if( CV_MAT_DEPTH( mhi->type ) != CV_32F )
 134         CV_ERROR( CV_BadDepth, "" );
 135
 136     if( !CV_ARE_SIZES_EQ( mhi, silh ))
 137         CV_ERROR( CV_StsUnmatchedSizes, "" );
 138
 139     size = cvGetMatSize( mhi );
 140
 141     mhi_step = mhi->step;
 142     silh_step = silh->step;
 143
 144     if( CV_IS_MAT_CONT( mhi->type & silh->type ))
 145     {
 146         size.width *= size.height;
 147         mhi_step = silh_step = CV_STUB_STEP;
 148         size.height = 1;
 149     }
 150
 151     IPPI_CALL( icvUpdateMotionHistory_8u32f_C1IR( (const uchar*)(silh->data.ptr), silh_step,
 152                                                   mhi->data.fl, mhi_step, size,
 153                                                   (float)timestamp, (float)mhi_duration ));
 154     __END__;
 155 }
 156
 157
 158 CV_IMPL void
 159 cvCalcMotionGradient( const CvArr* mhiimg, CvArr* maskimg,
 160                       CvArr* orientation,
 161                       double delta1, double delta2,
 162                       int aperture_size )
 163 {
 164     CvMat *dX_min = 0, *dY_max = 0;
 165     IplConvKernel* el = 0;
 166
 167     CV_FUNCNAME( "cvCalcMotionGradient" );
 168
 169     __BEGIN__;
 170
 171     CvMat  mhistub, *mhi = (CvMat*)mhiimg;
 172     CvMat  maskstub, *mask = (CvMat*)maskimg;
 173     CvMat  orientstub, *orient = (CvMat*)orientation;
 174     CvMat  dX_min_row, dY_max_row, orient_row, mask_row;
 175     CvSize size;
 176     int x, y;
 177
 178     float  gradient_epsilon = 1e-4f * aperture_size * aperture_size;
 179     float  min_delta, max_delta;
 180
 181     CV_CALL( mhi = cvGetMat( mhi, &mhistub ));
 182     CV_CALL( mask = cvGetMat( mask, &maskstub ));
 183     CV_CALL( orient = cvGetMat( orient, &orientstub ));
 184
 185     if( !CV_IS_MASK_ARR( mask ))
 186         CV_ERROR( CV_StsBadMask, "" );
 187
 188     if( aperture_size < 3 || aperture_size > 7 || (aperture_size & 1) == 0 )
 189         CV_ERROR( CV_StsOutOfRange, "aperture_size must be 3, 5 or 7" );
 190
 191     if( delta1 <= 0 || delta2 <= 0 )
 192         CV_ERROR( CV_StsOutOfRange, "both delta's must be positive" );
 193
 194     if( CV_MAT_TYPE( mhi->type ) != CV_32FC1 || CV_MAT_TYPE( orient->type ) != CV_32FC1 )
 195         CV_ERROR( CV_StsUnsupportedFormat,
 196         "MHI and orientation must be single-channel floating-point images" );
 197
 198     if( !CV_ARE_SIZES_EQ( mhi, mask ) || !CV_ARE_SIZES_EQ( orient, mhi ))
 199         CV_ERROR( CV_StsUnmatchedSizes, "" );
 200
 201     if( orient->data.ptr == mhi->data.ptr )
 202         CV_ERROR( CV_StsInplaceNotSupported, "orientation image must be different from MHI" );
 203
 204     if( delta1 > delta2 )
 205     {
 206         double t;
 207         CV_SWAP( delta1, delta2, t );
 208     }
 209
 210     size = cvGetMatSize( mhi );
 211     min_delta = (float)delta1;
 212     max_delta = (float)delta2;
 213     CV_CALL( dX_min = cvCreateMat( mhi->rows, mhi->cols, CV_32F ));
 214     CV_CALL( dY_max = cvCreateMat( mhi->rows, mhi->cols, CV_32F ));
 215
 216     /* calc Dx and Dy */
 217     CV_CALL( cvSobel( mhi, dX_min, 1, 0, aperture_size ));
 218     CV_CALL( cvSobel( mhi, dY_max, 0, 1, aperture_size ));
 219     cvGetRow( dX_min, &dX_min_row, 0 );
 220     cvGetRow( dY_max, &dY_max_row, 0 );
 221     cvGetRow( orient, &orient_row, 0 );
 222     cvGetRow( mask, &mask_row, 0 );
 223
 224     /* calc gradient */
 225     for( y = 0; y < size.height; y++ )
 226     {
 227         dX_min_row.data.ptr = dX_min->data.ptr + y*dX_min->step;
 228         dY_max_row.data.ptr = dY_max->data.ptr + y*dY_max->step;
 229         orient_row.data.ptr = orient->data.ptr + y*orient->step;
 230         mask_row.data.ptr = mask->data.ptr + y*mask->step;
 231         cvCartToPolar( &dX_min_row, &dY_max_row, 0, &orient_row, 1 );
 232
 233         /* make orientation zero where the gradient is very small */
 234         for( x = 0; x < size.width; x++ )
 235         {
 236             float dY = dY_max_row.data.fl[x];
 237             float dX = dX_min_row.data.fl[x];
 238
 239             if( fabs(dX) < gradient_epsilon && fabs(dY) < gradient_epsilon )
 240             {
 241                 mask_row.data.ptr[x] = 0;
 242                 orient_row.data.i[x] = 0;
 243             }
 244             else
 245                 mask_row.data.ptr[x] = 1;
 246         }
 247     }
 248
 249     CV_CALL( el = cvCreateStructuringElementEx( aperture_size, aperture_size,
 250                             aperture_size/2, aperture_size/2, CV_SHAPE_RECT ));
 251     cvErode( mhi, dX_min, el );
 252     cvDilate( mhi, dY_max, el );
 253
 254     /* mask off pixels which have little motion difference in their neighborhood */
 255     for( y = 0; y < size.height; y++ )
 256     {
 257         dX_min_row.data.ptr = dX_min->data.ptr + y*dX_min->step;
 258         dY_max_row.data.ptr = dY_max->data.ptr + y*dY_max->step;
 259         mask_row.data.ptr = mask->data.ptr + y*mask->step;
 260         orient_row.data.ptr = orient->data.ptr + y*orient->step;
 261
 262         for( x = 0; x < size.width; x++ )
 263         {
 264             float d0 = dY_max_row.data.fl[x] - dX_min_row.data.fl[x];
 265
 266             if( mask_row.data.ptr[x] == 0 || d0 < min_delta || max_delta < d0 )
 267             {
 268                 mask_row.data.ptr[x] = 0;
 269                 orient_row.data.i[x] = 0;
 270             }
 271         }
 272     }
 273
 274     __END__;
 275
 276     cvReleaseMat( &dX_min );
 277     cvReleaseMat( &dY_max );
 278     cvReleaseStructuringElement( &el );
 279 }
 280
 281
 282 CV_IMPL double
 283 cvCalcGlobalOrientation( const void* orientation, const void* maskimg, const void* mhiimg,
 284                          double curr_mhi_timestamp, double mhi_duration )
 285 {
 286     double  angle = 0;
 287     int hist_size = 12;
 288     CvHistogram* hist = 0;
 289
 290     CV_FUNCNAME( "cvCalcGlobalOrientation" );
 291
 292     __BEGIN__;
 293
 294     CvMat  mhistub, *mhi = (CvMat*)mhiimg;
 295     CvMat  maskstub, *mask = (CvMat*)maskimg;
 296     CvMat  orientstub, *orient = (CvMat*)orientation;
 297     void*  _orient;
 298     float _ranges[] = { 0, 360 };
 299     float* ranges = _ranges;
 300     int base_orient;
 301     double shift_orient = 0, shift_weight = 0, fbase_orient;
 302     double a, b;
 303     float delbound;
 304     CvMat mhi_row, mask_row, orient_row;
 305     int x, y, mhi_rows, mhi_cols;
 306
 307     CV_CALL( mhi = cvGetMat( mhi, &mhistub ));
 308     CV_CALL( mask = cvGetMat( mask, &maskstub ));
 309     CV_CALL( orient = cvGetMat( orient, &orientstub ));
 310
 311     if( !CV_IS_MASK_ARR( mask ))
 312         CV_ERROR( CV_StsBadMask, "" );
 313
 314     if( CV_MAT_TYPE( mhi->type ) != CV_32FC1 || CV_MAT_TYPE( orient->type ) != CV_32FC1 )
 315         CV_ERROR( CV_StsUnsupportedFormat,
 316         "MHI and orientation must be single-channel floating-point images" );
 317
 318     if( !CV_ARE_SIZES_EQ( mhi, mask ) || !CV_ARE_SIZES_EQ( orient, mhi ))
 319         CV_ERROR( CV_StsUnmatchedSizes, "" );
 320
 321     if( mhi_duration <= 0 )
 322         CV_ERROR( CV_StsOutOfRange, "MHI duration must be positive" );
 323
 324     if( orient->data.ptr == mhi->data.ptr )
 325         CV_ERROR( CV_StsInplaceNotSupported, "orientation image must be different from MHI" );
 326
 327     // calculate histogram of different orientation values
 328     CV_CALL( hist = cvCreateHist( 1, &hist_size, CV_HIST_ARRAY, &ranges ));
 329     _orient = orient;
 330     cvCalcArrHist( &_orient, hist, 0, mask );
 331
 332     // find the maximum index (the dominant orientation)
 333     cvGetMinMaxHistValue( hist, 0, 0, 0, &base_orient );
 334     base_orient *= 360/hist_size;
 335
 336     // override timestamp with the maximum value in MHI
 337     cvMinMaxLoc( mhi, 0, &curr_mhi_timestamp, 0, 0, mask );
 338
 339     // find the shift relative to the dominant orientation as weighted sum of relative angles
 340     a = 254. / 255. / mhi_duration;
 341     b = 1. - curr_mhi_timestamp * a;
 342     fbase_orient = base_orient;
 343     delbound = (float)(curr_mhi_timestamp - mhi_duration);
 344     mhi_rows = mhi->rows;
 345     mhi_cols = mhi->cols;
 346
 347     if( CV_IS_MAT_CONT( mhi->type & mask->type & orient->type ))
 348     {
 349         mhi_cols *= mhi_rows;
 350         mhi_rows = 1;
 351     }
 352
 353     cvGetRow( mhi, &mhi_row, 0 );
 354     cvGetRow( mask, &mask_row, 0 );
 355     cvGetRow( orient, &orient_row, 0 );
 356
 357     /*
 358        a = 254/(255*dt)
 359        b = 1 - t*a = 1 - 254*t/(255*dur) =
 360        (255*dt - 254*t)/(255*dt) =
 361        (dt - (t - dt)*254)/(255*dt);
 362        --------------------------------------------------------
 363        ax + b = 254*x/(255*dt) + (dt - (t - dt)*254)/(255*dt) =
 364        (254*x + dt - (t - dt)*254)/(255*dt) =
 365        ((x - (t - dt))*254 + dt)/(255*dt) =
 366        (((x - (t - dt))/dt)*254 + 1)/255 = (((x - low_time)/dt)*254 + 1)/255
 367      */
 368     for( y = 0; y < mhi_rows; y++ )
 369     {
 370         mhi_row.data.ptr = mhi->data.ptr + mhi->step*y;
 371         mask_row.data.ptr = mask->data.ptr + mask->step*y;
 372         orient_row.data.ptr = orient->data.ptr + orient->step*y;
 373
 374         for( x = 0; x < mhi_cols; x++ )
 375             if( mask_row.data.ptr[x] != 0 && mhi_row.data.fl[x] > delbound )
 376             {
 377                 /*
 378                    orient in 0..360, base_orient in 0..360
 379                    -> (rel_angle = orient - base_orient) in -360..360.
 380                    rel_angle is translated to -180..180
 381                  */
 382                 double weight = mhi_row.data.fl[x] * a + b;
 383                 int rel_angle = cvRound( orient_row.data.fl[x] - fbase_orient );
 384
 385                 rel_angle += (rel_angle < -180 ? 360 : 0);
 386                 rel_angle += (rel_angle > 180 ? -360 : 0);
 387
 388                 if( abs(rel_angle) < 90 )
 389                 {
 390                     shift_orient += weight * rel_angle;
 391                     shift_weight += weight;
 392                 }
 393             }
 394     }
 395
 396     // add the dominant orientation and the relative shift
 397     if( shift_weight == 0 )
 398         shift_weight = 0.01;
 399
 400     base_orient = base_orient + cvRound( shift_orient / shift_weight );
 401     base_orient -= (base_orient < 360 ? 0 : 360);
 402     base_orient += (base_orient >= 0 ? 0 : 360);
 403
 404     angle = base_orient;
 405
 406     __END__;
 407
 408     cvReleaseHist( &hist );
 409     return angle;
 410 }
 411
 412
 413 CV_IMPL CvSeq*
 414 cvSegmentMotion( const CvArr* mhiimg, CvArr* segmask, CvMemStorage* storage,
 415                  double timestamp, double seg_thresh )
 416 {
 417     CvSeq* components = 0;
 418     CvMat* mask8u = 0;
 419
 420     CV_FUNCNAME( "cvSegmentMotion" );
 421
 422     __BEGIN__;
 423
 424     CvMat  mhistub, *mhi = (CvMat*)mhiimg;
 425     CvMat  maskstub, *mask = (CvMat*)segmask;
 426     Cv32suf v, comp_idx;
 427     int stub_val, ts;
 428     int x, y;
 429
 430     if( !storage )
 431         CV_ERROR( CV_StsNullPtr, "NULL memory storage" );
 432
 433     CV_CALL( mhi = cvGetMat( mhi, &mhistub ));
 434     CV_CALL( mask = cvGetMat( mask, &maskstub ));
 435
 436     if( CV_MAT_TYPE( mhi->type ) != CV_32FC1 || CV_MAT_TYPE( mask->type ) != CV_32FC1 )
 437         CV_ERROR( CV_BadDepth, "Both MHI and the destination mask" );
 438
 439     if( !CV_ARE_SIZES_EQ( mhi, mask ))
 440         CV_ERROR( CV_StsUnmatchedSizes, "" );
 441
 442     CV_CALL( mask8u = cvCreateMat( mhi->rows + 2, mhi->cols + 2, CV_8UC1 ));
 443     cvZero( mask8u );
 444     cvZero( mask );
 445     CV_CALL( components = cvCreateSeq( CV_SEQ_KIND_GENERIC, sizeof(CvSeq),
 446                                        sizeof(CvConnectedComp), storage ));
 447
 448     v.f = (float)timestamp; ts = v.i;
 449     v.f = FLT_MAX*0.1f; stub_val = v.i;
 450     comp_idx.f = 1;
 451
 452     for( y = 0; y < mhi->rows; y++ )
 453     {
 454         int* mhi_row = (int*)(mhi->data.ptr + y*mhi->step);
 455         for( x = 0; x < mhi->cols; x++ )
 456         {
 457             if( mhi_row[x] == 0 )
 458                 mhi_row[x] = stub_val;
 459         }
 460     }
 461
 462     for( y = 0; y < mhi->rows; y++ )
 463     {
 464         int* mhi_row = (int*)(mhi->data.ptr + y*mhi->step);
 465         uchar* mask8u_row = mask8u->data.ptr + (y+1)*mask8u->step + 1;
 466
 467         for( x = 0; x < mhi->cols; x++ )
 468         {
 469             if( mhi_row[x] == ts && mask8u_row[x] == 0 )
 470             {
 471                 CvConnectedComp comp;
 472                 int x1, y1;
 473                 CvScalar _seg_thresh = cvRealScalar(seg_thresh);
 474                 CvPoint seed = cvPoint(x,y);
 475
 476                 CV_CALL( cvFloodFill( mhi, seed, cvRealScalar(0), _seg_thresh, _seg_thresh,
 477                                       &comp, CV_FLOODFILL_MASK_ONLY + 2*256 + 4, mask8u ));
 478
 479                 for( y1 = 0; y1 < comp.rect.height; y1++ )
 480                 {
 481                     int* mask_row1 = (int*)(mask->data.ptr +
 482                                     (comp.rect.y + y1)*mask->step) + comp.rect.x;
 483                     uchar* mask8u_row1 = mask8u->data.ptr +
 484                                     (comp.rect.y + y1+1)*mask8u->step + comp.rect.x+1;
 485
 486                     for( x1 = 0; x1 < comp.rect.width; x1++ )
 487                     {
 488                         if( mask8u_row1[x1] > 1 )
 489                         {
 490                             mask8u_row1[x1] = 1;
 491                             mask_row1[x1] = comp_idx.i;
 492                         }
 493                     }
 494                 }
 495                 comp_idx.f++;
 496                 cvSeqPush( components, &comp );
 497             }
 498         }
 499     }
 500
 501     for( y = 0; y < mhi->rows; y++ )
 502     {
 503         int* mhi_row = (int*)(mhi->data.ptr + y*mhi->step);
 504         for( x = 0; x < mhi->cols; x++ )
 505         {
 506             if( mhi_row[x] == stub_val )
 507                 mhi_row[x] = 0;
 508         }
 509     }
 510
 511     __END__;
 512
 513     cvReleaseMat( &mask8u );
 514     return components;
 515 }
 516
 517 /* End of file. */