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
cvUpdateMotionHistory(const void * silhouette,void * mhimg,double timestamp,double mhi_duration)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
cvCalcMotionGradient(const CvArr * mhiimg,CvArr * maskimg,CvArr * orientation,double delta1,double delta2,int aperture_size)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
cvCalcGlobalOrientation(const void * orientation,const void * maskimg,const void * mhiimg,double curr_mhi_timestamp,double mhi_duration)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*
cvSegmentMotion(const CvArr * mhiimg,CvArr * segmask,CvMemStorage * storage,double timestamp,double seg_thresh)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. */
518