int resid(CvMat* Y, CvMat* u, CvMat** Q, int num_Q_mats, CvMat* e, CvMat* J)
{
int i, mat_id;
CvMat* q;
CvMat* x0;
CvMat* x;
CvMat* temp_mat1;
CvMat* temp_mat2;
CvMat* temp_mat3_1;
CvMat* temp_mat3_2;
/* Create the initial e and J matrices */
// e = cvCreateMat(0, 0, CV_64FC1);
// J = cvCreateMat(0, 0, CV_64FC1);
for(mat_id = 0 ; mat_id < num_Q_mats ; mat_id++)
{
/* Copy data into the new matrix */
q = sfmGetCols(Q[mat_id], 0, 2);
/* Copy data to form the x0 matrix */
x0 = sfmGetCols(Q[mat_id],3);
/* x = q*Y + x0 */
x=sfmMatMul(q, Y);
cvAdd(x, x0, x);
/*
//debug
printf("....x\n");
CvMat_printdb(stdout,"%7.3f ",x);
*/
/* Temporary matrix to aid evaluations of e */
temp_mat1 = cvCreateMat(2, 1, CV_64FC1);
temp_mat2 = cvCreateMat(2, 1, CV_64FC1);
/* Evaluate and save temporary data */
temp_mat1->data.db[0] = x->data.db[0] / x->data.db[2];
temp_mat1->data.db[1] = x->data.db[1] / x->data.db[2];
temp_mat2->data.db[0] = u->data.db[0*u->cols + mat_id];
temp_mat2->data.db[1] = u->data.db[1*u->cols + mat_id];
/* e = [e; x(1:2)/x(3)-u(1:2,k)] */
cvSub(temp_mat1,temp_mat2,temp_mat1);
PutMatV(temp_mat1,e,mat_id*2);
/*
//debug
printf("....e\n");
CvMat_printdb(stdout,"%7.3f ",e);
*/
/* Temporary matrix to aid evaluations of Y */
cvReleaseMat(&temp_mat2);
cvReleaseMat(&temp_mat1);
//memory leak
temp_mat1 = cvCreateMat(1, 3, CV_64FC1);
temp_mat2 = cvCreateMat(1, 3, CV_64FC1);
temp_mat3_1 = cvCreateMat(1, 3, CV_64FC1);
temp_mat3_2 = cvCreateMat(1, 3, CV_64FC1);
for(i = 0 ; i < 3 ; i++)
{
/* Copy data into the temp matrices */
temp_mat1->data.db[i] = (q->data.db[i] * x->data.db[2]) /
(x->data.db[2] * x->data.db[2]); /* x(3)*q(1,:) / x(3)^2 */
temp_mat2->data.db[i] = (q->data.db[i + 3] * x->data.db[2]) /
(x->data.db[2] * x->data.db[2]); /* x(3)*q(2,:) / x(3)^2 */
temp_mat3_1->data.db[i] = (q->data.db[i + 6] * x->data.db[0]) /
(x->data.db[2] * x->data.db[2]); /* x(1)*q(3,:) / x(3)^2 */
temp_mat3_2->data.db[i] = (q->data.db[i + 6] * x->data.db[1]) /
(x->data.db[2] * x->data.db[2]); /* x(2)*q(3,:) / x(3)^2 */
}
/*
//for debug
printf("....temp_mat1\n");
CvMat_printdb(stdout,"%7.3f ",temp_mat1);
printf("....temp_mat2\n");
CvMat_printdb(stdout,"%7.3f ",temp_mat2);
printf("....temp_mat3_1\n");
CvMat_printdb(stdout,"%7.3f ",temp_mat3_1);
printf("....temp_mat3_2\n");
CvMat_printdb(stdout,"%7.3f ",temp_mat3_2);
*/
/* x(3)*q(1,:)-x(1)*q(3,:) */
cvSub(temp_mat1, temp_mat3_1, temp_mat1);
/* x(3)*q(2,:)-x(2)*q(3,:) */
cvSub(temp_mat2, temp_mat3_2, temp_mat2);
/* [x(3)*q(1,:)-x(1)*q(3,:) x(3)*q(2,:)-x(2)*q(3,:)]/x(3)^2 */
temp_mat1 = cat(temp_mat1, temp_mat2, 1);
/* J = [J; [x(3)*q(1,:)-x(1)*q(3,:) x(3)*q(2,:)-x(2)*q(3,:)]/x(3)^2] */
PutMatV(temp_mat1,J,mat_id*2);
/*
//for debug.
printf("....J\n");
CvMat_printdb(stdout,"%7.3f ",J);
*/
cvReleaseMat(&temp_mat3_2);
cvReleaseMat(&temp_mat3_1);
cvReleaseMat(&temp_mat2);
cvReleaseMat(&temp_mat1);
cvReleaseMat(&x);
cvReleaseMat(&x0);
cvReleaseMat(&q);
}
return 1;
}
~pstable_l2_func() {
cvReleaseMat(&a);
cvReleaseMat(&b);
cvReleaseMat(&r1);
cvReleaseMat(&r2);
}
static void*
imread_( const String& filename, int flags, int hdrtype, Mat* mat=0 )
{
IplImage* image = 0;
CvMat *matrix = 0;
Mat temp, *data = &temp;
ImageDecoder decoder = findDecoder(filename);
if( !decoder.obj )
return 0;
decoder->setSource(filename);
if( !decoder->readHeader() )
return 0;
CvSize size;
size.width = decoder->width();
size.height = decoder->height();
int type = decoder->type();
if( flags != -1 )
{
if( (flags & CV_LOAD_IMAGE_ANYDEPTH) == 0 )
type = CV_MAKETYPE(CV_8U, CV_MAT_CN(type));
if( (flags & CV_LOAD_IMAGE_COLOR) != 0 ||
((flags & CV_LOAD_IMAGE_ANYCOLOR) != 0 && CV_MAT_CN(type) > 1) )
type = CV_MAKETYPE(CV_MAT_DEPTH(type), 3);
else
type = CV_MAKETYPE(CV_MAT_DEPTH(type), 1);
}
if( hdrtype == LOAD_CVMAT || hdrtype == LOAD_MAT )
{
if( hdrtype == LOAD_CVMAT )
{
matrix = cvCreateMat( size.height, size.width, type );
temp = cvarrToMat(matrix);
}
else
{
mat->create( size.height, size.width, type );
data = mat;
}
}
else
{
image = cvCreateImage( size, cvIplDepth(type), CV_MAT_CN(type) );
temp = cvarrToMat(image);
}
if( !decoder->readData( *data ))
{
cvReleaseImage( &image );
cvReleaseMat( &matrix );
if( mat )
mat->release();
return 0;
}
return hdrtype == LOAD_CVMAT ? (void*)matrix :
hdrtype == LOAD_IMAGE ? (void*)image : (void*)mat;
}
void CV_POSITTest::run( int start_from )
{
int code = CvTS::OK;
/* fixed parameters output */
/*float rot[3][3]={ 0.49010f, 0.85057f, 0.19063f,
-0.56948f, 0.14671f, 0.80880f,
0.65997f, -0.50495f, 0.55629f };
float trans[3] = { 0.0f, 0.0f, 40.02637f };
*/
/* Some variables */
int i, counter;
CvTermCriteria criteria;
CvPoint3D32f* obj_points;
CvPoint2D32f* img_points;
CvPOSITObject* object;
float angleX, angleY, angleZ;
CvRNG* rng = ts->get_rng();
int progress = 0;
CvMat* true_rotationX = cvCreateMat( 3, 3, CV_32F );
CvMat* true_rotationY = cvCreateMat( 3, 3, CV_32F );
CvMat* true_rotationZ = cvCreateMat( 3, 3, CV_32F );
CvMat* tmp_matrix = cvCreateMat( 3, 3, CV_32F );
CvMat* true_rotation = cvCreateMat( 3, 3, CV_32F );
CvMat* rotation = cvCreateMat( 3, 3, CV_32F );
CvMat* translation = cvCreateMat( 3, 1, CV_32F );
CvMat* true_translation = cvCreateMat( 3, 1, CV_32F );
const float flFocalLength = 760.f;
const float flEpsilon = 0.1f;
/* Initilization */
criteria.type = CV_TERMCRIT_EPS|CV_TERMCRIT_ITER;
criteria.epsilon = flEpsilon;
criteria.max_iter = 10000;
/* Allocating source arrays; */
obj_points = (CvPoint3D32f*)cvAlloc( 8 * sizeof(CvPoint3D32f) );
img_points = (CvPoint2D32f*)cvAlloc( 8 * sizeof(CvPoint2D32f) );
/* Fill points arrays with values */
/* cube model with edge size 10 */
obj_points[0].x = 0; obj_points[0].y = 0; obj_points[0].z = 0;
obj_points[1].x = 10; obj_points[1].y = 0; obj_points[1].z = 0;
obj_points[2].x = 10; obj_points[2].y = 10; obj_points[2].z = 0;
obj_points[3].x = 0; obj_points[3].y = 10; obj_points[3].z = 0;
obj_points[4].x = 0; obj_points[4].y = 0; obj_points[4].z = 10;
obj_points[5].x = 10; obj_points[5].y = 0; obj_points[5].z = 10;
obj_points[6].x = 10; obj_points[6].y = 10; obj_points[6].z = 10;
obj_points[7].x = 0; obj_points[7].y = 10; obj_points[7].z = 10;
/* Loop for test some random object positions */
for( counter = start_from; counter < test_case_count; counter++ )
{
ts->update_context( this, counter, true );
progress = update_progress( progress, counter, test_case_count, 0 );
/* set all rotation matrix to zero */
cvZero( true_rotationX );
cvZero( true_rotationY );
cvZero( true_rotationZ );
/* fill random rotation matrix */
angleX = (float)(cvTsRandReal(rng)*2*CV_PI);
angleY = (float)(cvTsRandReal(rng)*2*CV_PI);
angleZ = (float)(cvTsRandReal(rng)*2*CV_PI);
true_rotationX->data.fl[0 *3+ 0] = 1;
true_rotationX->data.fl[1 *3+ 1] = (float)cos(angleX);
true_rotationX->data.fl[2 *3+ 2] = true_rotationX->data.fl[1 *3+ 1];
true_rotationX->data.fl[1 *3+ 2] = -(float)sin(angleX);
true_rotationX->data.fl[2 *3+ 1] = -true_rotationX->data.fl[1 *3+ 2];
true_rotationY->data.fl[1 *3+ 1] = 1;
true_rotationY->data.fl[0 *3+ 0] = (float)cos(angleY);
true_rotationY->data.fl[2 *3+ 2] = true_rotationY->data.fl[0 *3+ 0];
true_rotationY->data.fl[0 *3+ 2] = -(float)sin(angleY);
true_rotationY->data.fl[2 *3+ 0] = -true_rotationY->data.fl[0 *3+ 2];
true_rotationZ->data.fl[2 *3+ 2] = 1;
true_rotationZ->data.fl[0 *3+ 0] = (float)cos(angleZ);
true_rotationZ->data.fl[1 *3+ 1] = true_rotationZ->data.fl[0 *3+ 0];
true_rotationZ->data.fl[0 *3+ 1] = -(float)sin(angleZ);
true_rotationZ->data.fl[1 *3+ 0] = -true_rotationZ->data.fl[0 *3+ 1];
cvMatMul( true_rotationX, true_rotationY, tmp_matrix);
cvMatMul( tmp_matrix, true_rotationZ, true_rotation);
/* fill translation vector */
true_translation->data.fl[2] = (float)(cvRandReal(rng)*(2*flFocalLength-40) + 40);
true_translation->data.fl[0] = (float)((cvRandReal(rng)*2-1)*true_translation->data.fl[2]);
true_translation->data.fl[1] = (float)((cvRandReal(rng)*2-1)*true_translation->data.fl[2]);
/* calculate perspective projection */
for ( i = 0; i < 8; i++ )
{
float vec[3];
CvMat Vec = cvMat( 3, 1, CV_MAT32F, vec );
CvMat Obj_point = cvMat( 3, 1, CV_MAT32F, &obj_points[i].x );
cvMatMul( true_rotation, &Obj_point, &Vec );
vec[0] += true_translation->data.fl[0];
vec[1] += true_translation->data.fl[1];
vec[2] += true_translation->data.fl[2];
img_points[i].x = flFocalLength * vec[0] / vec[2];
img_points[i].y = flFocalLength * vec[1] / vec[2];
}
/*img_points[0].x = 0 ; img_points[0].y = 0;
img_points[1].x = 80; img_points[1].y = -93;
img_points[2].x = 245;img_points[2].y = -77;
img_points[3].x = 185;img_points[3].y = 32;
img_points[4].x = 32; img_points[4].y = 135;
img_points[5].x = 99; img_points[5].y = 35;
img_points[6].x = 247; img_points[6].y = 62;
img_points[7].x = 195; img_points[7].y = 179;
*/
object = cvCreatePOSITObject( obj_points, 8 );
cvPOSIT( object, img_points, flFocalLength, criteria,
rotation->data.fl, translation->data.fl );
cvReleasePOSITObject( &object );
code = cvTsCmpEps2( ts, rotation, true_rotation, flEpsilon, false, "rotation matrix" );
if( code < 0 )
goto _exit_;
code = cvTsCmpEps2( ts, translation, true_translation, flEpsilon, false, "translation vector" );
if( code < 0 )
goto _exit_;
}
_exit_:
cvFree( &obj_points );
cvFree( &img_points );
cvReleaseMat( &true_rotationX );
cvReleaseMat( &true_rotationY );
cvReleaseMat( &true_rotationZ );
cvReleaseMat( &tmp_matrix );
cvReleaseMat( &true_rotation );
cvReleaseMat( &rotation );
cvReleaseMat( &translation );
cvReleaseMat( &true_translation );
if( code < 0 )
ts->set_failed_test_info( code );
}
CV_IMPL void
cvMatchTemplate( const CvArr* _img, const CvArr* _templ, CvArr* _result, int method )
{
CvMat* sum = 0;
CvMat* sqsum = 0;
CV_FUNCNAME( "cvMatchTemplate" );
__BEGIN__;
int coi1 = 0, coi2 = 0;
int depth, cn;
int i, j, k;
CvMat stub, *img = (CvMat*)_img;
CvMat tstub, *templ = (CvMat*)_templ;
CvMat rstub, *result = (CvMat*)_result;
CvScalar templ_mean = cvScalarAll(0);
double templ_norm = 0, templ_sum2 = 0;
int idx = 0, idx2 = 0;
double *p0, *p1, *p2, *p3;
double *q0, *q1, *q2, *q3;
double inv_area;
int sum_step, sqsum_step;
int num_type = method == CV_TM_CCORR || method == CV_TM_CCORR_NORMED ? 0 :
method == CV_TM_CCOEFF || method == CV_TM_CCOEFF_NORMED ? 1 : 2;
int is_normed = method == CV_TM_CCORR_NORMED ||
method == CV_TM_SQDIFF_NORMED ||
method == CV_TM_CCOEFF_NORMED;
CV_CALL( img = cvGetMat( img, &stub, &coi1 ));
CV_CALL( templ = cvGetMat( templ, &tstub, &coi2 ));
CV_CALL( result = cvGetMat( result, &rstub ));
if( CV_MAT_DEPTH( img->type ) != CV_8U &&
CV_MAT_DEPTH( img->type ) != CV_32F )
CV_ERROR( CV_StsUnsupportedFormat,
"The function supports only 8u and 32f data types" );
if( !CV_ARE_TYPES_EQ( img, templ ))
CV_ERROR( CV_StsUnmatchedSizes, "image and template should have the same type" );
if( CV_MAT_TYPE( result->type ) != CV_32FC1 )
CV_ERROR( CV_StsUnsupportedFormat, "output image should have 32f type" );
if( img->rows < templ->rows || img->cols < templ->cols )
{
CvMat* t;
CV_SWAP( img, templ, t );
}
if( result->rows != img->rows - templ->rows + 1 ||
result->cols != img->cols - templ->cols + 1 )
CV_ERROR( CV_StsUnmatchedSizes, "output image should be (W - w + 1)x(H - h + 1)" );
if( method < CV_TM_SQDIFF || method > CV_TM_CCOEFF_NORMED )
CV_ERROR( CV_StsBadArg, "unknown comparison method" );
depth = CV_MAT_DEPTH(img->type);
cn = CV_MAT_CN(img->type);
/*if( is_normed && cn == 1 && templ->rows > 8 && templ->cols > 8 &&
img->rows > templ->cols && img->cols > templ->cols )
{
CvTemplMatchIPPFunc ipp_func =
depth == CV_8U ?
(method == CV_TM_SQDIFF_NORMED ? (CvTemplMatchIPPFunc)icvSqrDistanceValid_Norm_8u32f_C1R_p :
method == CV_TM_CCORR_NORMED ? (CvTemplMatchIPPFunc)icvCrossCorrValid_Norm_8u32f_C1R_p :
(CvTemplMatchIPPFunc)icvCrossCorrValid_NormLevel_8u32f_C1R_p) :
(method == CV_TM_SQDIFF_NORMED ? (CvTemplMatchIPPFunc)icvSqrDistanceValid_Norm_32f_C1R_p :
method == CV_TM_CCORR_NORMED ? (CvTemplMatchIPPFunc)icvCrossCorrValid_Norm_32f_C1R_p :
(CvTemplMatchIPPFunc)icvCrossCorrValid_NormLevel_32f_C1R_p);
if( ipp_func )
{
CvSize img_size = cvGetMatSize(img), templ_size = cvGetMatSize(templ);
IPPI_CALL( ipp_func( img->data.ptr, img->step ? img->step : CV_STUB_STEP,
img_size, templ->data.ptr,
templ->step ? templ->step : CV_STUB_STEP,
templ_size, result->data.ptr,
result->step ? result->step : CV_STUB_STEP ));
for( i = 0; i < result->rows; i++ )
{
float* rrow = (float*)(result->data.ptr + i*result->step);
for( j = 0; j < result->cols; j++ )
{
if( fabs(rrow[j]) > 1. )
rrow[j] = rrow[j] < 0 ? -1.f : 1.f;
}
}
EXIT;
}
}*/
CV_CALL( icvCrossCorr( img, templ, result ));
if( method == CV_TM_CCORR )
EXIT;
inv_area = 1./((double)templ->rows * templ->cols);
CV_CALL( sum = cvCreateMat( img->rows + 1, img->cols + 1,
CV_MAKETYPE( CV_64F, cn )));
if( method == CV_TM_CCOEFF )
{
CV_CALL( cvIntegral( img, sum, 0, 0 ));
CV_CALL( templ_mean = cvAvg( templ ));
q0 = q1 = q2 = q3 = 0;
}
else
{
CvScalar _templ_sdv = cvScalarAll(0);
CV_CALL( sqsum = cvCreateMat( img->rows + 1, img->cols + 1,
CV_MAKETYPE( CV_64F, cn )));
CV_CALL( cvIntegral( img, sum, sqsum, 0 ));
CV_CALL( cvAvgSdv( templ, &templ_mean, &_templ_sdv ));
templ_norm = CV_SQR(_templ_sdv.val[0]) + CV_SQR(_templ_sdv.val[1]) +
CV_SQR(_templ_sdv.val[2]) + CV_SQR(_templ_sdv.val[3]);
if( templ_norm < DBL_EPSILON && method == CV_TM_CCOEFF_NORMED )
{
cvSet( result, cvScalarAll(1.) );
EXIT;
}
templ_sum2 = templ_norm +
CV_SQR(templ_mean.val[0]) + CV_SQR(templ_mean.val[1]) +
CV_SQR(templ_mean.val[2]) + CV_SQR(templ_mean.val[3]);
if( num_type != 1 )
{
templ_mean = cvScalarAll(0);
templ_norm = templ_sum2;
}
templ_sum2 /= inv_area;
templ_norm = sqrt(templ_norm);
templ_norm /= sqrt(inv_area); // care of accuracy here
q0 = (double*)sqsum->data.ptr;
q1 = q0 + templ->cols*cn;
q2 = (double*)(sqsum->data.ptr + templ->rows*sqsum->step);
q3 = q2 + templ->cols*cn;
}
p0 = (double*)sum->data.ptr;
p1 = p0 + templ->cols*cn;
p2 = (double*)(sum->data.ptr + templ->rows*sum->step);
p3 = p2 + templ->cols*cn;
sum_step = sum ? sum->step / sizeof(double) : 0;
sqsum_step = sqsum ? sqsum->step / sizeof(double) : 0;
for( i = 0; i < result->rows; i++ )
{
float* rrow = (float*)(result->data.ptr + i*result->step);
idx = i * sum_step;
idx2 = i * sqsum_step;
for( j = 0; j < result->cols; j++, idx += cn, idx2 += cn )
{
double num = rrow[j], t;
double wnd_mean2 = 0, wnd_sum2 = 0;
if( num_type == 1 )
{
for( k = 0; k < cn; k++ )
{
t = p0[idx+k] - p1[idx+k] - p2[idx+k] + p3[idx+k];
wnd_mean2 += CV_SQR(t);
num -= t*templ_mean.val[k];
}
wnd_mean2 *= inv_area;
}
if( is_normed || num_type == 2 )
{
for( k = 0; k < cn; k++ )
{
t = q0[idx2+k] - q1[idx2+k] - q2[idx2+k] + q3[idx2+k];
wnd_sum2 += t;
}
if( num_type == 2 )
num = wnd_sum2 - 2*num + templ_sum2;
}
if( is_normed )
{
t = sqrt(MAX(wnd_sum2 - wnd_mean2,0))*templ_norm;
if( t > DBL_EPSILON )
{
num /= t;
if( fabs(num) > 1. )
num = num > 0 ? 1 : -1;
}
else
num = method != CV_TM_SQDIFF_NORMED || num < DBL_EPSILON ? 0 : 1;
}
rrow[j] = (float)num;
}
}
__END__;
cvReleaseMat( &sum );
cvReleaseMat( &sqsum );
}
~DefHist()
{
if(m_pHist)cvReleaseMat(&m_pHist);
}
void Cell::destroyCell ()
{
if (getFlagStr() != INVALID_STR)
{
if (_rhs != NULL)
{
if (getRhsDim() > 1)
delete[] _rhs;
else
delete _rhs;
_rhs = NULL;
}
if (_detwindow != NULL)
{
delete[] _detwindow;
_detwindow = NULL;
}
if (getFlagStr() == STR_ANCHOR)
{
if (_anchor != NULL)
{
for (int i = 0; i < getAnchorDim(); i++)
{
if (getAnchor()[i].array != NULL)
{
delete[] getAnchor()[i].array;
getAnchor()[i].array = NULL;
}
}
delete[] _anchor;
_anchor = NULL;
}
if (_score != NULL)
{
for (int i = 0; i < getScoreDim(); i++)
{
if (_score[i] != NULL)
{
cvReleaseMat (&_score[i]);
_score[i] = NULL;
}
}
delete[] _score;
_score = NULL;
}
}
if (_Ix != NULL)
{
for (int i = 0; i < getIxDim(); i++)
{
if (_Ix[i] != NULL)
{
cvReleaseMat (&_Ix[i]);
_Ix[i] = NULL;
}
}
delete[] _Ix;
_Ix = NULL;
}
if (_Iy != NULL)
{
for (int i = 0; i < getIyDim(); i++)
{
if (_Iy[i] != NULL)
{
cvReleaseMat (&_Iy[i]);
_Iy[i] = NULL;
}
}
delete[]_Iy;
_Iy = NULL;
}
}
setFlagStr (INVALID_STR);
}
int main( int argc, char** argv ) {
struct feature* feat1, * feat2, * feat;
struct feature** nbrs;
struct kd_node* kd_root;
double d0, d1;
int n1, n2, k, i, m = 0;
if( argc != 3 )
fatal_error( "usage: %s <keydescr1> <keydescr2>", argv[0] );
n1 = import_features( argv[1], feat_type, &feat1 );
n2 = import_features( argv[2], feat_type, &feat2 );
if( n1 < 0 )
fatal_error( "unable to load key descriptors from %s", argv[1] );
if( n2 < 0 )
fatal_error( "unable to load key descriptors from %s", argv[2] );
printf("%d features presenti nel modello.\n", n1);
printf("%d features presenti nell'immagine.\n", n2);
kd_root = kdtree_build( feat2, n2 );
for( i = 0; i < n1; i++ ) {
feat = feat1 + i;
k = kdtree_bbf_knn( kd_root, feat, 2, &nbrs, KDTREE_BBF_MAX_NN_CHKS );
if( k == 2 ) {
// Controlla
d0 = descr_dist_sq( feat, nbrs[0] );
d1 = descr_dist_sq( feat, nbrs[1] );
if( d0 < d1 * NN_SQ_DIST_RATIO_THR ) {
m++;
feat1[i].fwd_match = nbrs[0];
}
}
free( nbrs );
}
#ifdef RANSAC
{
CvMat* H;
IplImage* xformed;
struct feature ** inliers;
int n_inliers;
H = ransac_xform( feat1, n1, FEATURE_FWD_MATCH, lsq_homog, 4, 0.01, homog_xfer_err, 8.0, &inliers, &n_inliers );
if( H )
{
if ( cvmGet( H, 1, 2 ) < 120.0 &&
cvmGet( H, 0, 2 ) < 120.0 &&
(
fabs(cvmGet( H, 0, 0)) >= 0.000001 ||
fabs(cvmGet( H, 0, 1)) >= 0.000001 ||
fabs(cvmGet( H, 1, 0)) >= 0.000001 ||
fabs(cvmGet( H, 1, 1)) >= 0.000001 ||
fabs(cvmGet( H, 2, 0)) >= 0.000001 ||
fabs(cvmGet( H, 2, 1)) >= 0.000001
)
) {
// TROVATO
printf("RANSAC OK\n");
/*
xformed = cvCreateImage( cvGetSize( img2 ), IPL_DEPTH_8U, 3 );
cvWarpPerspective( img1, xformed, H, CV_INTER_LINEAR + CV_WARP_FILL_OUTLIERS, cvScalarAll( 0 ) );
cvNamedWindow( "Xformed", 1 );
cvShowImage( "Xformed", xformed );
cvWaitKey( 0 );
cvReleaseImage( &xformed );
*/
printf("N. inliers: %d\n", n_inliers);
}
else {
// Trovato ma probabilmente la matrice di trasformazione e' sbagliata.
printf("RANSAC FAIL\n");
}
cvReleaseMat( &H );
}
else {
printf("RANSAC FAIL\n");
}
}
#endif
fprintf( stderr, "Found %d total matches\n", m );
kdtree_release( kd_root );
free( feat1 );
free( feat2 );
return 0;
}
void ShiftMapHierarchy::ComputeFastShiftMap(IplImage* input, IplImage* saliency, CvSize output)
{
printf("Downsampling...");
_imageList = new vector<IplImage*>(0);
_labelMapList = new vector<CvMat*>(0);
vector<IplImage*>* imageSList = new vector<IplImage*>(0);
vector<CvSize>* outputSizeList = new vector<CvSize>(0);
_imageList->push_back(input);
imageSList->push_back(saliency);
outputSizeList->push_back(output);
IplImage* level = input;
IplImage* levelS = saliency;
CvSize levelSize = output;
int levelCount = 0;
while(level->width >20 && level->height > 20)
{
IplImage* level_temp = cvCreateImage(cvSize(level->width/2, level->height/2), input->depth, input->nChannels);
IplImage* levelS_temp = cvCreateImage(cvSize(level->width/2, level->height/2), input->depth, input->nChannels);
DownSampling(level, level_temp);
DownSampling(levelS, levelS_temp);
//
//cvPyrDown(level, level_temp);
//cvPyrDown(levelS, levelS_temp);
level = level_temp;
levelS = levelS_temp;
levelCount++;
CvSize output_temp;
output_temp.width = levelSize.width / 2;
output_temp.height = levelSize.height / 2;
levelSize = output_temp;
_imageList->push_back(level);
imageSList->push_back(levelS);
outputSizeList->push_back(levelSize);
}
// dummy initialGuess - just to be released later
_initialGuess = cvCreateMat(10,10, CV_32SC2);
_level = levelCount;
//int index = levelCount;
for(int i = levelCount; i >= 0; i--)
{
if(i == levelCount)
// first level does not require an initialGuess
ComputeShiftMap((*_imageList)[i], (*imageSList)[i], (*outputSizeList)[i], cvSize((*_imageList)[i]->width, (*_imageList)[i]->height));
else
ComputeShiftMapGuess((*_imageList)[i], (*imageSList)[i], _initialGuess, (*outputSizeList)[i], cvSize(3,3));
//
//if(i == levelCount - 3)
//{
// IplImage* image = GetRetargetImage();
// //IplImage* image = (*imageSList)[i];
// cvNamedWindow("test");
// while(1)
// {
// cvShowImage("test", image);
// cvWaitKey(100);
// }
//}
// save result
CvMat* labelMap;
if(i == levelCount)
labelMap = CalculateLabelMap();
else
labelMap = CalculateLabelMapGuess();
_labelMapList->insert(_labelMapList->begin(), labelMap);
if(i > 0)
{
cvReleaseMat(&_initialGuess);
_initialGuess = cvCreateMat((*outputSizeList)[i-1].height, (*outputSizeList)[i-1].width , CV_32SC2);
GetInterpolationMap(labelMap, _initialGuess);
//if(i == index)
//{
// IplImage* image = GetImageFromLabelMap(_initialGuess, (*_imageList)[i-1]);
// //IplImage* image = (*imageList)[0];
// cvNamedWindow("test");
// while(1)
// {
// cvShowImage("test", image);
// int key = cvWaitKey(100);
// if(key == 32)
// {
// index--;
// break;
// }
// }
//}
ClearGC();
}
}
}
static void*
imdecode_( const Mat& buf, int flags, int hdrtype, Mat* mat=0 )
{
CV_Assert(!buf.empty() && buf.isContinuous());
IplImage* image = 0;
CvMat *matrix = 0;
Mat temp, *data = &temp;
String filename;
ImageDecoder decoder = findDecoder(buf);
if( !decoder )
return 0;
if( !decoder->setSource(buf) )
{
filename = tempfile();
FILE* f = fopen( filename.c_str(), "wb" );
if( !f )
return 0;
size_t bufSize = buf.cols*buf.rows*buf.elemSize();
fwrite( buf.ptr(), 1, bufSize, f );
fclose(f);
decoder->setSource(filename);
}
if( !decoder->readHeader() )
{
decoder.release();
if ( !filename.empty() )
{
if ( remove(filename.c_str()) != 0 )
{
CV_Error( CV_StsError, "unable to remove temporary file" );
}
}
return 0;
}
CvSize size;
size.width = decoder->width();
size.height = decoder->height();
int type = decoder->type();
if( (flags & IMREAD_LOAD_GDAL) != IMREAD_LOAD_GDAL && flags != IMREAD_UNCHANGED )
{
if( (flags & CV_LOAD_IMAGE_ANYDEPTH) == 0 )
type = CV_MAKETYPE(CV_8U, CV_MAT_CN(type));
if( (flags & CV_LOAD_IMAGE_COLOR) != 0 ||
((flags & CV_LOAD_IMAGE_ANYCOLOR) != 0 && CV_MAT_CN(type) > 1) )
type = CV_MAKETYPE(CV_MAT_DEPTH(type), 3);
else
type = CV_MAKETYPE(CV_MAT_DEPTH(type), 1);
}
if( hdrtype == LOAD_CVMAT || hdrtype == LOAD_MAT )
{
if( hdrtype == LOAD_CVMAT )
{
matrix = cvCreateMat( size.height, size.width, type );
temp = cvarrToMat(matrix);
}
else
{
mat->create( size.height, size.width, type );
data = mat;
}
}
else
{
image = cvCreateImage( size, cvIplDepth(type), CV_MAT_CN(type) );
temp = cvarrToMat(image);
}
bool code = decoder->readData( *data );
decoder.release();
if ( !filename.empty() )
{
if ( remove(filename.c_str()) != 0 )
{
CV_Error( CV_StsError, "unable to remove temporary file" );
}
}
if( !code )
{
cvReleaseImage( &image );
cvReleaseMat( &matrix );
if( mat )
mat->release();
return 0;
}
return hdrtype == LOAD_CVMAT ? (void*)matrix :
hdrtype == LOAD_IMAGE ? (void*)image : (void*)mat;
}
static int icvL1QCNewton( CvAAtOpsData& AAtData, CvMat* B, CvMat* X, CvMat* U, double epsilon, double tau, CvTermCriteria nt_term_crit, CvTermCriteria cg_term_crit )
{
const double alpha = .01;
const double beta = .5;
CvMat* R = cvCreateMat( B->rows, B->cols, CV_MAT_TYPE(B->type) );
AAtData.AOps( X, AAtData.AR, AAtData.userdata );
cvSub( AAtData.AR, B, R );
CvMat* fu1 = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* fu2 = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* lfu1 = cvCreateMat( fu1->rows, fu1->cols, CV_MAT_TYPE(fu1->type) );
CvMat* lfu2 = cvCreateMat( fu2->rows, fu2->cols, CV_MAT_TYPE(fu2->type) );
cvSub( U, X, lfu1 );
cvAdd( X, U, lfu2 );
cvSubRS( lfu1, cvScalar(0), fu1 );
cvSubRS( lfu2, cvScalar(0), fu2 );
double epsilon2 = epsilon * epsilon;
double tau_inv = 1. / tau;
double fe = .5 * (cvDotProduct( R, R ) - epsilon2);
double fe_inv = 1. / fe;
cvLog( lfu1, lfu1 );
cvLog( lfu2, lfu2 );
CvScalar sumU = cvSum( U );
CvScalar sumfu1 = cvSum( lfu1 );
CvScalar sumfu2 = cvSum( lfu2 );
double f = sumU.val[0] - tau_inv * (sumfu1.val[0] + sumfu2.val[0] + log(-fe));
CvMat* atr = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* ntgx = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* ntgu = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* sig1211 = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* sigx = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* w1 = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* du = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* pX = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* pU = cvCreateMat( U->rows, U->cols, CV_MAT_TYPE(U->type) );
CvMat* pR = cvCreateMat( R->rows, R->cols, CV_MAT_TYPE(R->type) );
CvMat* pfu1 = cvCreateMat( fu1->rows, fu1->cols, CV_MAT_TYPE(fu1->type) );
CvMat* pfu2 = cvCreateMat( fu2->rows, fu2->cols, CV_MAT_TYPE(fu2->type) );
CvMat* Adx = cvCreateMat( B->rows, B->cols, CV_MAT_TYPE(B->type) );
CvMat* dx = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
CvMat* tX = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
int result = nt_term_crit.max_iter;
CvH11OpsData H11OpsData;
H11OpsData.AOps = AAtData.AOps;
H11OpsData.AtOps = AAtData.AtOps;
H11OpsData.AR = AAtData.AR;
H11OpsData.AtR = AAtData.AtR;
H11OpsData.userdata = AAtData.userdata;
H11OpsData.tX = tX;
H11OpsData.atr = atr;
H11OpsData.sigx = sigx;
int t, i;
for ( t = 0; t < nt_term_crit.max_iter; ++t )
{
AAtData.AtOps( R, atr, AAtData.userdata );
double* atrp = atr->data.db;
double* fu1p = fu1->data.db;
double* fu2p = fu2->data.db;
double* ntgxp = ntgx->data.db;
double* ntgup = ntgu->data.db;
double* sig1211p = sig1211->data.db;
double* sigxp = sigx->data.db;
double* w1p = w1->data.db;
double* dup = du->data.db;
for ( i = 0; i < X->rows; ++i, ++atrp, ++fu1p, ++fu2p, ++ntgxp, ++ntgup, ++sig1211p, ++sigxp, ++w1p, ++dup )
{
double fu1_inv = 1. / (*fu1p);
double fu2_inv = 1. / (*fu2p);
double ntgxv = fu1_inv - fu2_inv + fe_inv * (*atrp);
double ntguv = -tau - fu1_inv - fu2_inv;
double sig11 = fu1_inv * fu1_inv + fu2_inv * fu2_inv;
double sig12 = -fu1_inv * fu1_inv + fu2_inv * fu2_inv;
*sig1211p = sig12 / sig11;
*sigxp = sig11 - sig12 * (*sig1211p);
*w1p = ntgxv - (*sig1211p) * ntguv;
*ntgxp = -tau_inv * ntgxv;
*ntgup = -tau_inv * ntguv;
*dup = ntguv / sig11;
}
H11OpsData.fe_inv = fe_inv;
H11OpsData.fe_inv_2 = fe_inv * fe_inv;
if ( cvCGSolve( icvH11Ops, &H11OpsData, w1, dx, cg_term_crit ) > .5 )
{
result = t;
goto __clean_up__;
}
AAtData.AOps( dx, Adx, AAtData.userdata );
dup = du->data.db;
sig1211p = sig1211->data.db;
double* dxp = dx->data.db;
for ( i = 0; i < X->rows; ++i, ++dup, ++sig1211p, ++dxp )
*dup -= (*sig1211p) * (*dxp);
/* minimum step size that stays in the interior */
double aqe = cvDotProduct( Adx, Adx );
double bqe = 2. * cvDotProduct( R, Adx );
double cqe = cvDotProduct( R, R ) - epsilon2;
double smax = MIN( 1, -bqe + sqrt( bqe * bqe - 4 * aqe * cqe ) / (2 * aqe) );
dup = du->data.db;
dxp = dx->data.db;
fu1p = fu1->data.db;
fu2p = fu2->data.db;
for ( i = 0; i < X->rows; ++i, ++dup, ++dxp, ++fu1p, ++fu2p )
{
if ( (*dxp) - (*dup) > 0 )
smax = MIN( smax, -(*fu1p) / ((*dxp) - (*dup)) );
if ( (*dxp) + (*dup) < 0 )
smax = MIN( smax, (*fu2p) / ((*dxp) + (*dup)) );
}
smax *= .99;
/* backtracking line search */
bool suffdec = 0;
int backiter = 0;
double fep = fe;
double fp = f;
double lambda2;
while (!suffdec)
{
cvAddWeighted( X, 1, dx, smax, 0, pX );
cvAddWeighted( U, 1, du, smax, 0, pU );
cvAddWeighted( R, 1, Adx, smax, 0, pR );
cvSub( pU, pX, lfu1 );
cvAdd( pX, pU, lfu2 );
cvSubRS( lfu1, cvScalar(0), pfu1 );
cvSubRS( lfu2, cvScalar(0), pfu2 );
fep = .5 * (cvDotProduct( pR, pR ) - epsilon2);
cvLog( lfu1, lfu1 );
cvLog( lfu2, lfu2 );
CvScalar sumpU = cvSum( pU );
CvScalar sumpfu1 = cvSum( pfu1 );
CvScalar sumpfu2 = cvSum( pfu2 );
fp = sumpU.val[0] - tau_inv * (sumpfu1.val[0] + sumpfu2.val[0] + log(-fep));
lambda2 = cvDotProduct( ntgx, dx ) + cvDotProduct( ntgu, du );
double flin = f + alpha * smax * lambda2;
suffdec = (fp <= flin);
smax = beta * smax;
++backiter;
if ( backiter > 32 )
{
result = t;
goto __clean_up__;
}
}
/* set up for next iteration */
cvCopy( pX, X );
cvCopy( pU, U );
cvCopy( pR, R );
cvCopy( pfu1, fu1 );
cvCopy( pfu2, fu2 );
fe = fep;
fe_inv = 1. / fe;
f = fp;
lambda2 = -lambda2 * .5;
if ( lambda2 < nt_term_crit.epsilon )
{
result = t + 1;
break;
}
}
__clean_up__:
cvReleaseMat( &pfu2 );
cvReleaseMat( &pfu1 );
cvReleaseMat( &pR );
cvReleaseMat( &pU );
cvReleaseMat( &pX );
cvReleaseMat( &tX );
cvReleaseMat( &dx );
cvReleaseMat( &Adx );
cvReleaseMat( &du );
cvReleaseMat( &w1 );
cvReleaseMat( &sigx );
cvReleaseMat( &sig1211 );
cvReleaseMat( &ntgu );
cvReleaseMat( &ntgx );
cvReleaseMat( &lfu2 );
cvReleaseMat( &lfu1 );
cvReleaseMat( &fu2 );
cvReleaseMat( &fu1 );
cvReleaseMat( &R );
return result;
}
/**
* Read an image into memory and return the information
*
* @param[in] filename File to load
* @param[in] flags Flags
* @param[in] hdrtype { LOAD_CVMAT=0,
* LOAD_IMAGE=1,
* LOAD_MAT=2
* }
* @param[in] mat Reference to C++ Mat object (If LOAD_MAT)
* @param[in] scale_denom Scale value
*
*/
static void*
imread_( const String& filename, int flags, int hdrtype, Mat* mat=0 )
{
IplImage* image = 0;
CvMat *matrix = 0;
Mat temp, *data = &temp;
/// Search for the relevant decoder to handle the imagery
ImageDecoder decoder;
#ifdef HAVE_GDAL
if(flags != IMREAD_UNCHANGED && (flags & IMREAD_LOAD_GDAL) == IMREAD_LOAD_GDAL ){
decoder = GdalDecoder().newDecoder();
}else{
#endif
decoder = findDecoder( filename );
#ifdef HAVE_GDAL
}
#endif
/// if no decoder was found, return nothing.
if( !decoder ){
return 0;
}
int scale_denom = 1;
if( flags > IMREAD_LOAD_GDAL )
{
if( flags & IMREAD_REDUCED_GRAYSCALE_2 )
scale_denom = 2;
else if( flags & IMREAD_REDUCED_GRAYSCALE_4 )
scale_denom = 4;
else if( flags & IMREAD_REDUCED_GRAYSCALE_8 )
scale_denom = 8;
}
/// set the scale_denom in the driver
decoder->setScale( scale_denom );
/// set the filename in the driver
decoder->setSource( filename );
// read the header to make sure it succeeds
if( !decoder->readHeader() )
return 0;
// established the required input image size
CvSize size;
size.width = decoder->width();
size.height = decoder->height();
// grab the decoded type
int type = decoder->type();
if( (flags & IMREAD_LOAD_GDAL) != IMREAD_LOAD_GDAL && flags != IMREAD_UNCHANGED )
{
if( (flags & CV_LOAD_IMAGE_ANYDEPTH) == 0 )
type = CV_MAKETYPE(CV_8U, CV_MAT_CN(type));
if( (flags & CV_LOAD_IMAGE_COLOR) != 0 ||
((flags & CV_LOAD_IMAGE_ANYCOLOR) != 0 && CV_MAT_CN(type) > 1) )
type = CV_MAKETYPE(CV_MAT_DEPTH(type), 3);
else
type = CV_MAKETYPE(CV_MAT_DEPTH(type), 1);
}
if( hdrtype == LOAD_CVMAT || hdrtype == LOAD_MAT )
{
if( hdrtype == LOAD_CVMAT )
{
matrix = cvCreateMat( size.height, size.width, type );
temp = cvarrToMat( matrix );
}
else
{
mat->create( size.height, size.width, type );
data = mat;
}
}
else
{
image = cvCreateImage( size, cvIplDepth(type), CV_MAT_CN(type) );
temp = cvarrToMat( image );
}
// read the image data
if( !decoder->readData( *data ))
{
cvReleaseImage( &image );
cvReleaseMat( &matrix );
if( mat )
mat->release();
return 0;
}
if( decoder->setScale( scale_denom ) > 1 ) // if decoder is JpegDecoder then decoder->setScale always returns 1
{
resize( *mat, *mat, Size( size.width / scale_denom, size.height / scale_denom ) );
}
return hdrtype == LOAD_CVMAT ? (void*)matrix :
hdrtype == LOAD_IMAGE ? (void*)image : (void*)mat;
}
int match_X(IplImage* binary, CvPoint* points, int pixel_count, CvPoint* r_point, int cent_x, int cent_y, IplImage* debug){
int i,x,y; //useful variable names
CvPoint* corners; //the corners of the image
corners = (CvPoint*)calloc(4, sizeof(CvPoint));
corners[0].x = r_point->x;
corners[0].y = r_point->y;
//find the angle of the first corner
x = corners[0].x - cent_x;
y = corners[0].y - cent_y;
int theta = arctan(y,x);
//find the other 3 corners
int maxr1 = 0;
int maxr2 = 0;
int maxr3 = 0;
//keep track of the pixel sums on either side of angle0
int pxsum1 = 0; //this is bigger --> corner 0 goes in upper left
int pxsum2 = 0; // this is bigger --> corner 0 goes in upper right
for(i = pixel_count -1; i>=0; i--){
x = points[i].x - cent_x;
y = points[i].y - cent_y;
int tempang = arctan(y,x);
//normalize angles
if (tempang < theta) tempang += 360;
//find tempr
int tempr = (int)sqrt((double)(x*x + y*y));
if( tempang - theta > 315 ){
//we are in the same quadrant as the origional angle
pxsum1++;
} else if( tempang - theta > 225){
//call this quadrant 3
if( tempr > maxr3){
maxr3 = tempr;
corners[3].x = points[i].x;
corners[3].y = points[i].y;
}
} else if( tempang - theta > 135) {
//call this quadrant 2
if( tempr > maxr2) {
maxr2 = tempr;
corners[2].x = points[i].x;
corners[2].y = points[i].y;
}
} else if( tempang - theta > 45) {
//call this quadrant 1
if( tempr > maxr1) {
maxr1 = tempr;
corners[1].x = points[i].x;
corners[1].y = points[i].y;
}
} else {
//we are again in the same quadrant as the origional angle
pxsum2++;
}
#ifdef VISUAL_DEBUG_X
//color every quadrant a different color
if( tempang - theta > 315 ){
debug->imageData[3*points[i].y*debug->width+3*points[i].x+2]=0;
debug->imageData[3*points[i].y*debug->width+3*points[i].x+1]=254;
debug->imageData[3*points[i].y*debug->width+3*points[i].x+0]=254;
} else if( tempang - theta > 225){
debug->imageData[3*points[i].y*debug->width+3*points[i].x+2]=254;
debug->imageData[3*points[i].y*debug->width+3*points[i].x+1]=0;
debug->imageData[3*points[i].y*debug->width+3*points[i].x+0]=0;
} else if( tempang - theta > 135) {
debug->imageData[3*points[i].y*debug->width+3*points[i].x+2]=0;
debug->imageData[3*points[i].y*debug->width+3*points[i].x+1]=0;
debug->imageData[3*points[i].y*debug->width+3*points[i].x+0]=254;
} else if( tempang - theta > 45) {
debug->imageData[3*points[i].y*debug->width+3*points[i].x+2]=254;
debug->imageData[3*points[i].y*debug->width+3*points[i].x+1]=0;
debug->imageData[3*points[i].y*debug->width+3*points[i].x+0]=254;
} else {
debug->imageData[3*points[i].y*debug->width+3*points[i].x+2]=0;
debug->imageData[3*points[i].y*debug->width+3*points[i].x+1]=254;
debug->imageData[3*points[i].y*debug->width+3*points[i].x+0]=0;
}
#endif
}
#ifdef VISUAL_DEBUG_X
//draw a line between consecutive corners
CvScalar boxcolor = {{0, 254, 0}};
cvLine(debug, corners[0], corners[1], boxcolor, 1, 8, 0);
cvLine(debug, corners[1], corners[2], boxcolor, 1, 8, 0);
cvLine(debug, corners[2], corners[3], boxcolor, 1, 8, 0);
cvLine(debug, corners[3], corners[0], boxcolor, 1, 8, 0);
//draw a circle at the center of the image
CvPoint center = {cent_x, cent_y};
CvScalar centercolor = {{0, 0, 254}};
cvCircle(debug, center, 5, centercolor, 2, 8, 0);
//mark corner 0
CvPoint corner0 = {corners[0].x, corners[0].y};
CvScalar cornercolor = {{254, 0, 254}};
cvCircle(debug, corner0, 5, cornercolor, 1, 8, 0);
#endif
//load template
IplImage* xtemplate = cvLoadImage("../vision/xtemplate.png",CV_LOAD_IMAGE_GRAYSCALE);
//get transformation matrix that would place corner values
//in the correct location to compare to template
//transform image
//create an array for the 4 src points and dest points
CvPoint2D32f* src;
CvPoint2D32f* dst;
src = (CvPoint2D32f*)calloc(4, sizeof(CvPoint2D32f));
dst = (CvPoint2D32f*)calloc(4, sizeof(CvPoint2D32f));
//populate the src array
if( pxsum1 >= pxsum2 ){
for ( i=0; i<4; i++){
src[i].x = corners[i].x;
src[i].y = corners[i].y;
}
}else{
for ( i=0; i<4; i++){
int j = i-1;
if ( j<0 ) j = 3;
src[i].x = corners[j].x;
src[i].y = corners[j].y;
}
}
//populate the dst array
dst[0].x = 0;
dst[0].y = 0;
dst[1].x = 0;
dst[1].y = 100;
dst[2].x = 100;
dst[2].y = 100;
dst[3].x = 100;
dst[3].y = 0;
//get the transformation matrix
CvMat* tmatrix = cvCreateMat(3,3,CV_32FC1);
tmatrix = cvGetPerspectiveTransform( src, dst, tmatrix);
//transform the image
CvSize warpedsize = {100,100};
IplImage* warped = cvCreateImage(warpedsize, 8, 1);
CvScalar fillcolor = {{0}};
cvWarpPerspective(binary, warped, tmatrix,CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS , fillcolor);
#ifdef VISUAL_DEBUG_X
IplImage* compared = cvCreateImage(cvGetSize(xtemplate),8,3);
#endif
//XOR the template image with our warped image
int xor_sum = 0;
for ( i=xtemplate->width*xtemplate->height -1; i>=0; i--){
int p1 = xtemplate->imageData[i];
int p2 = warped->imageData[i];
if(( p1 != 0 && p2 != 0 ) || ( p1 == 0 && p2 == 0 )){
xor_sum++;
}
#ifdef VISUAL_DEBUG_X
if(p1 != 0 && p2 != 0){
compared->imageData[i*3+0] = 0x00;
compared->imageData[i*3+1] = 0xff;
compared->imageData[i*3+2] = 0x00;
}else if(p1 == 0 && p2 == 0){
compared->imageData[i*3+0] = 0x00;
compared->imageData[i*3+1] = 0xff;
compared->imageData[i*3+2] = 0x00;
}else if(p1 != 0){
compared->imageData[i*3+0] = 0xff;
compared->imageData[i*3+1] = 0x00;
compared->imageData[i*3+2] = 0x00;
}else if(p2 != 0){
compared->imageData[i*3+0] = 0xff;
compared->imageData[i*3+1] = 0x00;
compared->imageData[i*3+2] = 0x00;
}
#endif
}
//compute confidence
int confidence = xor_sum * 100 / (xtemplate->width*xtemplate->height);
#ifdef VISUAL_DEBUG_X
cvNamedWindow("Compared",CV_WINDOW_AUTOSIZE);
cvShowImage("Compared", compared);
cvNamedWindow("Warped", CV_WINDOW_AUTOSIZE);
cvShowImage("Warped", warped);
cvNamedWindow("Xtemplate", CV_WINDOW_AUTOSIZE);
cvShowImage("Xtemplate",xtemplate);
#endif
//free memory
cvReleaseImage(&xtemplate);
cvReleaseImage(&warped);
free(corners);
free(src);
free(dst);
cvReleaseMat(&tmatrix);
#ifdef VISUAL_DEBUG_X
cvReleaseImage(&compared);
#endif
return confidence;
}
CvMat* vgg_X_from_xP_nonlin(CvMat* u1, CvMat** P1, CvMat* imsize1, int K)
{
CvMat* u;
CvMat** P=new CvMat* [K];
CvMat* imsize;
u=cvCreateMat(u1->rows,u1->cols,u1->type);
cvCopy(u1,u);
int kp;
for(kp=0;kp<K;kp++)
{
P[kp]=cvCreateMat(P1[kp]->rows,P1[kp]->cols,P1[kp]->type);
cvCopy(P1[kp],P[kp]);
}
imsize=cvCreateMat(imsize1->rows,imsize1->cols,imsize1->type);
cvCopy(imsize1,imsize);
CvMat* X;
CvMat* H;
CvMat* u_2_rows;
CvMat* W;
CvMat* U;
CvMat* T;
CvMat* Y;
CvMat** Q=new CvMat*[K];//Q is a variable not well defined
CvMat* J;
CvMat* e;
CvMat* J_tr;
CvMat* eprev;
CvMat* JtJ;
CvMat* Je;
CvMat* Y_new;
CvMat* T_2_cols;
CvMat* T_rest_cols;
CvMat* X_T;
CvScalar f, inf;
int i, mat_id;
int u_rows = u->rows;
int u_cols = u->cols;
double lambda_min, lambda_max;
CvMat* imsize_col = cvCreateMat(2, 1, CV_64FC1);
/* K is the number of images */
if(K < 2)
{
printf("\n Cannot reconstruct 3D from 1 image");
return 0;
}
/* Create temporary matrix for the linear function */
u_2_rows = cvCreateMat(2, u_cols, CV_64FC1);
/* Initialize the temporary matrix by extracting the first two rows */
u_2_rows = cvGetRows(u, u_2_rows, 0, 2, 1);
/* Call the linear function */
X = vgg_X_from_xP_lin(u_2_rows, P, K, imsize);
imsize_col = cvGetCol(imsize, imsize_col, 0);
f = cvSum(imsize_col);
f.val[0] = 4 / f.val[0];
/* Create and initialize H matrix */
H = cvCreateMat(3, 3, CV_64FC1);
H->data.db[0] = f.val[0];
H->data.db[1] = 0;
H->data.db[2] = ((-1) * f.val[0] * cvmGet(imsize, 0, 0)) / 2;
H->data.db[3] = 0;
H->data.db[4] = f.val[0];
H->data.db[5] = ((-1) * f.val[0] * cvmGet(imsize, 1, 0)) / 2;
H->data.db[6] = 0;
H->data.db[7] = 0;
H->data.db[8] = 1;
for(mat_id = 0; mat_id < K ; mat_id++)
{
cvMatMul(H, P[mat_id], P[mat_id]);
}
/* u = H * u; */
cvMatMul(H, u, u);
/*
//debug
printf("....H\n");
CvMat_printdb(stdout,"%7.3f ",H);
//debug
printf("....u\n");
CvMat_printdb(stdout,"%7.3f ",u);
*/
/* Parametrize X such that X = T*[Y;1]; thus x = P*T*[Y;1] = Q*[Y;1] */
/* Create the SVD matrices X = U*W*V'*/
X_T = cvCreateMat(X->cols, X->rows, CV_64FC1); /* M * N */
W = cvCreateMat(X_T->rows, X_T->cols, CV_64FC1); /* M * N */
U = cvCreateMat(X_T->rows, X_T->rows, CV_64FC1); /* M * M */
T = cvCreateMat(X_T->cols, X_T->cols, CV_64FC1); /* N * N */
cvTranspose(X, X_T);
cvSVD(X_T, W, U, T);
cvReleaseMat(&W);
/* T = T(:,[2:end 1]); */
/* Initialize the temporary matrix by extracting the first two columns */
/* Create temporary matrix for the linear function */
T_2_cols = cvCreateMat(T->rows, 2, CV_64FC1);
T_rest_cols = cvCreateMat(T->rows, (T->cols - 2), CV_64FC1);
/* Initialize the temporary matrix by extracting the first two columns */
T_2_cols= sfmGetCols(T,0,0);
T_rest_cols=sfmGetCols(T,1,T->cols-1);
T=sfmAlignMatH(T_rest_cols,T_2_cols);
for(mat_id = 0; mat_id < K ; mat_id++)
{
/* Create temporary matrix for the linear function */
Q[mat_id] = cvCreateMat(P[mat_id]->rows, T->cols, CV_64FC1);
cvMatMul(P[mat_id], T, Q[mat_id]);
}
/*
//debug
printf("....Q0\n");
CvMat_printdb(stdout,"%7.3f ",Q[0]);
//debug
printf("....Q1\n");
CvMat_printdb(stdout,"%7.3f ",Q[1]);
*/
/* Newton estimation */
/* Create the required Y matrix for the Newton process */
Y = cvCreateMat(3, 1, CV_64FC1);
cvSetZero(Y); /* Y = [0;0;0] */
/* Initialize the infinite array */
inf.val[0] = INF;
inf.val[1] = INF;
inf.val[2] = INF;
inf.val[3] = INF;
eprev = cvCreateMat(1, 1, CV_64FC1);
cvSet(eprev, inf, 0);
for(i = 0 ; i < 10 ; i++)
{
// printf("i=%d....\n",i);
int pass;
double RCondVal;
//initialize e,J before using.
e=cvCreateMat(2*K,1,CV_64FC1);
J=cvCreateMat(2*K,3,CV_64FC1);
pass = resid(Y, u, Q, K, e, J);
J_tr = cvCreateMat(J->cols, J->rows, CV_64FC1);
cvTranspose(J, J_tr);
JtJ = cvCreateMat(J->cols, J->cols, CV_64FC1);
cvMatMul(J_tr, J, JtJ);
//prevent memory leak;
cvReleaseMat(&W);
/* Create the SVD matrices JtJ = U*W*V'*/
W = cvCreateMat(J->cols, J->cols, CV_64FC1);
cvSVD(JtJ, W);
/*
//debug
printf("....W\n");
CvMat_printdb(stdout,"%7.3f ",W);
*/
lambda_max = W->data.db[0];
lambda_min = W->data.db[((W->rows * W->cols) - 1)];
RCondVal = lambda_min / lambda_max;
if(1 - (cvNorm(e, 0, CV_L2, 0) / cvNorm(eprev, 0, CV_L2, 0)) < 1000 * EPS)
{
cvReleaseMat(&J);
cvReleaseMat(&e);
cvReleaseMat(&J_tr);
cvReleaseMat(&JtJ);
cvReleaseMat(&W);
break;
}
if(RCondVal < 10 * EPS)
{
cvReleaseMat(&J);
cvReleaseMat(&e);
cvReleaseMat(&J_tr);
cvReleaseMat(&JtJ);
cvReleaseMat(&W);
break;
}
cvReleaseMat(&eprev);
eprev = cvCreateMat(e->rows, e->cols, CV_64FC1);
cvCopy(e, eprev);
Je = cvCreateMat(J->cols, e->cols, CV_64FC1);
cvMatMul(J_tr, e, Je); /* (J'*e) */
/*
//debug
printf("....J_tr\n");
CvMat_printdb(stdout,"%7.3f ",J_tr);
//debug
printf("....e\n");
CvMat_printdb(stdout,"%7.3f ",e);
//debug
printf("....JtJ\n");
CvMat_printdb(stdout,"%7.3f ",JtJ);
//debug
printf("....Je\n");
CvMat_printdb(stdout,"%7.3f ",Je);
//debug
printf("....JtJ\n");
CvMat_printdb(stdout,"%7.3f ",JtJ);
*/
cvInvert(JtJ,JtJ);
/* (J'*J)\(J'*e) */
Je=sfmMatMul(JtJ, Je);
/*
//debug
printf("....Je\n");
CvMat_printdb(stdout,"%7.3f ",Je);
*/
/* Y = Y - (J'*J)\(J'*e) */
cvSub(Y, Je, Y, 0);
/*
//debug
printf("....Y\n");
CvMat_printdb(stdout,"%7.3f ",Y);
*/
cvReleaseMat(&J);
cvReleaseMat(&e);
cvReleaseMat(&J_tr);
cvReleaseMat(&JtJ);
cvReleaseMat(&Je);
cvReleaseMat(&W);
}
Y_new = cvCreateMat(4, 1, CV_64FC1);
PutMatV(Y,Y_new,0);
Y_new->data.db[3]=1;
/*
//debug
printf("....Y_new\n");
CvMat_printdb(stdout,"%7.3f ",Y_new);
printf("....T\n");
CvMat_printdb(stdout,"%7.3f ",T);
*/
/* Obtain the new X */
cvMatMul(T, Y_new, X);
cvReleaseMat(&H);
cvReleaseMat(&u_2_rows);
cvReleaseMat(&U);
cvReleaseMat(&T);
cvReleaseMat(&Y);
cvReleaseMat(&Y_new);
cvReleaseMat(&T_2_cols);
cvReleaseMat(&T_rest_cols);
for(kp=0;kp<K;kp++)
{
cvReleaseMat(&P[kp]);
}
cvReleaseMat(&u);
cvReleaseMat(&imsize);
cvReleaseMatGrp(Q,K);
return X;
}
bool CvANN_MLP::prepare_to_train( const CvMat* _inputs, const CvMat* _outputs,
const CvMat* _sample_weights, const CvMat* _sample_idx,
CvVectors* _ivecs, CvVectors* _ovecs, double** _sw, int _flags )
{
bool ok = false;
CvMat* sample_idx = 0;
CvVectors ivecs, ovecs;
double* sw = 0;
int count = 0;
CV_FUNCNAME( "CvANN_MLP::prepare_to_train" );
ivecs.data.ptr = ovecs.data.ptr = 0;
assert( _ivecs && _ovecs );
__BEGIN__;
const int* sidx = 0;
int i, sw_type = 0, sw_count = 0;
int sw_step = 0;
double sw_sum = 0;
if( !layer_sizes )
CV_ERROR( CV_StsError,
"The network has not been created. Use method create or the appropriate constructor" );
if( !CV_IS_MAT(_inputs) || CV_MAT_TYPE(_inputs->type) != CV_32FC1 &&
CV_MAT_TYPE(_inputs->type) != CV_64FC1 || _inputs->cols != layer_sizes->data.i[0] )
CV_ERROR( CV_StsBadArg,
"input training data should be a floating-point matrix with"
"the number of rows equal to the number of training samples and "
"the number of columns equal to the size of 0-th (input) layer" );
if( !CV_IS_MAT(_outputs) || CV_MAT_TYPE(_outputs->type) != CV_32FC1 &&
CV_MAT_TYPE(_outputs->type) != CV_64FC1 ||
_outputs->cols != layer_sizes->data.i[layer_sizes->cols - 1] )
CV_ERROR( CV_StsBadArg,
"output training data should be a floating-point matrix with"
"the number of rows equal to the number of training samples and "
"the number of columns equal to the size of last (output) layer" );
if( _inputs->rows != _outputs->rows )
CV_ERROR( CV_StsUnmatchedSizes, "The numbers of input and output samples do not match" );
if( _sample_idx )
{
CV_CALL( sample_idx = cvPreprocessIndexArray( _sample_idx, _inputs->rows ));
sidx = sample_idx->data.i;
count = sample_idx->cols + sample_idx->rows - 1;
}
else
count = _inputs->rows;
if( _sample_weights )
{
if( !CV_IS_MAT(_sample_weights) )
CV_ERROR( CV_StsBadArg, "sample_weights (if passed) must be a valid matrix" );
sw_type = CV_MAT_TYPE(_sample_weights->type);
sw_count = _sample_weights->cols + _sample_weights->rows - 1;
if( sw_type != CV_32FC1 && sw_type != CV_64FC1 ||
_sample_weights->cols != 1 && _sample_weights->rows != 1 ||
sw_count != count && sw_count != _inputs->rows )
CV_ERROR( CV_StsBadArg,
"sample_weights must be 1d floating-point vector containing weights "
"of all or selected training samples" );
sw_step = CV_IS_MAT_CONT(_sample_weights->type) ? 1 :
_sample_weights->step/CV_ELEM_SIZE(sw_type);
CV_CALL( sw = (double*)cvAlloc( count*sizeof(sw[0]) ));
}
CV_CALL( ivecs.data.ptr = (uchar**)cvAlloc( count*sizeof(ivecs.data.ptr[0]) ));
CV_CALL( ovecs.data.ptr = (uchar**)cvAlloc( count*sizeof(ovecs.data.ptr[0]) ));
ivecs.type = CV_MAT_TYPE(_inputs->type);
ovecs.type = CV_MAT_TYPE(_outputs->type);
ivecs.count = ovecs.count = count;
for( i = 0; i < count; i++ )
{
int idx = sidx ? sidx[i] : i;
ivecs.data.ptr[i] = _inputs->data.ptr + idx*_inputs->step;
ovecs.data.ptr[i] = _outputs->data.ptr + idx*_outputs->step;
if( sw )
{
int si = sw_count == count ? i : idx;
double w = sw_type == CV_32FC1 ?
(double)_sample_weights->data.fl[si*sw_step] :
_sample_weights->data.db[si*sw_step];
sw[i] = w;
if( w < 0 )
CV_ERROR( CV_StsOutOfRange, "some of sample weights are negative" );
sw_sum += w;
}
}
// normalize weights
if( sw )
{
sw_sum = sw_sum > DBL_EPSILON ? 1./sw_sum : 0;
for( i = 0; i < count; i++ )
sw[i] *= sw_sum;
}
calc_input_scale( &ivecs, _flags );
CV_CALL( calc_output_scale( &ovecs, _flags ));
ok = true;
__END__;
if( !ok )
{
cvFree( &ivecs.data.ptr );
cvFree( &ovecs.data.ptr );
cvFree( &sw );
}
cvReleaseMat( &sample_idx );
*_ivecs = ivecs;
*_ovecs = ovecs;
*_sw = sw;
return ok;
}
void MainWindow::stereoVisionTest(QString image_path,int cornersX,int cornersY){
trace("stereoVisionTest ... ");
StereoVision* sv = new StereoVision(CAM_WIDTH,CAM_HEIGHT);
IplImage* images[2];
//perform calibration based on sets of 2 images (chessboard)
sv->calibrationStart(cornersX,cornersY);
// READ IN THE LIST OF CHESSBOARDS:
QString file_name;
for(int i=0;;i++){
for(int lr=0;lr<2;lr++){
file_name = tr("%1%2%3.jpg").arg(image_path).arg(i).arg(lr ? 'L' : 'R');
trace(file_name);
images[lr] = cvLoadImage( file_name.toLatin1(), 0 );
}
if(images[0] && images[1]){
trace(file_name);
sv->calibrationAddSample(images[0],images[1]);
for(int lr=0;lr<2;lr++)
cvReleaseImage(&images[lr]);
}else{
break;
}
}
sv->calibrationEnd();
sv->calibrationSave("stereovisiontest.dat");
//Once saved calibartion data can be loaded later with:
//sv->calibrationLoad("stereovisiontest.dat");
//test our calibartion with first image set:
CvSize imageSize = sv->getImageSize();
for(int lr=0;lr<2;lr++){
QString file_name = tr("%1%2%3.jpg").arg(image_path).arg(0).arg(lr ? 'L' : 'R');
images[lr] = cvLoadImage( file_name.toLatin1(), 0 );
}
//this method will compute sv->imagesRectified[0],sv->imagesRectified[1],sv->imageDepth,sv->imageDepthNormalized
sv->stereoProcess(images[0],images[1]);
//merge 2 rectified images in one image (pair) and display horizontal lines
//to evaluate rectification.
CvMat* pair = cvCreateMat( imageSize.height, imageSize.width*2,CV_8UC3 );
CvMat part;
cvGetCols( pair, &part, 0, imageSize.width );
cvCvtColor( sv->imagesRectified[0], &part, CV_GRAY2BGR );
cvGetCols( pair, &part, imageSize.width,imageSize.width*2 );
cvCvtColor( sv->imagesRectified[1], &part, CV_GRAY2BGR );
for(int j = 0; j < imageSize.height; j += 16 )
cvLine( pair, cvPoint(0,j),cvPoint(imageSize.width*2,j),CV_RGB(0,255,0));
//display the results
cvNamedWindow( "rectified", 1 );
cvShowImage( "rectified", pair );
cvNamedWindow( "depth", 1 );
cvShowImage( "depth", sv->imageDepthNormalized);
//free up memory
cvReleaseImage(&images[0]);
cvReleaseImage(&images[1]);
cvReleaseMat(&pair);
}
int CvANN_MLP::train_backprop( CvVectors x0, CvVectors u, const double* sw )
{
CvMat* dw = 0;
CvMat* buf = 0;
double **x = 0, **df = 0;
CvMat* _idx = 0;
int iter = -1, count = x0.count;
CV_FUNCNAME( "CvANN_MLP::train_backprop" );
__BEGIN__;
int i, j, k, ivcount, ovcount, l_count, total = 0, max_iter;
double *buf_ptr;
double prev_E = DBL_MAX*0.5, E = 0, epsilon;
max_iter = params.term_crit.max_iter*count;
epsilon = params.term_crit.epsilon*count;
l_count = layer_sizes->cols;
ivcount = layer_sizes->data.i[0];
ovcount = layer_sizes->data.i[l_count-1];
// allocate buffers
for( i = 0; i < l_count; i++ )
total += layer_sizes->data.i[i] + 1;
CV_CALL( dw = cvCreateMat( wbuf->rows, wbuf->cols, wbuf->type ));
cvZero( dw );
CV_CALL( buf = cvCreateMat( 1, (total + max_count)*2, CV_64F ));
CV_CALL( _idx = cvCreateMat( 1, count, CV_32SC1 ));
for( i = 0; i < count; i++ )
_idx->data.i[i] = i;
CV_CALL( x = (double**)cvAlloc( total*2*sizeof(x[0]) ));
df = x + total;
buf_ptr = buf->data.db;
for( j = 0; j < l_count; j++ )
{
x[j] = buf_ptr;
df[j] = x[j] + layer_sizes->data.i[j];
buf_ptr += (df[j] - x[j])*2;
}
// run back-propagation loop
/*
y_i = w_i*x_{i-1}
x_i = f(y_i)
E = 1/2*||u - x_N||^2
grad_N = (x_N - u)*f'(y_i)
dw_i(t) = momentum*dw_i(t-1) + dw_scale*x_{i-1}*grad_i
w_i(t+1) = w_i(t) + dw_i(t)
grad_{i-1} = w_i^t*grad_i
*/
for( iter = 0; iter < max_iter; iter++ )
{
int idx = iter % count;
double* w = weights[0];
double sweight = sw ? count*sw[idx] : 1.;
CvMat _w, _dw, hdr1, hdr2, ghdr1, ghdr2, _df;
CvMat *x1 = &hdr1, *x2 = &hdr2, *grad1 = &ghdr1, *grad2 = &ghdr2, *temp;
if( idx == 0 )
{
if( fabs(prev_E - E) < epsilon )
break;
prev_E = E;
E = 0;
// shuffle indices
for( i = 0; i < count; i++ )
{
int tt;
j = (unsigned)cvRandInt(&rng) % count;
k = (unsigned)cvRandInt(&rng) % count;
CV_SWAP( _idx->data.i[j], _idx->data.i[k], tt );
}
}
idx = _idx->data.i[idx];
if( x0.type == CV_32F )
{
const float* x0data = x0.data.fl[idx];
for( j = 0; j < ivcount; j++ )
x[0][j] = x0data[j]*w[j*2] + w[j*2 + 1];
}
else
{
const double* x0data = x0.data.db[idx];
for( j = 0; j < ivcount; j++ )
x[0][j] = x0data[j]*w[j*2] + w[j*2 + 1];
}
cvInitMatHeader( x1, 1, ivcount, CV_64F, x[0] );
// forward pass, compute y[i]=w*x[i-1], x[i]=f(y[i]), df[i]=f'(y[i])
for( i = 1; i < l_count; i++ )
{
cvInitMatHeader( x2, 1, layer_sizes->data.i[i], CV_64F, x[i] );
cvInitMatHeader( &_w, x1->cols, x2->cols, CV_64F, weights[i] );
cvGEMM( x1, &_w, 1, 0, 0, x2 );
_df = *x2;
_df.data.db = df[i];
calc_activ_func_deriv( x2, &_df, _w.data.db + _w.rows*_w.cols );
CV_SWAP( x1, x2, temp );
}
cvInitMatHeader( grad1, 1, ovcount, CV_64F, buf_ptr );
*grad2 = *grad1;
grad2->data.db = buf_ptr + max_count;
w = weights[l_count+1];
// calculate error
if( u.type == CV_32F )
{
const float* udata = u.data.fl[idx];
for( k = 0; k < ovcount; k++ )
{
double t = udata[k]*w[k*2] + w[k*2+1] - x[l_count-1][k];
grad1->data.db[k] = t*sweight;
E += t*t;
}
}
else
{
const double* udata = u.data.db[idx];
for( k = 0; k < ovcount; k++ )
{
double t = udata[k]*w[k*2] + w[k*2+1] - x[l_count-1][k];
grad1->data.db[k] = t*sweight;
E += t*t;
}
}
E *= sweight;
// backward pass, update weights
for( i = l_count-1; i > 0; i-- )
{
int n1 = layer_sizes->data.i[i-1], n2 = layer_sizes->data.i[i];
cvInitMatHeader( &_df, 1, n2, CV_64F, df[i] );
cvMul( grad1, &_df, grad1 );
cvInitMatHeader( &_w, n1+1, n2, CV_64F, weights[i] );
cvInitMatHeader( &_dw, n1+1, n2, CV_64F, dw->data.db + (weights[i] - weights[0]) );
cvInitMatHeader( x1, n1+1, 1, CV_64F, x[i-1] );
x[i-1][n1] = 1.;
cvGEMM( x1, grad1, params.bp_dw_scale, &_dw, params.bp_moment_scale, &_dw );
cvAdd( &_w, &_dw, &_w );
if( i > 1 )
{
grad2->cols = n1;
_w.rows = n1;
cvGEMM( grad1, &_w, 1, 0, 0, grad2, CV_GEMM_B_T );
}
CV_SWAP( grad1, grad2, temp );
}
}
iter /= count;
__END__;
cvReleaseMat( &dw );
cvReleaseMat( &buf );
cvReleaseMat( &_idx );
cvFree( &x );
return iter;
}
// This function is copied from http://mehrez.kristou.org/opencv-change-contrast-and-brightness-of-an-image/
boost::shared_ptr< Image > Image::ContrastBrightness( int contrast, int brightness ) const
{
if(contrast > 100) contrast = 100;
if(contrast < -100) contrast = -100;
if(brightness > 100) brightness = 100;
if(brightness < -100) brightness = -100;
uchar lut[256];
CvMat* lut_mat;
int hist_size = 256;
float range_0[]={0,256};
float* ranges[] = { range_0 };
int i;
IplImage * dest = cvCloneImage(this);
IplImage * GRAY;
if (this->nChannels == 3)
{
GRAY = cvCreateImage(cvGetSize(this),this->depth,1);
cvCvtColor(this,GRAY,CV_RGB2GRAY);
}
else
{
GRAY = cvCloneImage(this);
}
lut_mat = cvCreateMatHeader( 1, 256, CV_8UC1 );
cvSetData( lut_mat, lut, 0 );
/*
* The algorithm is by Werner D. Streidt
* (http://visca.com/ffactory/archives/5-99/msg00021.html)
*/
if( contrast > 0 )
{
double delta = 127.* contrast/100;
double a = 255./(255. - delta*2);
double b = a*(brightness - delta);
for( i = 0; i < 256; i++ )
{
int v = cvRound(a*i + b);
if( v < 0 )
v = 0;
if( v > 255 )
v = 255;
lut[i] = v;
}
}
else
{
double delta = -128.* contrast/100;
double a = (256.-delta*2)/255.;
double b = a* brightness + delta;
for( i = 0; i < 256; i++ )
{
int v = cvRound(a*i + b);
if( v < 0 )
v = 0;
if( v > 255 )
v = 255;
lut[i] = v;
}
}
if (this->nChannels ==3)
{
IplImage * R = cvCreateImage(cvGetSize(this),this->depth,1);
IplImage * G = cvCreateImage(cvGetSize(this),this->depth,1);
IplImage * B = cvCreateImage(cvGetSize(this),this->depth,1);
cvCvtPixToPlane(this,R,G,B,NULL);
cvLUT( R, R, lut_mat );
cvLUT( G, G, lut_mat );
cvLUT( B, B, lut_mat );
cvCvtPlaneToPix(R,G,B,NULL,dest);
cvReleaseImage(&R);
cvReleaseImage(&G);
cvReleaseImage(&B);
}
else
{
cvLUT( GRAY, dest, lut_mat );
}
cvReleaseImage(&GRAY);
cvReleaseMat( &lut_mat);
return boost::shared_ptr< Image >( new Image( dest, true ) );
}
void cvShowVecSamples( const char* filename, int winwidth, int winheight,
double scale )
{
CvVecFile file;
short tmp;
int i;
CvMat* sample;
tmp = 0;
file.input = fopen( filename, "rb" );
if( file.input != NULL )
{
size_t elements_read1 = fread( &file.count, sizeof( file.count ), 1, file.input );
size_t elements_read2 = fread( &file.vecsize, sizeof( file.vecsize ), 1, file.input );
size_t elements_read3 = fread( &tmp, sizeof( tmp ), 1, file.input );
size_t elements_read4 = fread( &tmp, sizeof( tmp ), 1, file.input );
CV_Assert(elements_read1 == 1 && elements_read2 == 1 && elements_read3 == 1 && elements_read4 == 1);
if( file.vecsize != winwidth * winheight )
{
int guessed_w = 0;
int guessed_h = 0;
fprintf( stderr, "Warning: specified sample width=%d and height=%d "
"does not correspond to .vec file vector size=%d.\n",
winwidth, winheight, file.vecsize );
if( file.vecsize > 0 )
{
guessed_w = cvFloor( sqrt( (float) file.vecsize ) );
if( guessed_w > 0 )
{
guessed_h = file.vecsize / guessed_w;
}
}
if( guessed_w <= 0 || guessed_h <= 0 || guessed_w * guessed_h != file.vecsize)
{
fprintf( stderr, "Error: failed to guess sample width and height\n" );
fclose( file.input );
return;
}
else
{
winwidth = guessed_w;
winheight = guessed_h;
fprintf( stderr, "Guessed width=%d, guessed height=%d\n",
winwidth, winheight );
}
}
if( !feof( file.input ) && scale > 0 )
{
CvMat* scaled_sample = 0;
file.last = 0;
file.vector = (short*) cvAlloc( sizeof( *file.vector ) * file.vecsize );
sample = scaled_sample = cvCreateMat( winheight, winwidth, CV_8UC1 );
if( scale != 1.0 )
{
scaled_sample = cvCreateMat( MAX( 1, cvCeil( scale * winheight ) ),
MAX( 1, cvCeil( scale * winwidth ) ),
CV_8UC1 );
}
cvNamedWindow( "Sample", CV_WINDOW_AUTOSIZE );
for( i = 0; i < file.count; i++ )
{
icvGetHaarTraininDataFromVecCallback( sample, &file );
if( scale != 1.0 ) cvResize( sample, scaled_sample, CV_INTER_LINEAR);
cvShowImage( "Sample", scaled_sample );
if( cvWaitKey( 0 ) == 27 ) break;
}
if( scaled_sample && scaled_sample != sample ) cvReleaseMat( &scaled_sample );
cvReleaseMat( &sample );
cvFree( &file.vector );
}
fclose( file.input );
}
}
int frontalFaceDetect::tmp(IplImage* templat, IplImage* target, IplImage* Tresult)
{
IplImage* image22=cvCreateImage(cvSize(templat->width,templat->height),IPL_DEPTH_8U,1);
int targetHeight = target->height;
int targetWidth = target->width;
int templateHeight = templat->height;
int templateWidth = templat->width;
//mean value of templat
CvScalar Scalar1;
Scalar1 = cvAvg(templat);
//image22=templat-mean(templat)
for (int ii=0;ii<(templateHeight);ii++)
{
for (int jj=0;jj<(templateWidth);jj++)
{
if (((((uchar*)(templat->imageData + templat->widthStep*(ii)))[(jj)])-(uchar)(Scalar1.val[0]))<0)
((uchar*)(image22->imageData + image22->widthStep*(ii)))[(jj)] = 0;
else
((uchar*)(image22->imageData + image22->widthStep*(ii)))[(jj)] = ((uchar*)(templat->imageData + templat->widthStep*(ii)))[(jj)]-(uchar)(Scalar1.val[0]);
}
}
CvMat* M=cvCreateMat((targetHeight-templateHeight+1),(targetWidth-templateWidth+1),CV_32FC1);//模板与目标图像的相关矩阵，最大值处开始的区域为眼睛区域
CvScalar Scalar2;
float t,a1,a2,corr;
for(int i=0;i<(targetHeight-templateHeight+1);i++)
{
for (int j=0;j<(targetWidth-templateWidth+1);j++)
{
CvMat* Nimage=cvCreateMat(templateHeight,templateWidth,CV_8UC1);
//Nimage=target;
for (int ii=0;ii<(templateHeight);ii++)
{
for (int jj=0;jj<(templateWidth);jj++)
{
((uchar*)(Nimage->data.ptr + Nimage->step*ii))[jj] = ((uchar*)(target->imageData + target->widthStep*(ii+i)))[(jj+j)];
}
}
Scalar2 = cvAvg(Nimage);
//Nimage=target-mean(target);
for (int ii=0;ii<(templateHeight);ii++)
{
for (int jj=0;jj<(templateWidth);jj++)
{
if ((((uchar*)(Nimage->data.ptr + Nimage->step*ii))[jj]-(uchar)(Scalar2.val[0]))<0)
((uchar*)(Nimage->data.ptr + Nimage->step*ii))[jj] = 0;
else
((uchar*)(Nimage->data.ptr + Nimage->step*ii))[jj] = ((uchar*)(Nimage->data.ptr + Nimage->step*ii))[jj]-(uchar)(Scalar2.val[0]);
}
}
//求点（i，j）的相关系数t
corr=0;
for (int ii=0;ii<(templateHeight);ii++)
{
for (int jj=0;jj<(templateWidth);jj++)
{
corr = float((((uchar*)(Nimage->data.ptr + Nimage->step*ii))[jj])*(((uchar*)(image22->imageData + image22->widthStep*(ii)))[(jj)]))+corr;
}
}
a1=a2=0.0;
for (int ii=0;ii<(templateHeight);ii++)
{
for (int jj=0;jj<(templateWidth);jj++)
{
a1=a1+float((((uchar*)(Nimage->data.ptr + Nimage->step*ii))[jj])*(((uchar*)(Nimage->data.ptr + Nimage->step*ii))[jj]));
a2=a2+float((((uchar*)(image22->imageData + image22->widthStep*(ii)))[(jj)])*(((uchar*)(image22->imageData + image22->widthStep*(ii)))[(jj)]));
}
}
t=corr/(sqrt(a1)*sqrt(a2));
((float*)(M->data.ptr + M->step*i))[j] = (float)(t);
cvReleaseMat(&Nimage);
}
}
PlotBox(Tresult, target, templat, M);//由相关矩阵M，求出目标图像的眼睛区域Tresult
cvReleaseImage(&image22);
cvReleaseMat(&M);
return 0;
}
CV_IMPL CvSeq*
cvSegmentImage( const CvArr* srcarr, CvArr* dstarr,
double canny_threshold,
double ffill_threshold,
CvMemStorage* storage )
{
CvSeq* root = 0;
CvMat* gray = 0;
CvMat* canny = 0;
//CvMat* temp = 0;
void* stack = 0;
CV_FUNCNAME( "cvSegmentImage" );
__BEGIN__;
CvMat srcstub, *src;
CvMat dststub, *dst;
CvMat* mask;
CvSize size;
CvPoint pt;
int ffill_lw_up = cvRound( fabs(ffill_threshold) );
CvSeq* prev_seq = 0;
CV_CALL( src = cvGetMat( srcarr, &srcstub ));
CV_CALL( dst = cvGetMat( dstarr, &dststub ));
size = cvGetSize( src );
CV_CALL( gray = cvCreateMat( size.height, size.width, CV_8UC1 ));
CV_CALL( canny = cvCreateMat( size.height, size.width, CV_8UC1 ));
//CV_CALL( temp = cvCreateMat( size.height/2, size.width/2, CV_8UC3 ));
CV_CALL( stack = cvAlloc( size.width * size.height * sizeof(Seg)));
cvCvtColor( src, gray, CV_BGR2GRAY );
cvCanny( gray, canny, 0/*canny_threshold*0.4*/, canny_threshold, 3 );
cvThreshold( canny, canny, 1, 1, CV_THRESH_BINARY );
//cvZero( canny );
//color_derv( src, canny, canny_threshold );
//cvPyrDown( src, temp );
//cvPyrUp( temp, dst );
//src = dst;
mask = canny; // a new name for new role
// make a non-zero border.
cvRectangle( mask, cvPoint(0,0), cvPoint(size.width-1,size.height-1), cvScalarAll(1), 1 );
for( pt.y = 0; pt.y < size.height; pt.y++ )
{
for( pt.x = 0; pt.x < size.width; pt.x++ )
{
if( mask->data.ptr[mask->step*pt.y + pt.x] == 0 )
{
CvConnectedComp region;
int avgVal[3] = { 0, 0, 0 };
icvSegmFloodFill_Stage1( src->data.ptr, src->step,
mask->data.ptr, mask->step,
size, pt, avgVal,
ffill_lw_up, ffill_lw_up,
®ion, stack );
/*avgVal[0] = (avgVal[0] + 15) & -32;
if( avgVal[0] > 255 )
avgVal[0] = 255;
avgVal[1] = (avgVal[1] + 15) & -32;
if( avgVal[1] > 255 )
avgVal[1] = 255;
avgVal[2] = (avgVal[2] + 15) & -32;
if( avgVal[2] > 255 )
avgVal[2] = 255;*/
if( storage )
{
CvSeq* tmpseq = icvGetComponent( mask->data.ptr, mask->step,
region.rect, storage );
if( tmpseq != 0 )
{
((CvContour*)tmpseq)->color = avgVal[0] + (avgVal[1] << 8) + (avgVal[2] << 16);
tmpseq->h_prev = prev_seq;
if( prev_seq )
prev_seq->h_next = tmpseq;
else
root = tmpseq;
prev_seq = tmpseq;
}
}
icvSegmFloodFill_Stage2( dst->data.ptr, dst->step,
mask->data.ptr, mask->step,
size, avgVal,
region.rect );
}
}
}
__END__;
//cvReleaseMat( &temp );
cvReleaseMat( &gray );
cvReleaseMat( &canny );
cvFree( &stack );
return root;
}
int main(int argc, char** argv)
{
CvMat* M = cvCreateMat(3, 3, CV_64FC1);
cvSetIdentity(M);
CvMat* L = MT_CreateCholeskyResult(M);
MT_Cholesky(M, L);
disp_mat(M, "M");
disp_mat(L, "L = chol(M)");
cvmSet(M, 1, 1, 4.0);
cvmSet(M, 2, 2, 9.0);
MT_Cholesky(M, L);
disp_mat(M, "M");
disp_mat(L, "L = chol(M)");
cvmSet(M, 0, 1, 0.1);
cvmSet(M, 0, 2, 0.1);
cvmSet(M, 1, 0, 0.1);
cvmSet(M, 1, 2, 0.1);
cvmSet(M, 2, 0, 0.1);
cvmSet(M, 2, 1, 0.1);
MT_Cholesky(M, L);
disp_mat(M, "M");
disp_mat(L, "L = chol(M)");
cvReleaseMat(&M);
cvReleaseMat(&L);
M = cvCreateMat(5, 5, CV_64FC1);
cvSet(M, cvScalar(0.1));
for(unsigned int i = 0; i < 5; i++)
{
cvmSet(M, i, i, (double) (i+1));
}
L = MT_CreateCholeskyResult(M);
MT_Cholesky(M, L);
disp_mat(M, "M");
disp_mat(L, "L = chol(M)");
cvReleaseMat(&M);
cvReleaseMat(&L);
CvMat* C = cvCreateMat(4, 4, CV_64FC1);
CvMat* A = cvCreateMatHeader(2, 2, CV_64FC1);
CvMat* B = cvCreateMatHeader(2, 2, CV_64FC1);
cvGetSubRect(C, A, cvRect(0, 0, 2, 2));
cvGetSubRect(C, B, cvRect(2, 2, 2, 2));
cvSet(C, cvScalar(0));
cvSet(A, cvScalar(1));
cvSet(B, cvScalar(2));
cvReleaseMat(&A);
cvReleaseMat(&B);
disp_mat(C, "C (composited)");
cvReleaseMat(&C);
}
int UCS_run(SslHandle_t* ucs) {
IplImage* image;
CvCapture* capture;
CvMat* cvmat;
char imgseg[9];
char recvbuf[2];
size_t tsize, ssize, total_size;
int err, flag;
int is_stop_ucstream=0;
static const int jpeg_param[3] = {
CV_IMWRITE_JPEG_QUALITY, UCS_JPEG_QUALITY, 0 };
image = NULL;
capture = cvCaptureFromCAM(0);
flag = fcntl(ucs->ssl_fd, F_GETFL, 0);
fcntl(ucs->ssl_fd, F_SETFL, flag | O_NONBLOCK);
// 1280 x 800 tablet size
cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH,
UCS_CAPTURE_SIZE_WIDTH);
cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT,
UCS_CAPTURE_SIZE_HIGHT);
//cvSetCaptureProperty(capture, CV_CAP_PROP_FPS, UCS_CAPTURE_FPS);
imgseg[0] = UCS_REQ_IMGSEG;
itobuf(UCS_SENDBUF_SIZE, imgseg + 1);
while (!is_stop_ucstream) {
while (!cvGrabFrame(capture)) {
perror("UCS_run > cvGrabFrame\n");
}
image = cvRetrieveFrame(capture, 0);
cvmat = cvEncodeImage(".jpg", image, jpeg_param);
total_size = cvmat->cols * cvmat->rows;
itobuf(total_size, imgseg + 5);
if (SSL_write(ucs->ssl, imgseg, 9) <= 0) {
perror("UCS_run > UCS_REQ_IMGSEG");
cvReleaseMat(&cvmat);
continue;
}
ssize = 0;
while (SSL_write(ucs->ssl, cvmat->data.ptr, total_size) <= 0);
cvReleaseMat(&cvmat);
usleep(100000);
if (SSL_read(ucs->ssl, recvbuf, 1) > 0) {
if (recvbuf[0] == UCS_REP_STOP) {
is_stop_ucstream = 1;
} else {
perror("UCS_run > UCS_REP_STOP");
break;
}
}
}
cvReleaseCapture(&capture);
return 0;
}
ofxCvGrayscaleImage::~ofxCvGrayscaleImage(){
cvReleaseMat(&briConLutMatrix);
}
void
icvCrossCorr( const CvArr* _img, const CvArr* _templ, CvArr* _corr,
CvPoint anchor, double delta, int borderType )
{
const double block_scale = 4.5;
const int min_block_size = 256;
CvMat* dft_img[CV_MAX_THREADS] = {0};
CvMat* dft_templ = 0;
void* buf[CV_MAX_THREADS] = {0};
int k, num_threads = 0;
CV_FUNCNAME( "icvCrossCorr" );
__BEGIN__;
CvMat istub, *img = (CvMat*)_img;
CvMat tstub, *templ = (CvMat*)_templ;
CvMat cstub, *corr = (CvMat*)_corr;
CvSize dftsize, blocksize;
int depth, templ_depth, corr_depth, max_depth = CV_32F,
cn, templ_cn, corr_cn, buf_size = 0,
tile_count_x, tile_count_y, tile_count;
CV_CALL( img = cvGetMat( img, &istub ));
CV_CALL( templ = cvGetMat( templ, &tstub ));
CV_CALL( corr = cvGetMat( corr, &cstub ));
if( CV_MAT_DEPTH( img->type ) != CV_8U &&
CV_MAT_DEPTH( img->type ) != CV_16U &&
CV_MAT_DEPTH( img->type ) != CV_32F )
CV_ERROR( CV_StsUnsupportedFormat,
"The function supports only 8u, 16u and 32f data types" );
if( !CV_ARE_DEPTHS_EQ( img, templ ) && CV_MAT_DEPTH( templ->type ) != CV_32F )
CV_ERROR( CV_StsUnsupportedFormat,
"Template (kernel) must be of the same depth as the input image, or be 32f" );
if( !CV_ARE_DEPTHS_EQ( img, corr ) && CV_MAT_DEPTH( corr->type ) != CV_32F &&
CV_MAT_DEPTH( corr->type ) != CV_64F )
CV_ERROR( CV_StsUnsupportedFormat,
"The output image must have the same depth as the input image, or be 32f/64f" );
if( (!CV_ARE_CNS_EQ( img, corr ) || CV_MAT_CN(templ->type) > 1) &&
(CV_MAT_CN( corr->type ) > 1 || !CV_ARE_CNS_EQ( img, templ)) )
CV_ERROR( CV_StsUnsupportedFormat,
"The output must have the same number of channels as the input (when the template has 1 channel), "
"or the output must have 1 channel when the input and the template have the same number of channels" );
depth = CV_MAT_DEPTH(img->type);
cn = CV_MAT_CN(img->type);
templ_depth = CV_MAT_DEPTH(templ->type);
templ_cn = CV_MAT_CN(templ->type);
corr_depth = CV_MAT_DEPTH(corr->type);
corr_cn = CV_MAT_CN(corr->type);
CV_Assert( corr_cn == 1 || delta == 0 );
max_depth = MAX( max_depth, templ_depth );
max_depth = MAX( max_depth, depth );
max_depth = MAX( max_depth, corr_depth );
if( depth > CV_8U )
max_depth = CV_64F;
if( img->cols < templ->cols || img->rows < templ->rows )
CV_ERROR( CV_StsUnmatchedSizes,
"Such a combination of image and template/filter size is not supported" );
if( corr->rows > img->rows + templ->rows - 1 ||
corr->cols > img->cols + templ->cols - 1 )
CV_ERROR( CV_StsUnmatchedSizes,
"output image should not be greater than (W + w - 1)x(H + h - 1)" );
blocksize.width = cvRound(templ->cols*block_scale);
blocksize.width = MAX( blocksize.width, min_block_size - templ->cols + 1 );
blocksize.width = MIN( blocksize.width, corr->cols );
blocksize.height = cvRound(templ->rows*block_scale);
blocksize.height = MAX( blocksize.height, min_block_size - templ->rows + 1 );
blocksize.height = MIN( blocksize.height, corr->rows );
dftsize.width = cvGetOptimalDFTSize(blocksize.width + templ->cols - 1);
if( dftsize.width == 1 )
dftsize.width = 2;
dftsize.height = cvGetOptimalDFTSize(blocksize.height + templ->rows - 1);
if( dftsize.width <= 0 || dftsize.height <= 0 )
CV_ERROR( CV_StsOutOfRange, "the input arrays are too big" );
// recompute block size
blocksize.width = dftsize.width - templ->cols + 1;
blocksize.width = MIN( blocksize.width, corr->cols );
blocksize.height = dftsize.height - templ->rows + 1;
blocksize.height = MIN( blocksize.height, corr->rows );
CV_CALL( dft_templ = cvCreateMat( dftsize.height*templ_cn, dftsize.width, max_depth ));
num_threads = cvGetNumThreads();
for( k = 0; k < num_threads; k++ )
CV_CALL( dft_img[k] = cvCreateMat( dftsize.height, dftsize.width, max_depth ));
if( templ_cn > 1 && templ_depth != max_depth )
buf_size = templ->cols*templ->rows*CV_ELEM_SIZE(templ_depth);
if( cn > 1 && depth != max_depth )
buf_size = MAX( buf_size, (blocksize.width + templ->cols - 1)*
(blocksize.height + templ->rows - 1)*CV_ELEM_SIZE(depth));
if( (corr_cn > 1 || cn > 1) && corr_depth != max_depth )
buf_size = MAX( buf_size, blocksize.width*blocksize.height*CV_ELEM_SIZE(corr_depth));
if( buf_size > 0 )
{
for( k = 0; k < num_threads; k++ )
CV_CALL( buf[k] = cvAlloc(buf_size) );
}
// compute DFT of each template plane
for( k = 0; k < templ_cn; k++ )
{
CvMat dstub, *src, *dst, temp;
CvMat* planes[] = { 0, 0, 0, 0 };
int yofs = k*dftsize.height;
src = templ;
dst = cvGetSubRect( dft_templ, &dstub, cvRect(0,yofs,templ->cols,templ->rows));
if( templ_cn > 1 )
{
planes[k] = templ_depth == max_depth ? dst :
cvInitMatHeader( &temp, templ->rows, templ->cols, templ_depth, buf[0] );
cvSplit( templ, planes[0], planes[1], planes[2], planes[3] );
src = planes[k];
planes[k] = 0;
}
if( dst != src )
cvConvert( src, dst );
if( dft_templ->cols > templ->cols )
{
cvGetSubRect( dft_templ, dst, cvRect(templ->cols, yofs,
dft_templ->cols - templ->cols, templ->rows) );
cvZero( dst );
}
cvGetSubRect( dft_templ, dst, cvRect(0,yofs,dftsize.width,dftsize.height) );
cvDFT( dst, dst, CV_DXT_FORWARD + CV_DXT_SCALE, templ->rows );
}
tile_count_x = (corr->cols + blocksize.width - 1)/blocksize.width;
tile_count_y = (corr->rows + blocksize.height - 1)/blocksize.height;
tile_count = tile_count_x*tile_count_y;
{
#ifdef _OPENMP
#pragma omp parallel for num_threads(num_threads) schedule(dynamic)
#endif
// calculate correlation by blocks
for( k = 0; k < tile_count; k++ )
{
int thread_idx = cvGetThreadNum();
int x = (k%tile_count_x)*blocksize.width;
int y = (k/tile_count_x)*blocksize.height;
int i, yofs;
CvMat sstub, dstub, *src, *dst, temp;
CvMat* planes[] = { 0, 0, 0, 0 };
CvMat* _dft_img = dft_img[thread_idx];
void* _buf = buf[thread_idx];
CvSize csz = { blocksize.width, blocksize.height }, isz;
int x0 = x - anchor.x, y0 = y - anchor.y;
int x1 = MAX( 0, x0 ), y1 = MAX( 0, y0 ), x2, y2;
csz.width = MIN( csz.width, corr->cols - x );
csz.height = MIN( csz.height, corr->rows - y );
isz.width = csz.width + templ->cols - 1;
isz.height = csz.height + templ->rows - 1;
x2 = MIN( img->cols, x0 + isz.width );
y2 = MIN( img->rows, y0 + isz.height );
for( i = 0; i < cn; i++ )
{
CvMat dstub1, *dst1;
yofs = i*dftsize.height;
src = cvGetSubRect( img, &sstub, cvRect(x1,y1,x2-x1,y2-y1) );
dst = cvGetSubRect( _dft_img, &dstub,
cvRect(0,0,isz.width,isz.height) );
dst1 = dst;
if( x2 - x1 < isz.width || y2 - y1 < isz.height )
dst1 = cvGetSubRect( _dft_img, &dstub1,
cvRect( x1 - x0, y1 - y0, x2 - x1, y2 - y1 ));
if( cn > 1 )
{
planes[i] = dst1;
if( depth != max_depth )
planes[i] = cvInitMatHeader( &temp, y2 - y1, x2 - x1, depth, _buf );
cvSplit( src, planes[0], planes[1], planes[2], planes[3] );
src = planes[i];
planes[i] = 0;
}
if( dst1 != src )
cvConvert( src, dst1 );
if( dst != dst1 )
cvCopyMakeBorder( dst1, dst, cvPoint(x1 - x0, y1 - y0), borderType );
if( dftsize.width > isz.width )
{
cvGetSubRect( _dft_img, dst, cvRect(isz.width, 0,
dftsize.width - isz.width,dftsize.height) );
cvZero( dst );
}
cvDFT( _dft_img, _dft_img, CV_DXT_FORWARD, isz.height );
cvGetSubRect( dft_templ, dst,
cvRect(0,(templ_cn>1?yofs:0),dftsize.width,dftsize.height) );
cvMulSpectrums( _dft_img, dst, _dft_img, CV_DXT_MUL_CONJ );
cvDFT( _dft_img, _dft_img, CV_DXT_INVERSE, csz.height );
src = cvGetSubRect( _dft_img, &sstub, cvRect(0,0,csz.width,csz.height) );
dst = cvGetSubRect( corr, &dstub, cvRect(x,y,csz.width,csz.height) );
if( corr_cn > 1 )
{
planes[i] = src;
if( corr_depth != max_depth )
{
planes[i] = cvInitMatHeader( &temp, csz.height, csz.width,
corr_depth, _buf );
cvConvertScale( src, planes[i], 1, delta );
}
cvMerge( planes[0], planes[1], planes[2], planes[3], dst );
planes[i] = 0;
}
else
{
if( i == 0 )
cvConvertScale( src, dst, 1, delta );
else
{
if( max_depth > corr_depth )
{
cvInitMatHeader( &temp, csz.height, csz.width,
corr_depth, _buf );
cvConvert( src, &temp );
src = &temp;
}
cvAcc( src, dst );
}
}
}
}
}
__END__;
cvReleaseMat( &dft_templ );
for( k = 0; k < num_threads; k++ )
{
cvReleaseMat( &dft_img[k] );
cvFree( &buf[k] );
}
}
CV_IMPL void
cvReduce( const CvArr* srcarr, CvArr* dstarr, int dim, int op )
{
CvMat* temp = 0;
CV_FUNCNAME( "cvReduce" );
__BEGIN__;
CvMat sstub, *src = (CvMat*)srcarr;
CvMat dstub, *dst = (CvMat*)dstarr, *dst0;
int sdepth, ddepth, cn, op0 = op;
CvSize size;
if( !CV_IS_MAT(src) )
CV_CALL( src = cvGetMat( src, &sstub ));
if( !CV_IS_MAT(dst) )
CV_CALL( dst = cvGetMat( dst, &dstub ));
if( !CV_ARE_CNS_EQ(src, dst) )
CV_ERROR( CV_StsUnmatchedFormats, "Input and output arrays must have the same number of channels" );
sdepth = CV_MAT_DEPTH(src->type);
ddepth = CV_MAT_DEPTH(dst->type);
cn = CV_MAT_CN(src->type);
dst0 = dst;
size = cvGetMatSize(src);
if( dim < 0 )
dim = src->rows > dst->rows ? 0 : src->cols > dst->cols ? 1 : dst->cols == 1;
if( dim > 1 )
CV_ERROR( CV_StsOutOfRange, "The reduced dimensionality index is out of range" );
if( dim == 0 && (dst->cols != src->cols || dst->rows != 1) ||
dim == 1 && (dst->rows != src->rows || dst->cols != 1) )
CV_ERROR( CV_StsBadSize, "The output array size is incorrect" );
if( op == CV_REDUCE_AVG )
{
int ttype = sdepth == CV_8U ? CV_MAKETYPE(CV_32S,cn) : dst->type;
if( ttype != dst->type )
CV_CALL( dst = temp = cvCreateMat( dst->rows, dst->cols, ttype ));
op = CV_REDUCE_SUM;
ddepth = CV_MAT_DEPTH(ttype);
}
if( op != CV_REDUCE_SUM && op != CV_REDUCE_MAX && op != CV_REDUCE_MIN )
CV_ERROR( CV_StsBadArg, "Unknown reduce operation index, must be one of CV_REDUCE_*" );
if( dim == 0 )
{
CvReduceToRowFunc rfunc =
op == CV_REDUCE_SUM ?
(sdepth == CV_8U && ddepth == CV_32S ? (CvReduceToRowFunc)icvSumRows_8u32s_C1R :
sdepth == CV_8U && ddepth == CV_32F ? (CvReduceToRowFunc)icvSumRows_8u32f_C1R :
sdepth == CV_16U && ddepth == CV_32F ? (CvReduceToRowFunc)icvSumRows_16u32f_C1R :
sdepth == CV_16U && ddepth == CV_64F ? (CvReduceToRowFunc)icvSumRows_16u64f_C1R :
sdepth == CV_16S && ddepth == CV_32F ? (CvReduceToRowFunc)icvSumRows_16s32f_C1R :
sdepth == CV_16S && ddepth == CV_64F ? (CvReduceToRowFunc)icvSumRows_16s64f_C1R :
sdepth == CV_32F && ddepth == CV_32F ? (CvReduceToRowFunc)icvSumRows_32f_C1R :
sdepth == CV_32F && ddepth == CV_64F ? (CvReduceToRowFunc)icvSumRows_32f64f_C1R :
sdepth == CV_64F && ddepth == CV_64F ? (CvReduceToRowFunc)icvSumRows_64f_C1R : 0) :
op == CV_REDUCE_MAX ?
(sdepth == CV_8U && ddepth == CV_8U ? (CvReduceToRowFunc)icvMaxRows_8u_C1R :
sdepth == CV_32F && ddepth == CV_32F ? (CvReduceToRowFunc)icvMaxRows_32f_C1R :
sdepth == CV_64F && ddepth == CV_64F ? (CvReduceToRowFunc)icvMaxRows_64f_C1R : 0) :
(sdepth == CV_8U && ddepth == CV_8U ? (CvReduceToRowFunc)icvMinRows_8u_C1R :
sdepth == CV_32F && ddepth == CV_32F ? (CvReduceToRowFunc)icvMinRows_32f_C1R :
sdepth == CV_64F && ddepth == CV_64F ? (CvReduceToRowFunc)icvMinRows_64f_C1R : 0);
if( !rfunc )
CV_ERROR( CV_StsUnsupportedFormat,
"Unsupported combination of input and output array formats" );
size.width *= cn;
IPPI_CALL( rfunc( src->data.ptr, src->step ? src->step : CV_STUB_STEP,
dst->data.ptr, size ));
}
else
{
CvReduceToColFunc cfunc =
op == CV_REDUCE_SUM ?
(sdepth == CV_8U && ddepth == CV_32S ?
(CvReduceToColFunc)(cn == 1 ? icvSumCols_8u32s_C1R :
cn == 3 ? icvSumCols_8u32s_C3R :
cn == 4 ? icvSumCols_8u32s_C4R : 0) :
sdepth == CV_8U && ddepth == CV_32F ?
(CvReduceToColFunc)(cn == 1 ? icvSumCols_8u32f_C1R :
cn == 3 ? icvSumCols_8u32f_C3R :
cn == 4 ? icvSumCols_8u32f_C4R : 0) :
sdepth == CV_16U && ddepth == CV_32F ?
(CvReduceToColFunc)(cn == 1 ? icvSumCols_16u32f_C1R : 0) :
sdepth == CV_16U && ddepth == CV_64F ?
(CvReduceToColFunc)(cn == 1 ? icvSumCols_16u64f_C1R : 0) :
sdepth == CV_16S && ddepth == CV_32F ?
(CvReduceToColFunc)(cn == 1 ? icvSumCols_16s32f_C1R : 0) :
sdepth == CV_16S && ddepth == CV_64F ?
(CvReduceToColFunc)(cn == 1 ? icvSumCols_16s64f_C1R : 0) :
sdepth == CV_32F && ddepth == CV_32F ?
(CvReduceToColFunc)(cn == 1 ? icvSumCols_32f_C1R :
cn == 3 ? icvSumCols_32f_C3R :
cn == 4 ? icvSumCols_32f_C4R : 0) :
sdepth == CV_32F && ddepth == CV_64F ?
(CvReduceToColFunc)(cn == 1 ? icvSumCols_32f64f_C1R : 0) :
sdepth == CV_64F && ddepth == CV_64F ?
(CvReduceToColFunc)(cn == 1 ? icvSumCols_64f_C1R :
cn == 3 ? icvSumCols_64f_C3R :
cn == 4 ? icvSumCols_64f_C4R : 0) : 0) :
op == CV_REDUCE_MAX && cn == 1 ?
(sdepth == CV_8U && ddepth == CV_8U ? (CvReduceToColFunc)icvMaxCols_8u_C1R :
sdepth == CV_32F && ddepth == CV_32F ? (CvReduceToColFunc)icvMaxCols_32f_C1R :
sdepth == CV_64F && ddepth == CV_64F ? (CvReduceToColFunc)icvMaxCols_64f_C1R : 0) :
op == CV_REDUCE_MIN && cn == 1 ?
(sdepth == CV_8U && ddepth == CV_8U ? (CvReduceToColFunc)icvMinCols_8u_C1R :
sdepth == CV_32F && ddepth == CV_32F ? (CvReduceToColFunc)icvMinCols_32f_C1R :
sdepth == CV_64F && ddepth == CV_64F ? (CvReduceToColFunc)icvMinCols_64f_C1R : 0) : 0;
if( !cfunc )
CV_ERROR( CV_StsUnsupportedFormat,
"Unsupported combination of input and output array formats" );
IPPI_CALL( cfunc( src->data.ptr, src->step ? src->step : CV_STUB_STEP,
dst->data.ptr, dst->step ? dst->step : CV_STUB_STEP, size ));
}
if( op0 == CV_REDUCE_AVG )
cvScale( dst, dst0, 1./(dim == 0 ? src->rows : src->cols) );
__END__;
if( temp )
cvReleaseMat( &temp );
}
void
icvAdaptiveThreshold_StdDev( const CvMat* srcIm, CvMat* dstIm,
int maxValue, CvThreshType type,
int size, int epsilon )
{
//////////////// Some variables /////////////////////
CvMat* avgIm = 0;
CvMat* dispIm = 0;
CvSize roi;
uchar* src = 0;
uchar* dst = 0;
uchar* disp = 0;
uchar* avg = 0;
int src_step;
int dst_step;
int disp_step;
int avg_step;
int thresh = 0;
int i, j;
CV_FUNCNAME( "cvAdaptiveThreshold" );
__BEGIN__;
//////////////// Check for bad arguments ////////////////
if( !srcIm || !dstIm )
CV_ERROR( CV_StsNullPtr, "" );
if( size < 1 || size > 4 )
CV_ERROR( CV_StsBadSize, "" );
cvGetRawData( srcIm, &src, &src_step, &roi );
cvGetRawData( dstIm, &dst, &dst_step, 0 );
CV_CALL( avgIm = cvCreateMat( roi.height, roi.width, CV_8UC1 ));
CV_CALL( dispIm = cvCreateMat( roi.height, roi.width, CV_8UC1 ));
// calc dispersion
IPPI_CALL( _CalcDispMean( srcIm, avgIm, dispIm, size ));
cvGetRawData( dispIm, &disp, &disp_step, 0 );
cvGetRawData( avgIm, &avg, &avg_step, 0 );
epsilon = epsilon * epsilon;
_FindInitiThreshold( src, src_step, roi, size, epsilon, &thresh );
switch (type)
{
case CV_THRESH_BINARY:
for( i = 0; i < roi.height; i++, src += src_step,
dst += dst_step, disp += disp_step, avg += avg_step )
{
for( j = 0; j < roi.width; j++ )
{
int tdisp = disp[j];
if( tdisp > epsilon )
thresh = avg[j];
dst[j] = (uchar)((thresh < src[j] ? -1 : 0) & maxValue);
}
}
break;
case CV_THRESH_BINARY_INV:
for( i = 0; i < roi.height; i++, src += src_step,
dst += dst_step, disp += disp_step, avg += avg_step )
{
for( j = 0; j < roi.width; j++ )
{
int tdisp = disp[j];
if( tdisp > epsilon )
thresh = avg[j];
dst[j] = (uchar)((src[j] < thresh ? -1 : 0) & maxValue);
}
}
break;
case CV_THRESH_TOZERO:
for( i = 0; i < roi.height; i++, src += src_step,
dst += dst_step, disp += disp_step, avg += avg_step )
{
for( j = 0; j < roi.width; j++ )
{
int t;
int tdisp = disp[j];
if( tdisp > epsilon )
thresh = avg[j];
t = src[j];
dst[j] = (uchar) ((thresh < t ? -1 : 0) & t);
}
}
break;
case CV_THRESH_TOZERO_INV:
for( i = 0; i < roi.height; i++, src += src_step,
dst += dst_step, disp += disp_step, avg += avg_step )
{
for( j = 0; j < roi.width; j++ )
{
int tdisp = disp[j];
if( tdisp > epsilon )
thresh = avg[j];
dst[j] = (uchar)((src[j] < thresh ? -1 : 0) & src[j]);
}
}
break;
default:
CV_ERROR( CV_StsBadFlag, "" );
}
__END__;
cvReleaseMat( &avgIm );
cvReleaseMat( &dispIm );
}
int CvANN_MLP::train_rprop( CvVectors x0, CvVectors u, const double* sw )
{
const int max_buf_sz = 1 << 16;
CvMat* dw = 0;
CvMat* dEdw = 0;
CvMat* prev_dEdw_sign = 0;
CvMat* buf = 0;
double **x = 0, **df = 0;
int iter = -1, count = x0.count;
CV_FUNCNAME( "CvANN_MLP::train" );
__BEGIN__;
int i, ivcount, ovcount, l_count, total = 0, max_iter, buf_sz, dcount0, dcount=0;
double *buf_ptr;
double prev_E = DBL_MAX*0.5, epsilon;
double dw_plus, dw_minus, dw_min, dw_max;
double inv_count;
max_iter = params.term_crit.max_iter;
epsilon = params.term_crit.epsilon;
dw_plus = params.rp_dw_plus;
dw_minus = params.rp_dw_minus;
dw_min = params.rp_dw_min;
dw_max = params.rp_dw_max;
l_count = layer_sizes->cols;
ivcount = layer_sizes->data.i[0];
ovcount = layer_sizes->data.i[l_count-1];
// allocate buffers
for( i = 0; i < l_count; i++ )
total += layer_sizes->data.i[i];
CV_CALL( dw = cvCreateMat( wbuf->rows, wbuf->cols, wbuf->type ));
cvSet( dw, cvScalarAll(params.rp_dw0) );
CV_CALL( dEdw = cvCreateMat( wbuf->rows, wbuf->cols, wbuf->type ));
cvZero( dEdw );
CV_CALL( prev_dEdw_sign = cvCreateMat( wbuf->rows, wbuf->cols, CV_8SC1 ));
cvZero( prev_dEdw_sign );
inv_count = 1./count;
dcount0 = max_buf_sz/(2*total);
dcount0 = MAX( dcount0, 1 );
dcount0 = MIN( dcount0, count );
buf_sz = dcount0*(total + max_count)*2;
CV_CALL( buf = cvCreateMat( 1, buf_sz, CV_64F ));
CV_CALL( x = (double**)cvAlloc( total*2*sizeof(x[0]) ));
df = x + total;
buf_ptr = buf->data.db;
for( i = 0; i < l_count; i++ )
{
x[i] = buf_ptr;
df[i] = x[i] + layer_sizes->data.i[i]*dcount0;
buf_ptr += (df[i] - x[i])*2;
}
// run rprop loop
/*
y_i(t) = w_i(t)*x_{i-1}(t)
x_i(t) = f(y_i(t))
E = sum_over_all_samples(1/2*||u - x_N||^2)
grad_N = (x_N - u)*f'(y_i)
MIN(dw_i{jk}(t)*dw_plus, dw_max), if dE/dw_i{jk}(t)*dE/dw_i{jk}(t-1) > 0
dw_i{jk}(t) = MAX(dw_i{jk}(t)*dw_minus, dw_min), if dE/dw_i{jk}(t)*dE/dw_i{jk}(t-1) < 0
dw_i{jk}(t-1) else
if (dE/dw_i{jk}(t)*dE/dw_i{jk}(t-1) < 0)
dE/dw_i{jk}(t)<-0
else
w_i{jk}(t+1) = w_i{jk}(t) + dw_i{jk}(t)
grad_{i-1}(t) = w_i^t(t)*grad_i(t)
*/
for( iter = 0; iter < max_iter; iter++ )
{
int n1, n2, si, j, k;
double* w;
CvMat _w, _dEdw, hdr1, hdr2, ghdr1, ghdr2, _df;
CvMat *x1, *x2, *grad1, *grad2, *temp;
double E = 0;
// first, iterate through all the samples and compute dEdw
for( si = 0; si < count; si += dcount )
{
dcount = MIN( count - si, dcount0 );
w = weights[0];
grad1 = &ghdr1; grad2 = &ghdr2;
x1 = &hdr1; x2 = &hdr2;
// grab and preprocess input data
if( x0.type == CV_32F )
for( i = 0; i < dcount; i++ )
{
const float* x0data = x0.data.fl[si+i];
double* xdata = x[0]+i*ivcount;
for( j = 0; j < ivcount; j++ )
xdata[j] = x0data[j]*w[j*2] + w[j*2+1];
}
else
for( i = 0; i < dcount; i++ )
{
const double* x0data = x0.data.db[si+i];
double* xdata = x[0]+i*ivcount;
for( j = 0; j < ivcount; j++ )
xdata[j] = x0data[j]*w[j*2] + w[j*2+1];
}
cvInitMatHeader( x1, dcount, ivcount, CV_64F, x[0] );
// forward pass, compute y[i]=w*x[i-1], x[i]=f(y[i]), df[i]=f'(y[i])
for( i = 1; i < l_count; i++ )
{
cvInitMatHeader( x2, dcount, layer_sizes->data.i[i], CV_64F, x[i] );
cvInitMatHeader( &_w, x1->cols, x2->cols, CV_64F, weights[i] );
cvGEMM( x1, &_w, 1, 0, 0, x2 );
_df = *x2;
_df.data.db = df[i];
calc_activ_func_deriv( x2, &_df, _w.data.db + _w.rows*_w.cols );
CV_SWAP( x1, x2, temp );
}
cvInitMatHeader( grad1, dcount, ovcount, CV_64F, buf_ptr );
w = weights[l_count+1];
grad2->data.db = buf_ptr + max_count*dcount;
// calculate error
if( u.type == CV_32F )
for( i = 0; i < dcount; i++ )
{
const float* udata = u.data.fl[si+i];
const double* xdata = x[l_count-1] + i*ovcount;
double* gdata = grad1->data.db + i*ovcount;
double sweight = sw ? sw[si+i] : inv_count, E1 = 0;
for( j = 0; j < ovcount; j++ )
{
double t = udata[j]*w[j*2] + w[j*2+1] - xdata[j];
gdata[j] = t*sweight;
E1 += t*t;
}
E += sweight*E1;
}
else
for( i = 0; i < dcount; i++ )
{
const double* udata = u.data.db[si+i];
const double* xdata = x[l_count-1] + i*ovcount;
double* gdata = grad1->data.db + i*ovcount;
double sweight = sw ? sw[si+i] : inv_count, E1 = 0;
for( j = 0; j < ovcount; j++ )
{
double t = udata[j]*w[j*2] + w[j*2+1] - xdata[j];
gdata[j] = t*sweight;
E1 += t*t;
}
E += sweight*E1;
}
// backward pass, update dEdw
for( i = l_count-1; i > 0; i-- )
{
n1 = layer_sizes->data.i[i-1]; n2 = layer_sizes->data.i[i];
cvInitMatHeader( &_df, dcount, n2, CV_64F, df[i] );
cvMul( grad1, &_df, grad1 );
cvInitMatHeader( &_dEdw, n1, n2, CV_64F, dEdw->data.db+(weights[i]-weights[0]) );
cvInitMatHeader( x1, dcount, n1, CV_64F, x[i-1] );
cvGEMM( x1, grad1, 1, &_dEdw, 1, &_dEdw, CV_GEMM_A_T );
// update bias part of dEdw
for( k = 0; k < dcount; k++ )
{
double* dst = _dEdw.data.db + n1*n2;
const double* src = grad1->data.db + k*n2;
for( j = 0; j < n2; j++ )
dst[j] += src[j];
}
cvInitMatHeader( &_w, n1, n2, CV_64F, weights[i] );
cvInitMatHeader( grad2, dcount, n1, CV_64F, grad2->data.db );
if( i > 1 )
cvGEMM( grad1, &_w, 1, 0, 0, grad2, CV_GEMM_B_T );
CV_SWAP( grad1, grad2, temp );
}
}
// now update weights
for( i = 1; i < l_count; i++ )
{
n1 = layer_sizes->data.i[i-1]; n2 = layer_sizes->data.i[i];
for( k = 0; k <= n1; k++ )
{
double* wk = weights[i]+k*n2;
size_t delta = wk - weights[0];
double* dwk = dw->data.db + delta;
double* dEdwk = dEdw->data.db + delta;
char* prevEk = (char*)(prev_dEdw_sign->data.ptr + delta);
for( j = 0; j < n2; j++ )
{
double Eval = dEdwk[j];
double dval = dwk[j];
double wval = wk[j];
int s = CV_SIGN(Eval);
int ss = prevEk[j]*s;
if( ss > 0 )
{
dval *= dw_plus;
dval = MIN( dval, dw_max );
dwk[j] = dval;
wk[j] = wval + dval*s;
}
else if( ss < 0 )
{
dval *= dw_minus;
dval = MAX( dval, dw_min );
prevEk[j] = 0;
dwk[j] = dval;
wk[j] = wval + dval*s;
}
else
{
prevEk[j] = (char)s;
wk[j] = wval + dval*s;
}
dEdwk[j] = 0.;
}
}
}
if( fabs(prev_E - E) < epsilon )
break;
prev_E = E;
E = 0;
}
__END__;
cvReleaseMat( &dw );
cvReleaseMat( &dEdw );
cvReleaseMat( &prev_dEdw_sign );
cvReleaseMat( &buf );
cvFree( &x );
return iter;
}
static void*
imdecode_( const Vector<uchar>& buf, int flags, int hdrtype, Mat* mat=0 )
{
IplImage* image = 0;
CvMat *matrix = 0;
Mat temp, *data = &temp;
char fnamebuf[L_tmpnam];
const char* filename = 0;
ImageDecoder decoder = findDecoder(buf);
if( !decoder.obj )
return 0;
if( !decoder->setSource(buf) )
{
filename = tmpnam(fnamebuf);
FILE* f = fopen( filename, "wb" );
if( !f )
return 0;
fwrite( &buf[0], 1, buf.size(), f );
fclose(f);
decoder->setSource(filename);
}
if( !decoder->readHeader() )
{
if( filename )
unlink(filename);
return 0;
}
CvSize size;
size.width = decoder->width();
size.height = decoder->height();
int type = decoder->type();
if( flags != -1 )
{
if( (flags & CV_LOAD_IMAGE_ANYDEPTH) == 0 )
type = CV_MAKETYPE(CV_8U, CV_MAT_CN(type));
if( (flags & CV_LOAD_IMAGE_COLOR) != 0 ||
((flags & CV_LOAD_IMAGE_ANYCOLOR) != 0 && CV_MAT_CN(type) > 1) )
type = CV_MAKETYPE(CV_MAT_DEPTH(type), 3);
else
type = CV_MAKETYPE(CV_MAT_DEPTH(type), 1);
}
if( hdrtype == LOAD_CVMAT || hdrtype == LOAD_MAT )
{
if( hdrtype == LOAD_CVMAT )
{
matrix = cvCreateMat( size.height, size.width, type );
temp = cvarrToMat(matrix);
}
else
{
mat->create( size.height, size.width, type );
data = mat;
}
}
else
{
image = cvCreateImage( size, cvIplDepth(type), CV_MAT_CN(type) );
temp = cvarrToMat(image);
}
bool code = decoder->readData( *data );
if( filename )
unlink(filename);
if( !code )
{
cvReleaseImage( &image );
cvReleaseMat( &matrix );
if( mat )
mat->release();
return 0;
}
return hdrtype == LOAD_CVMAT ? (void*)matrix :
hdrtype == LOAD_IMAGE ? (void*)image : (void*)mat;
}
JNIEXPORT void JNICALL Java_com_seasbase_video_io_VideoReader_DiffProc(JNIEnv * env, jobject obj, jstring jo,jint thd,jint nframes)
{
jclass jovideo = env->GetObjectClass(obj);
jmethodID appendInfo = env->GetMethodID(jovideo,"appendInfo", "(Lcom/seasbase/video/io/Info;)V");//关键代码行
jclass jinfo = env->FindClass("com/seasbase/video/io/Info");
jmethodID initInfo = env->GetMethodID(jinfo, "<init>","(II[BIIIILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
//调用代码
HMODULE dlh = NULL;
char buf[256]={0};
//dlh=LoadLibrary("VehicleTypeRecognition_D.dll");
//dlh=LoadLibrary("HelloWorld.dll");
if (!(dlh=LoadLibrary("VehicleTypeRecognition_D.dll")))
{
printf("LoadLibrary() failed: %d\n", GetLastError());
}
ThreadInit threadInit;
threadInit = (ThreadInit)GetProcAddress(dlh, "ITS_ThreadInit");//ITS_ThreadInit(); 进程启动时调用
/*threadInit = (ThreadInit)GetProcAddress(dlh, "PrintHelloWord");*/
(*threadInit)();
VehicleRecInit vehicleRecInit;
int iInitFlag;
char* pathvar = getenv("ALG_DIR");
sprintf(buf,"%smodel",pathvar);
char* modePath = buf;// ..\\bin\\model
vehicleRecInit = (VehicleRecInit)GetProcAddress(dlh, "ITS_VehicleRecInit");
vehproc.pInstance = (*vehicleRecInit)(modePath, iInitFlag);//初始化操作
char* fpath =NULL;
fpath = jstringTostring(env,jo);
CvCapture * capture = cvCreateFileCapture(fpath);
long nbFrames = (long) cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_COUNT);
if( !capture )
{
fprintf(stderr,"Could not initialize capturing...\n");
}
IplImage* pSrcImg =NULL;
////////////////////////////////////////////////////
while (cvGrabFrame(capture) != 0 && (vehproc.pFrame = cvRetrieveFrame(capture)) != NULL)
{
nframes++;
vehproc.nfrnum++;
/*if(vehproc.nfrnum>40)
{
if(vehproc.nfrnum%5!=0)
continue;
}*/
if (NULL==pSrcImg)
{
pSrcImg =cvCreateImage(cvSize(vehproc.pFrame->width,vehproc.pFrame->height),IPL_DEPTH_8U,3);
}
cvCopyImage(vehproc.pFrame,pSrcImg);
vehproc.VehiclePreProc(pSrcImg);
jobject info;
jstring jnumber;jstring jtype;jstring jcolor;
for (int j = 0; j < vehproc.vehCnt; j++)//
{
/*threadInit = (ThreadInit)GetProcAddress(dlh, "PrintHelloWord");
(*threadInit)();*/
IplImage * pOutput = vehproc.vehinfo[j].vehicleImg;//cvCreateImage(cvSize(vehproc.pFrame->width,vehproc.pFrame->height),IPL_DEPTH_8U,3);
//cvCopyImage(vehproc.pFrame,pOutput);vehproc.vehinfo[j].plateImg;
sprintf(buf,"E:\\aaaa\\%d-%d.jpg",nframes,j);
cvSaveImage(buf,pOutput);
CvMat* mat = cvEncodeImage(".jpg",pOutput);
jbyteArray jarrRV =env->NewByteArray(mat->cols);
/*env->NewFloatArray()
env->NewFloatArray()
env->NewFloatArray()*/
env->SetByteArrayRegion(jarrRV,0,mat->cols,(const jbyte *)mat->data.ptr);
cvReleaseMat(&mat);
jnumber = WindowsTojstring(env,vehproc.vehinfo[j].platenumber);
jtype = WindowsTojstring(env,vehproc.vehinfo[j].tempVehicleType);
jcolor= WindowsTojstring(env,vehproc.vehinfo[j].eVehicleColor);
//jnumber = env->NewStringUTF(vehproc.vehinfo[j].platenumber);
//jtype = env->NewStringUTF(vehproc.vehinfo[j].tempVehicleType);
//jbyteArray jarrRV =env->NewByteArray(1);
/*jnumber = env->NewStringUTF("fde");
jtype = env->NewStringUTF("bbb");
jcolor = env->NewStringUTF("ccab");*/
//黑AU5881
if (strcmp(vehproc.vehinfo[j].platenumber,"黑AU5881")==0)
{
system("pause");
}
info = env->NewObject(jinfo,initInfo,vehproc.nfrnum,j,jarrRV,vehproc.vehinfo[j].pointLT.x,vehproc.vehinfo[j].pointLT.y,vehproc.vehinfo[j].width,vehproc.vehinfo[j].height,jnumber,jtype,jcolor);
//info = env->NewObject(jinfo,initInfo,vehproc.nfrnum,j,jarrRV,100,4,5,6,jnumber,jtype,jcolor);
env->CallObjectMethod(obj,appendInfo,info);
env->DeleteLocalRef(info);
env->DeleteLocalRef(jarrRV);
cvReleaseImage(&pOutput);
}
//#ifdef DEBUG_OUTPUT_IMAGE
//sprintf(buf,"E:\\aaaa\\%da.jpg",nframes);
cvSaveImage(buf,vehproc.pFrame);
//sprintf(buf,"E:\\aaaa\\%db.jpg",nframes);
cvSaveImage(buf,pSrcImg);
//#endif
}
jstring jnumber;
jstring jtype;
jstring jcolor;
jnumber = env->NewStringUTF("aaaaa");
jtype = env->NewStringUTF("bbbbb");
jcolor = env->NewStringUTF("ccccc");
jbyteArray jarrRV1 =env->NewByteArray(1);////
jobject info1 = env->NewObject(jinfo,initInfo,-1,-1,jarrRV1,-1,2,3,4,jnumber,jtype,jcolor);
env->CallObjectMethod(obj,appendInfo,info1);
env->DeleteLocalRef(info1);
env->DeleteLocalRef(jarrRV1);
env->DeleteLocalRef(jinfo);
cvReleaseImage(&pSrcImg);
cvReleaseCapture(&capture); //释放视频空间
VehicleRecRelease vehicleRecRelease;
vehicleRecRelease = (VehicleRecRelease)GetProcAddress(dlh, "ITS_VehicleRecRelease");
(*vehicleRecRelease)(vehproc.pInstance);
return;
}
