diff options
Diffstat (limited to 'cv/src/cvmotempl.cpp')
| -rw-r--r-- | cv/src/cvmotempl.cpp | 517 |
1 files changed, 517 insertions, 0 deletions
diff --git a/cv/src/cvmotempl.cpp b/cv/src/cvmotempl.cpp new file mode 100644 index 0000000..1792671 --- /dev/null +++ b/cv/src/cvmotempl.cpp @@ -0,0 +1,517 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// Intel License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2000, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of Intel Corporation may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "_cv.h" + +IPCVAPI_IMPL( CvStatus, icvUpdateMotionHistory_8u32f_C1IR, + (const uchar * silIm, int silStep, float *mhiIm, int mhiStep, + CvSize size, float timestamp, float mhi_duration), + (silIm, silStep, mhiIm, mhiStep, size, timestamp, mhi_duration) ) +{ + int x, y; + + /* function processes floating-point images using integer arithmetics */ + Cv32suf v; + int ts, delbound; + int *mhi = (int *) mhiIm; + + v.f = timestamp; + ts = v.i; + + if( !silIm || !mhiIm ) + return CV_NULLPTR_ERR; + + if( size.height <= 0 || size.width <= 0 || + silStep < size.width || mhiStep < size.width * CV_SIZEOF_FLOAT || + (mhiStep & (CV_SIZEOF_FLOAT - 1)) != 0 ) + return CV_BADSIZE_ERR; + + if( mhi_duration < 0 ) + return CV_BADFACTOR_ERR; + + mhi_duration = timestamp - mhi_duration; + + v.f = mhi_duration; + delbound = CV_TOGGLE_FLT( v.i ); + + mhiStep /= sizeof(mhi[0]); + + if( mhiStep == size.width && silStep == size.width ) + { + size.width *= size.height; + size.height = 1; + } + + if( delbound > 0 ) + for( y = 0; y < size.height; y++, silIm += silStep, mhi += mhiStep ) + for( x = 0; x < size.width; x++ ) + { + int val = mhi[x]; + + /* val = silIm[x] ? ts : val < delbound ? 0 : val; */ + val &= (val < delbound) - 1; + val ^= (ts ^ val) & ((silIm[x] == 0) - 1); + mhi[x] = val; + } + else + for( y = 0; y < size.height; y++, silIm += silStep, mhi += mhiStep ) + for( x = 0; x < size.width; x++ ) + { + int val = mhi[x]; + + /* val = silIm[x] ? ts : val < delbound ? 0 : val; */ + val &= (CV_TOGGLE_FLT( val ) < delbound) - 1; + val ^= (ts ^ val) & ((silIm[x] == 0) - 1); + mhi[x] = val; + } + + return CV_OK; +} + + +/* motion templates */ +CV_IMPL void +cvUpdateMotionHistory( const void* silhouette, void* mhimg, + double timestamp, double mhi_duration ) +{ + CvSize size; + CvMat silhstub, *silh = (CvMat*)silhouette; + CvMat mhistub, *mhi = (CvMat*)mhimg; + int mhi_step, silh_step; + + CV_FUNCNAME( "cvUpdateMHIByTime" ); + + __BEGIN__; + + CV_CALL( silh = cvGetMat( silh, &silhstub )); + CV_CALL( mhi = cvGetMat( mhi, &mhistub )); + + if( !CV_IS_MASK_ARR( silh )) + CV_ERROR( CV_StsBadMask, "" ); + + if( CV_MAT_CN( mhi->type ) > 1 ) + CV_ERROR( CV_BadNumChannels, "" ); + + if( CV_MAT_DEPTH( mhi->type ) != CV_32F ) + CV_ERROR( CV_BadDepth, "" ); + + if( !CV_ARE_SIZES_EQ( mhi, silh )) + CV_ERROR( CV_StsUnmatchedSizes, "" ); + + size = cvGetMatSize( mhi ); + + mhi_step = mhi->step; + silh_step = silh->step; + + if( CV_IS_MAT_CONT( mhi->type & silh->type )) + { + size.width *= size.height; + mhi_step = silh_step = CV_STUB_STEP; + size.height = 1; + } + + IPPI_CALL( icvUpdateMotionHistory_8u32f_C1IR( (const uchar*)(silh->data.ptr), silh_step, + mhi->data.fl, mhi_step, size, + (float)timestamp, (float)mhi_duration )); + __END__; +} + + +CV_IMPL void +cvCalcMotionGradient( const CvArr* mhiimg, CvArr* maskimg, + CvArr* orientation, + double delta1, double delta2, + int aperture_size ) +{ + CvMat *dX_min = 0, *dY_max = 0; + IplConvKernel* el = 0; + + CV_FUNCNAME( "cvCalcMotionGradient" ); + + __BEGIN__; + + CvMat mhistub, *mhi = (CvMat*)mhiimg; + CvMat maskstub, *mask = (CvMat*)maskimg; + CvMat orientstub, *orient = (CvMat*)orientation; + CvMat dX_min_row, dY_max_row, orient_row, mask_row; + CvSize size; + int x, y; + + float gradient_epsilon = 1e-4f * aperture_size * aperture_size; + float min_delta, max_delta; + + CV_CALL( mhi = cvGetMat( mhi, &mhistub )); + CV_CALL( mask = cvGetMat( mask, &maskstub )); + CV_CALL( orient = cvGetMat( orient, &orientstub )); + + if( !CV_IS_MASK_ARR( mask )) + CV_ERROR( CV_StsBadMask, "" ); + + if( aperture_size < 3 || aperture_size > 7 || (aperture_size & 1) == 0 ) + CV_ERROR( CV_StsOutOfRange, "aperture_size must be 3, 5 or 7" ); + + if( delta1 <= 0 || delta2 <= 0 ) + CV_ERROR( CV_StsOutOfRange, "both delta's must be positive" ); + + if( CV_MAT_TYPE( mhi->type ) != CV_32FC1 || CV_MAT_TYPE( orient->type ) != CV_32FC1 ) + CV_ERROR( CV_StsUnsupportedFormat, + "MHI and orientation must be single-channel floating-point images" ); + + if( !CV_ARE_SIZES_EQ( mhi, mask ) || !CV_ARE_SIZES_EQ( orient, mhi )) + CV_ERROR( CV_StsUnmatchedSizes, "" ); + + if( orient->data.ptr == mhi->data.ptr ) + CV_ERROR( CV_StsInplaceNotSupported, "orientation image must be different from MHI" ); + + if( delta1 > delta2 ) + { + double t; + CV_SWAP( delta1, delta2, t ); + } + + size = cvGetMatSize( mhi ); + min_delta = (float)delta1; + max_delta = (float)delta2; + CV_CALL( dX_min = cvCreateMat( mhi->rows, mhi->cols, CV_32F )); + CV_CALL( dY_max = cvCreateMat( mhi->rows, mhi->cols, CV_32F )); + + /* calc Dx and Dy */ + CV_CALL( cvSobel( mhi, dX_min, 1, 0, aperture_size )); + CV_CALL( cvSobel( mhi, dY_max, 0, 1, aperture_size )); + cvGetRow( dX_min, &dX_min_row, 0 ); + cvGetRow( dY_max, &dY_max_row, 0 ); + cvGetRow( orient, &orient_row, 0 ); + cvGetRow( mask, &mask_row, 0 ); + + /* calc gradient */ + for( y = 0; y < size.height; y++ ) + { + dX_min_row.data.ptr = dX_min->data.ptr + y*dX_min->step; + dY_max_row.data.ptr = dY_max->data.ptr + y*dY_max->step; + orient_row.data.ptr = orient->data.ptr + y*orient->step; + mask_row.data.ptr = mask->data.ptr + y*mask->step; + cvCartToPolar( &dX_min_row, &dY_max_row, 0, &orient_row, 1 ); + + /* make orientation zero where the gradient is very small */ + for( x = 0; x < size.width; x++ ) + { + float dY = dY_max_row.data.fl[x]; + float dX = dX_min_row.data.fl[x]; + + if( fabs(dX) < gradient_epsilon && fabs(dY) < gradient_epsilon ) + { + mask_row.data.ptr[x] = 0; + orient_row.data.i[x] = 0; + } + else + mask_row.data.ptr[x] = 1; + } + } + + CV_CALL( el = cvCreateStructuringElementEx( aperture_size, aperture_size, + aperture_size/2, aperture_size/2, CV_SHAPE_RECT )); + cvErode( mhi, dX_min, el ); + cvDilate( mhi, dY_max, el ); + + /* mask off pixels which have little motion difference in their neighborhood */ + for( y = 0; y < size.height; y++ ) + { + dX_min_row.data.ptr = dX_min->data.ptr + y*dX_min->step; + dY_max_row.data.ptr = dY_max->data.ptr + y*dY_max->step; + mask_row.data.ptr = mask->data.ptr + y*mask->step; + orient_row.data.ptr = orient->data.ptr + y*orient->step; + + for( x = 0; x < size.width; x++ ) + { + float d0 = dY_max_row.data.fl[x] - dX_min_row.data.fl[x]; + + if( mask_row.data.ptr[x] == 0 || d0 < min_delta || max_delta < d0 ) + { + mask_row.data.ptr[x] = 0; + orient_row.data.i[x] = 0; + } + } + } + + __END__; + + cvReleaseMat( &dX_min ); + cvReleaseMat( &dY_max ); + cvReleaseStructuringElement( &el ); +} + + +CV_IMPL double +cvCalcGlobalOrientation( const void* orientation, const void* maskimg, const void* mhiimg, + double curr_mhi_timestamp, double mhi_duration ) +{ + double angle = 0; + int hist_size = 12; + CvHistogram* hist = 0; + + CV_FUNCNAME( "cvCalcGlobalOrientation" ); + + __BEGIN__; + + CvMat mhistub, *mhi = (CvMat*)mhiimg; + CvMat maskstub, *mask = (CvMat*)maskimg; + CvMat orientstub, *orient = (CvMat*)orientation; + void* _orient; + float _ranges[] = { 0, 360 }; + float* ranges = _ranges; + int base_orient; + double shift_orient = 0, shift_weight = 0, fbase_orient; + double a, b; + float delbound; + CvMat mhi_row, mask_row, orient_row; + int x, y, mhi_rows, mhi_cols; + + CV_CALL( mhi = cvGetMat( mhi, &mhistub )); + CV_CALL( mask = cvGetMat( mask, &maskstub )); + CV_CALL( orient = cvGetMat( orient, &orientstub )); + + if( !CV_IS_MASK_ARR( mask )) + CV_ERROR( CV_StsBadMask, "" ); + + if( CV_MAT_TYPE( mhi->type ) != CV_32FC1 || CV_MAT_TYPE( orient->type ) != CV_32FC1 ) + CV_ERROR( CV_StsUnsupportedFormat, + "MHI and orientation must be single-channel floating-point images" ); + + if( !CV_ARE_SIZES_EQ( mhi, mask ) || !CV_ARE_SIZES_EQ( orient, mhi )) + CV_ERROR( CV_StsUnmatchedSizes, "" ); + + if( mhi_duration <= 0 ) + CV_ERROR( CV_StsOutOfRange, "MHI duration must be positive" ); + + if( orient->data.ptr == mhi->data.ptr ) + CV_ERROR( CV_StsInplaceNotSupported, "orientation image must be different from MHI" ); + + // calculate histogram of different orientation values + CV_CALL( hist = cvCreateHist( 1, &hist_size, CV_HIST_ARRAY, &ranges )); + _orient = orient; + cvCalcArrHist( &_orient, hist, 0, mask ); + + // find the maximum index (the dominant orientation) + cvGetMinMaxHistValue( hist, 0, 0, 0, &base_orient ); + base_orient *= 360/hist_size; + + // override timestamp with the maximum value in MHI + cvMinMaxLoc( mhi, 0, &curr_mhi_timestamp, 0, 0, mask ); + + // find the shift relative to the dominant orientation as weighted sum of relative angles + a = 254. / 255. / mhi_duration; + b = 1. - curr_mhi_timestamp * a; + fbase_orient = base_orient; + delbound = (float)(curr_mhi_timestamp - mhi_duration); + mhi_rows = mhi->rows; + mhi_cols = mhi->cols; + + if( CV_IS_MAT_CONT( mhi->type & mask->type & orient->type )) + { + mhi_cols *= mhi_rows; + mhi_rows = 1; + } + + cvGetRow( mhi, &mhi_row, 0 ); + cvGetRow( mask, &mask_row, 0 ); + cvGetRow( orient, &orient_row, 0 ); + + /* + a = 254/(255*dt) + b = 1 - t*a = 1 - 254*t/(255*dur) = + (255*dt - 254*t)/(255*dt) = + (dt - (t - dt)*254)/(255*dt); + -------------------------------------------------------- + ax + b = 254*x/(255*dt) + (dt - (t - dt)*254)/(255*dt) = + (254*x + dt - (t - dt)*254)/(255*dt) = + ((x - (t - dt))*254 + dt)/(255*dt) = + (((x - (t - dt))/dt)*254 + 1)/255 = (((x - low_time)/dt)*254 + 1)/255 + */ + for( y = 0; y < mhi_rows; y++ ) + { + mhi_row.data.ptr = mhi->data.ptr + mhi->step*y; + mask_row.data.ptr = mask->data.ptr + mask->step*y; + orient_row.data.ptr = orient->data.ptr + orient->step*y; + + for( x = 0; x < mhi_cols; x++ ) + if( mask_row.data.ptr[x] != 0 && mhi_row.data.fl[x] > delbound ) + { + /* + orient in 0..360, base_orient in 0..360 + -> (rel_angle = orient - base_orient) in -360..360. + rel_angle is translated to -180..180 + */ + double weight = mhi_row.data.fl[x] * a + b; + int rel_angle = cvRound( orient_row.data.fl[x] - fbase_orient ); + + rel_angle += (rel_angle < -180 ? 360 : 0); + rel_angle += (rel_angle > 180 ? -360 : 0); + + if( abs(rel_angle) < 90 ) + { + shift_orient += weight * rel_angle; + shift_weight += weight; + } + } + } + + // add the dominant orientation and the relative shift + if( shift_weight == 0 ) + shift_weight = 0.01; + + base_orient = base_orient + cvRound( shift_orient / shift_weight ); + base_orient -= (base_orient < 360 ? 0 : 360); + base_orient += (base_orient >= 0 ? 0 : 360); + + angle = base_orient; + + __END__; + + cvReleaseHist( &hist ); + return angle; +} + + +CV_IMPL CvSeq* +cvSegmentMotion( const CvArr* mhiimg, CvArr* segmask, CvMemStorage* storage, + double timestamp, double seg_thresh ) +{ + CvSeq* components = 0; + CvMat* mask8u = 0; + + CV_FUNCNAME( "cvSegmentMotion" ); + + __BEGIN__; + + CvMat mhistub, *mhi = (CvMat*)mhiimg; + CvMat maskstub, *mask = (CvMat*)segmask; + Cv32suf v, comp_idx; + int stub_val, ts; + int x, y; + + if( !storage ) + CV_ERROR( CV_StsNullPtr, "NULL memory storage" ); + + CV_CALL( mhi = cvGetMat( mhi, &mhistub )); + CV_CALL( mask = cvGetMat( mask, &maskstub )); + + if( CV_MAT_TYPE( mhi->type ) != CV_32FC1 || CV_MAT_TYPE( mask->type ) != CV_32FC1 ) + CV_ERROR( CV_BadDepth, "Both MHI and the destination mask" ); + + if( !CV_ARE_SIZES_EQ( mhi, mask )) + CV_ERROR( CV_StsUnmatchedSizes, "" ); + + CV_CALL( mask8u = cvCreateMat( mhi->rows + 2, mhi->cols + 2, CV_8UC1 )); + cvZero( mask8u ); + cvZero( mask ); + CV_CALL( components = cvCreateSeq( CV_SEQ_KIND_GENERIC, sizeof(CvSeq), + sizeof(CvConnectedComp), storage )); + + v.f = (float)timestamp; ts = v.i; + v.f = FLT_MAX*0.1f; stub_val = v.i; + comp_idx.f = 1; + + for( y = 0; y < mhi->rows; y++ ) + { + int* mhi_row = (int*)(mhi->data.ptr + y*mhi->step); + for( x = 0; x < mhi->cols; x++ ) + { + if( mhi_row[x] == 0 ) + mhi_row[x] = stub_val; + } + } + + for( y = 0; y < mhi->rows; y++ ) + { + int* mhi_row = (int*)(mhi->data.ptr + y*mhi->step); + uchar* mask8u_row = mask8u->data.ptr + (y+1)*mask8u->step + 1; + + for( x = 0; x < mhi->cols; x++ ) + { + if( mhi_row[x] == ts && mask8u_row[x] == 0 ) + { + CvConnectedComp comp; + int x1, y1; + CvScalar _seg_thresh = cvRealScalar(seg_thresh); + CvPoint seed = cvPoint(x,y); + + CV_CALL( cvFloodFill( mhi, seed, cvRealScalar(0), _seg_thresh, _seg_thresh, + &comp, CV_FLOODFILL_MASK_ONLY + 2*256 + 4, mask8u )); + + for( y1 = 0; y1 < comp.rect.height; y1++ ) + { + int* mask_row1 = (int*)(mask->data.ptr + + (comp.rect.y + y1)*mask->step) + comp.rect.x; + uchar* mask8u_row1 = mask8u->data.ptr + + (comp.rect.y + y1+1)*mask8u->step + comp.rect.x+1; + + for( x1 = 0; x1 < comp.rect.width; x1++ ) + { + if( mask8u_row1[x1] > 1 ) + { + mask8u_row1[x1] = 1; + mask_row1[x1] = comp_idx.i; + } + } + } + comp_idx.f++; + cvSeqPush( components, &comp ); + } + } + } + + for( y = 0; y < mhi->rows; y++ ) + { + int* mhi_row = (int*)(mhi->data.ptr + y*mhi->step); + for( x = 0; x < mhi->cols; x++ ) + { + if( mhi_row[x] == stub_val ) + mhi_row[x] = 0; + } + } + + __END__; + + cvReleaseMat( &mask8u ); + return components; +} + +/* End of file. */ |