generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
6bb509b44a
opencv/modules/legacy/src/epilines.cpp

3703 lines
106 KiB
C++
Raw Blame History

/*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 "precomp.hpp"
#include <float.h>
#include <limits.h>
/* Valery Mosyagin */
#undef quad
#define EPS64D 1e-9
int cvComputeEssentialMatrix( CvMatr32f rotMatr,
CvMatr32f transVect,
CvMatr32f essMatr);
int cvConvertEssential2Fundamental( CvMatr32f essMatr,
CvMatr32f fundMatr,
CvMatr32f cameraMatr1,
CvMatr32f cameraMatr2);
int cvComputeEpipolesFromFundMatrix(CvMatr32f fundMatr,
CvPoint3D32f* epipole1,
CvPoint3D32f* epipole2);
void icvTestPoint( CvPoint2D64d testPoint,
CvVect64d line1,CvVect64d line2,
CvPoint2D64d basePoint,
int* result);
int icvGetSymPoint3D( CvPoint3D64d pointCorner,
CvPoint3D64d point1,
CvPoint3D64d point2,
CvPoint3D64d *pointSym2)
{
double len1,len2;
double alpha;
icvGetPieceLength3D(pointCorner,point1,&len1);
if( len1 < EPS64D )
{
return CV_BADARG_ERR;
}
icvGetPieceLength3D(pointCorner,point2,&len2);
alpha = len2 / len1;
pointSym2->x = pointCorner.x + alpha*(point1.x - pointCorner.x);
pointSym2->y = pointCorner.y + alpha*(point1.y - pointCorner.y);
pointSym2->z = pointCorner.z + alpha*(point1.z - pointCorner.z);
return CV_NO_ERR;
}
/* author Valery Mosyagin */
/* Compute 3D point for scanline and alpha betta */
int icvCompute3DPoint( double alpha,double betta,
CvStereoLineCoeff* coeffs,
CvPoint3D64d* point)
{
double partX;
double partY;
double partZ;
double partAll;
double invPartAll;
double alphabetta = alpha*betta;
partAll = alpha - betta;
if( fabs(partAll) > 0.00001 ) /* alpha must be > betta */
{
partX = coeffs->Xcoef + coeffs->XcoefA *alpha +
coeffs->XcoefB*betta + coeffs->XcoefAB*alphabetta;
partY = coeffs->Ycoef + coeffs->YcoefA *alpha +
coeffs->YcoefB*betta + coeffs->YcoefAB*alphabetta;
partZ = coeffs->Zcoef + coeffs->ZcoefA *alpha +
coeffs->ZcoefB*betta + coeffs->ZcoefAB*alphabetta;
invPartAll = 1.0 / partAll;
point->x = partX * invPartAll;
point->y = partY * invPartAll;
point->z = partZ * invPartAll;
return CV_NO_ERR;
}
else
{
return CV_BADFACTOR_ERR;
}
}
/*--------------------------------------------------------------------------------------*/
/* Compute rotate matrix and trans vector for change system */
int icvCreateConvertMatrVect( CvMatr64d rotMatr1,
CvMatr64d transVect1,
CvMatr64d rotMatr2,
CvMatr64d transVect2,
CvMatr64d convRotMatr,
CvMatr64d convTransVect)
{
double invRotMatr2[9];
double tmpVect[3];
icvInvertMatrix_64d(rotMatr2,3,invRotMatr2);
/* Test for error */
icvMulMatrix_64d( rotMatr1,
3,3,
invRotMatr2,
3,3,
convRotMatr);
icvMulMatrix_64d( convRotMatr,
3,3,
transVect2,
1,3,
tmpVect);
icvSubVector_64d(transVect1,tmpVect,convTransVect,3);
return CV_NO_ERR;
}
/*--------------------------------------------------------------------------------------*/
/* Compute point coordinates in other system */
int icvConvertPointSystem(CvPoint3D64d M2,
CvPoint3D64d* M1,
CvMatr64d rotMatr,
CvMatr64d transVect
)
{
double tmpVect[3];
icvMulMatrix_64d( rotMatr,
3,3,
(double*)&M2,
1,3,
tmpVect);
icvAddVector_64d(tmpVect,transVect,(double*)M1,3);
return CV_NO_ERR;
}
/*--------------------------------------------------------------------------------------*/
static int icvComputeCoeffForStereoV3( double quad1[4][2],
double quad2[4][2],
int numScanlines,
CvMatr64d camMatr1,
CvMatr64d rotMatr1,
CvMatr64d transVect1,
CvMatr64d camMatr2,
CvMatr64d rotMatr2,
CvMatr64d transVect2,
CvStereoLineCoeff* startCoeffs,
int* needSwapCamera)
{
/* For each pair */
/* In this function we must define position of cameras */
CvPoint2D64d point1;
CvPoint2D64d point2;
CvPoint2D64d point3;
CvPoint2D64d point4;
int currLine;
*needSwapCamera = 0;
for( currLine = 0; currLine < numScanlines; currLine++ )
{
/* Compute points */
double alpha = ((double)currLine)/((double)(numScanlines)); /* maybe - 1 */
point1.x = (1.0 - alpha) * quad1[0][0] + alpha * quad1[3][0];
point1.y = (1.0 - alpha) * quad1[0][1] + alpha * quad1[3][1];
point2.x = (1.0 - alpha) * quad1[1][0] + alpha * quad1[2][0];
point2.y = (1.0 - alpha) * quad1[1][1] + alpha * quad1[2][1];
point3.x = (1.0 - alpha) * quad2[0][0] + alpha * quad2[3][0];
point3.y = (1.0 - alpha) * quad2[0][1] + alpha * quad2[3][1];
point4.x = (1.0 - alpha) * quad2[1][0] + alpha * quad2[2][0];
point4.y = (1.0 - alpha) * quad2[1][1] + alpha * quad2[2][1];
/* We can compute coeffs for this line */
icvComCoeffForLine( point1,
point2,
point3,
point4,
camMatr1,
rotMatr1,
transVect1,
camMatr2,
rotMatr2,
transVect2,
&startCoeffs[currLine],
needSwapCamera);
}
return CV_NO_ERR;
}
/*--------------------------------------------------------------------------------------*/
static int icvComputeCoeffForStereoNew( double quad1[4][2],
double quad2[4][2],
int numScanlines,
CvMatr32f camMatr1,
CvMatr32f rotMatr1,
CvMatr32f transVect1,
CvMatr32f camMatr2,
CvStereoLineCoeff* startCoeffs,
int* needSwapCamera)
{
/* Convert data */
double camMatr1_64d[9];
double camMatr2_64d[9];
double rotMatr1_64d[9];
double transVect1_64d[3];
double rotMatr2_64d[9];
double transVect2_64d[3];
icvCvt_32f_64d(camMatr1,camMatr1_64d,9);
icvCvt_32f_64d(camMatr2,camMatr2_64d,9);
icvCvt_32f_64d(rotMatr1,rotMatr1_64d,9);
icvCvt_32f_64d(transVect1,transVect1_64d,3);
rotMatr2_64d[0] = 1;
rotMatr2_64d[1] = 0;
rotMatr2_64d[2] = 0;
rotMatr2_64d[3] = 0;
rotMatr2_64d[4] = 1;
rotMatr2_64d[5] = 0;
rotMatr2_64d[6] = 0;
rotMatr2_64d[7] = 0;
rotMatr2_64d[8] = 1;
transVect2_64d[0] = 0;
transVect2_64d[1] = 0;
transVect2_64d[2] = 0;
int status = icvComputeCoeffForStereoV3( quad1,
quad2,
numScanlines,
camMatr1_64d,
rotMatr1_64d,
transVect1_64d,
camMatr2_64d,
rotMatr2_64d,
transVect2_64d,
startCoeffs,
needSwapCamera);
return status;
}
/*--------------------------------------------------------------------------------------*/
int icvComputeCoeffForStereo( CvStereoCamera* stereoCamera)
{
double quad1[4][2];
double quad2[4][2];
int i;
for( i = 0; i < 4; i++ )
{
quad1[i][0] = stereoCamera->quad[0][i].x;
quad1[i][1] = stereoCamera->quad[0][i].y;
quad2[i][0] = stereoCamera->quad[1][i].x;
quad2[i][1] = stereoCamera->quad[1][i].y;
}
icvComputeCoeffForStereoNew( quad1,
quad2,
stereoCamera->warpSize.height,
stereoCamera->camera[0]->matrix,
stereoCamera->rotMatrix,
stereoCamera->transVector,
stereoCamera->camera[1]->matrix,
stereoCamera->lineCoeffs,
&(stereoCamera->needSwapCameras));
return CV_OK;
}
/*--------------------------------------------------------------------------------------*/
int icvComCoeffForLine( CvPoint2D64d point1,
CvPoint2D64d point2,
CvPoint2D64d point3,
CvPoint2D64d point4,
CvMatr64d camMatr1,
CvMatr64d rotMatr1,
CvMatr64d transVect1,
CvMatr64d camMatr2,
CvMatr64d rotMatr2,
CvMatr64d transVect2,
CvStereoLineCoeff* coeffs,
int* needSwapCamera)
{
/* Get direction for all points */
/* Direction for camera 1 */
CvPoint3D64f direct1;
CvPoint3D64f direct2;
CvPoint3D64f camPoint1;
CvPoint3D64f directS3;
CvPoint3D64f directS4;
CvPoint3D64f direct3;
CvPoint3D64f direct4;
CvPoint3D64f camPoint2;
icvGetDirectionForPoint( point1,
camMatr1,
&direct1);
icvGetDirectionForPoint( point2,
camMatr1,
&direct2);
/* Direction for camera 2 */
icvGetDirectionForPoint( point3,
camMatr2,
&directS3);
icvGetDirectionForPoint( point4,
camMatr2,
&directS4);
/* Create convertion for camera 2: two direction and camera point */
double convRotMatr[9];
double convTransVect[3];
icvCreateConvertMatrVect( rotMatr1,
transVect1,
rotMatr2,
transVect2,
convRotMatr,
convTransVect);
CvPoint3D64f zeroVect;
zeroVect.x = zeroVect.y = zeroVect.z = 0.0;
camPoint1.x = camPoint1.y = camPoint1.z = 0.0;
icvConvertPointSystem(directS3,&direct3,convRotMatr,convTransVect);
icvConvertPointSystem(directS4,&direct4,convRotMatr,convTransVect);
icvConvertPointSystem(zeroVect,&camPoint2,convRotMatr,convTransVect);
CvPoint3D64f pointB;
int postype = 0;
/* Changed order */
/* Compute point B: xB,yB,zB */
icvGetCrossLines(camPoint1,direct2,
camPoint2,direct3,
&pointB);
if( pointB.z < 0 )/* If negative use other lines for cross */
{
postype = 1;
icvGetCrossLines(camPoint1,direct1,
camPoint2,direct4,
&pointB);
}
CvPoint3D64d pointNewA;
CvPoint3D64d pointNewC;
pointNewA.x = pointNewA.y = pointNewA.z = 0;
pointNewC.x = pointNewC.y = pointNewC.z = 0;
if( postype == 0 )
{
icvGetSymPoint3D( camPoint1,
direct1,
pointB,
&pointNewA);
icvGetSymPoint3D( camPoint2,
direct4,
pointB,
&pointNewC);
}
else
{/* In this case we must change cameras */
*needSwapCamera = 1;
icvGetSymPoint3D( camPoint2,
direct3,
pointB,
&pointNewA);
icvGetSymPoint3D( camPoint1,
direct2,
pointB,
&pointNewC);
}
double gamma;
double xA,yA,zA;
double xB,yB,zB;
double xC,yC,zC;
xA = pointNewA.x;
yA = pointNewA.y;
zA = pointNewA.z;
xB = pointB.x;
yB = pointB.y;
zB = pointB.z;
xC = pointNewC.x;
yC = pointNewC.y;
zC = pointNewC.z;
double len1,len2;
len1 = sqrt( (xA-xB)*(xA-xB) + (yA-yB)*(yA-yB) + (zA-zB)*(zA-zB) );
len2 = sqrt( (xB-xC)*(xB-xC) + (yB-yC)*(yB-yC) + (zB-zC)*(zB-zC) );
gamma = len2 / len1;
icvComputeStereoLineCoeffs( pointNewA,
pointB,
camPoint1,
gamma,
coeffs);
return CV_NO_ERR;
}
/*--------------------------------------------------------------------------------------*/
int icvGetDirectionForPoint( CvPoint2D64d point,
CvMatr64d camMatr,
CvPoint3D64d* direct)
{
/* */
double invMatr[9];
/* Invert matrix */
icvInvertMatrix_64d(camMatr,3,invMatr);
/* TEST FOR ERRORS */
double vect[3];
vect[0] = point.x;
vect[1] = point.y;
vect[2] = 1;
/* Mul matr */
icvMulMatrix_64d( invMatr,
3,3,
vect,
1,3,
(double*)direct);
return CV_NO_ERR;
}
/*--------------------------------------------------------------------------------------*/
int icvGetCrossLines(CvPoint3D64d point11,CvPoint3D64d point12,
CvPoint3D64d point21,CvPoint3D64d point22,
CvPoint3D64d* midPoint)
{
double xM,yM,zM;
double xN,yN,zN;
double xA,yA,zA;
double xB,yB,zB;
double xC,yC,zC;
double xD,yD,zD;
xA = point11.x;
yA = point11.y;
zA = point11.z;
xB = point12.x;
yB = point12.y;
zB = point12.z;
xC = point21.x;
yC = point21.y;
zC = point21.z;
xD = point22.x;
yD = point22.y;
zD = point22.z;
double a11,a12,a21,a22;
double b1,b2;
a11 = (xB-xA)*(xB-xA)+(yB-yA)*(yB-yA)+(zB-zA)*(zB-zA);
a12 = -(xD-xC)*(xB-xA)-(yD-yC)*(yB-yA)-(zD-zC)*(zB-zA);
a21 = (xB-xA)*(xD-xC)+(yB-yA)*(yD-yC)+(zB-zA)*(zD-zC);
a22 = -(xD-xC)*(xD-xC)-(yD-yC)*(yD-yC)-(zD-zC)*(zD-zC);
b1 = -( (xA-xC)*(xB-xA)+(yA-yC)*(yB-yA)+(zA-zC)*(zB-zA) );
b2 = -( (xA-xC)*(xD-xC)+(yA-yC)*(yD-yC)+(zA-zC)*(zD-zC) );
double delta;
double deltaA,deltaB;
double alpha,betta;
delta = a11*a22-a12*a21;
if( fabs(delta) < EPS64D )
{
/*return ERROR;*/
}
deltaA = b1*a22-b2*a12;
deltaB = a11*b2-b1*a21;
alpha = deltaA / delta;
betta = deltaB / delta;
xM = xA+alpha*(xB-xA);
yM = yA+alpha*(yB-yA);
zM = zA+alpha*(zB-zA);
xN = xC+betta*(xD-xC);
yN = yC+betta*(yD-yC);
zN = zC+betta*(zD-zC);
/* Compute middle point */
midPoint->x = (xM + xN) * 0.5;
midPoint->y = (yM + yN) * 0.5;
midPoint->z = (zM + zN) * 0.5;
return CV_NO_ERR;
}
/*--------------------------------------------------------------------------------------*/
int icvComputeStereoLineCoeffs( CvPoint3D64d pointA,
CvPoint3D64d pointB,
CvPoint3D64d pointCam1,
double gamma,
CvStereoLineCoeff* coeffs)
{
double x1,y1,z1;
x1 = pointCam1.x;
y1 = pointCam1.y;
z1 = pointCam1.z;
double xA,yA,zA;
double xB,yB,zB;
xA = pointA.x;
yA = pointA.y;
zA = pointA.z;
xB = pointB.x;
yB = pointB.y;
zB = pointB.z;
if( gamma > 0 )
{
coeffs->Xcoef = -x1 + xA;
coeffs->XcoefA = xB + x1 - xA;
coeffs->XcoefB = -xA - gamma * x1 + gamma * xA;
coeffs->XcoefAB = -xB + xA + gamma * xB - gamma * xA;
coeffs->Ycoef = -y1 + yA;
coeffs->YcoefA = yB + y1 - yA;
coeffs->YcoefB = -yA - gamma * y1 + gamma * yA;
coeffs->YcoefAB = -yB + yA + gamma * yB - gamma * yA;
coeffs->Zcoef = -z1 + zA;
coeffs->ZcoefA = zB + z1 - zA;
coeffs->ZcoefB = -zA - gamma * z1 + gamma * zA;
coeffs->ZcoefAB = -zB + zA + gamma * zB - gamma * zA;
}
else
{
gamma = - gamma;
coeffs->Xcoef = -( -x1 + xA);
coeffs->XcoefB = -( xB + x1 - xA);
coeffs->XcoefA = -( -xA - gamma * x1 + gamma * xA);
coeffs->XcoefAB = -( -xB + xA + gamma * xB - gamma * xA);
coeffs->Ycoef = -( -y1 + yA);
coeffs->YcoefB = -( yB + y1 - yA);
coeffs->YcoefA = -( -yA - gamma * y1 + gamma * yA);
coeffs->YcoefAB = -( -yB + yA + gamma * yB - gamma * yA);
coeffs->Zcoef = -( -z1 + zA);
coeffs->ZcoefB = -( zB + z1 - zA);
coeffs->ZcoefA = -( -zA - gamma * z1 + gamma * zA);
coeffs->ZcoefAB = -( -zB + zA + gamma * zB - gamma * zA);
}
return CV_NO_ERR;
}
/*--------------------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------------------*/
/* This function get minimum angle started at point which contains rect */
int icvGetAngleLine( CvPoint2D64d startPoint, CvSize imageSize,CvPoint2D64d *point1,CvPoint2D64d *point2)
{
/* Get crosslines with image corners */
/* Find four lines */
CvPoint2D64d pa,pb,pc,pd;
pa.x = 0;
pa.y = 0;
pb.x = imageSize.width-1;
pb.y = 0;
pd.x = imageSize.width-1;
pd.y = imageSize.height-1;
pc.x = 0;
pc.y = imageSize.height-1;
/* We can compute points for angle */
/* Test for place section */
if( startPoint.x < 0 )
{/* 1,4,7 */
if( startPoint.y < 0)
{/* 1 */
*point1 = pb;
*point2 = pc;
}
else if( startPoint.y > imageSize.height-1 )
{/* 7 */
*point1 = pa;
*point2 = pd;
}
else
{/* 4 */
*point1 = pa;
*point2 = pc;
}
}
else if ( startPoint.x > imageSize.width-1 )
{/* 3,6,9 */
if( startPoint.y < 0 )
{/* 3 */
*point1 = pa;
*point2 = pd;
}
else if ( startPoint.y > imageSize.height-1 )
{/* 9 */
*point1 = pb;
*point2 = pc;
}
else
{/* 6 */
*point1 = pb;
*point2 = pd;
}
}
else
{/* 2,5,8 */
if( startPoint.y < 0 )
{/* 2 */
if( startPoint.x < imageSize.width/2 )
{
*point1 = pb;
*point2 = pa;
}
else
{
*point1 = pa;
*point2 = pb;
}
}
else if( startPoint.y > imageSize.height-1 )
{/* 8 */
if( startPoint.x < imageSize.width/2 )
{
*point1 = pc;
*point2 = pd;
}
else
{
*point1 = pd;
*point2 = pc;
}
}
else
{/* 5 - point in the image */
return 2;
}
}
return 0;
}/* GetAngleLine */
/*---------------------------------------------------------------------------------------*/
void icvGetCoefForPiece( CvPoint2D64d p_start,CvPoint2D64d p_end,
double *a,double *b,double *c,
int* result)
{
double det;
double detA,detB,detC;
det = p_start.x*p_end.y+p_end.x+p_start.y-p_end.y-p_start.y*p_end.x-p_start.x;
if( fabs(det) < EPS64D)/* Error */
{
*result = 0;
return;
}
detA = p_start.y - p_end.y;
detB = p_end.x - p_start.x;
detC = p_start.x*p_end.y - p_end.x*p_start.y;
double invDet = 1.0 / det;
*a = detA * invDet;
*b = detB * invDet;
*c = detC * invDet;
*result = 1;
return;
}
/*---------------------------------------------------------------------------------------*/
/* Get common area of rectifying */
static void icvGetCommonArea( CvSize imageSize,
CvPoint3D64d epipole1,CvPoint3D64d epipole2,
CvMatr64d fundMatr,
CvVect64d coeff11,CvVect64d coeff12,
CvVect64d coeff21,CvVect64d coeff22,
int* result)
{
int res = 0;
CvPoint2D64d point11;
CvPoint2D64d point12;
CvPoint2D64d point21;
CvPoint2D64d point22;
double corr11[3];
double corr12[3];
double corr21[3];
double corr22[3];
double pointW11[3];
double pointW12[3];
double pointW21[3];
double pointW22[3];
double transFundMatr[3*3];
/* Compute transpose of fundamental matrix */
icvTransposeMatrix_64d( fundMatr, 3, 3, transFundMatr );
CvPoint2D64d epipole1_2d;
CvPoint2D64d epipole2_2d;
if( fabs(epipole1.z) < 1e-8 )
{/* epipole1 in infinity */
*result = 0;
return;
}
epipole1_2d.x = epipole1.x / epipole1.z;
epipole1_2d.y = epipole1.y / epipole1.z;
if( fabs(epipole2.z) < 1e-8 )
{/* epipole2 in infinity */
*result = 0;
return;
}
epipole2_2d.x = epipole2.x / epipole2.z;
epipole2_2d.y = epipole2.y / epipole2.z;
int stat = icvGetAngleLine( epipole1_2d, imageSize,&point11,&point12);
if( stat == 2 )
{
/* No angle */
*result = 0;
return;
}
stat = icvGetAngleLine( epipole2_2d, imageSize,&point21,&point22);
if( stat == 2 )
{
/* No angle */
*result = 0;
return;
}
/* ============= Computation for line 1 ================ */
/* Find correspondence line for angle points11 */
/* corr21 = Fund'*p1 */
pointW11[0] = point11.x;
pointW11[1] = point11.y;
pointW11[2] = 1.0;
icvTransformVector_64d( transFundMatr, /* !!! Modified from not transposed */
pointW11,
corr21,
3,3);
/* Find crossing of line with image 2 */
CvPoint2D64d start;
CvPoint2D64d end;
icvGetCrossRectDirect( imageSize,
corr21[0],corr21[1],corr21[2],
&start,&end,
&res);
if( res == 0 )
{/* We have not cross */
/* We must define new angle */
pointW21[0] = point21.x;
pointW21[1] = point21.y;
pointW21[2] = 1.0;
/* Find correspondence line for this angle points */
/* We know point and try to get corr line */
/* For point21 */
/* corr11 = Fund * p21 */
icvTransformVector_64d( fundMatr, /* !!! Modified */
pointW21,
corr11,
3,3);
/* We have cross. And it's result cross for up line. Set result coefs */
/* Set coefs for line 1 image 1 */
coeff11[0] = corr11[0];
coeff11[1] = corr11[1];
coeff11[2] = corr11[2];
/* Set coefs for line 1 image 2 */
icvGetCoefForPiece( epipole2_2d,point21,
&coeff21[0],&coeff21[1],&coeff21[2],
&res);
if( res == 0 )
{
*result = 0;
return;/* Error */
}
}
else
{/* Line 1 cross image 2 */
/* Set coefs for line 1 image 1 */
icvGetCoefForPiece( epipole1_2d,point11,
&coeff11[0],&coeff11[1],&coeff11[2],
&res);
if( res == 0 )
{
*result = 0;
return;/* Error */
}
/* Set coefs for line 1 image 2 */
coeff21[0] = corr21[0];
coeff21[1] = corr21[1];
coeff21[2] = corr21[2];
}
/* ============= Computation for line 2 ================ */
/* Find correspondence line for angle points11 */
/* corr22 = Fund*p2 */
pointW12[0] = point12.x;
pointW12[1] = point12.y;
pointW12[2] = 1.0;
icvTransformVector_64d( transFundMatr,
pointW12,
corr22,
3,3);
/* Find crossing of line with image 2 */
icvGetCrossRectDirect( imageSize,
corr22[0],corr22[1],corr22[2],
&start,&end,
&res);
if( res == 0 )
{/* We have not cross */
/* We must define new angle */
pointW22[0] = point22.x;
pointW22[1] = point22.y;
pointW22[2] = 1.0;
/* Find correspondence line for this angle points */
/* We know point and try to get corr line */
/* For point21 */
/* corr2 = Fund' * p1 */
icvTransformVector_64d( fundMatr,
pointW22,
corr12,
3,3);
/* We have cross. And it's result cross for down line. Set result coefs */
/* Set coefs for line 2 image 1 */
coeff12[0] = corr12[0];
coeff12[1] = corr12[1];
coeff12[2] = corr12[2];
/* Set coefs for line 1 image 2 */
icvGetCoefForPiece( epipole2_2d,point22,
&coeff22[0],&coeff22[1],&coeff22[2],
&res);
if( res == 0 )
{
*result = 0;
return;/* Error */
}
}
else
{/* Line 2 cross image 2 */
/* Set coefs for line 2 image 1 */
icvGetCoefForPiece( epipole1_2d,point12,
&coeff12[0],&coeff12[1],&coeff12[2],
&res);
if( res == 0 )
{
*result = 0;
return;/* Error */
}
/* Set coefs for line 1 image 2 */
coeff22[0] = corr22[0];
coeff22[1] = corr22[1];
coeff22[2] = corr22[2];
}
/* Now we know common area */
return;
}/* GetCommonArea */
/*---------------------------------------------------------------------------------------*/
/* Get cross for direction1 and direction2 */
/* Result = 1 - cross */
/* Result = 2 - parallel and not equal */
/* Result = 3 - parallel and equal */
void icvGetCrossDirectDirect( CvVect64d direct1,CvVect64d direct2,
CvPoint2D64d *cross,int* result)
{
double det = direct1[0]*direct2[1] - direct2[0]*direct1[1];
double detx = -direct1[2]*direct2[1] + direct1[1]*direct2[2];
if( fabs(det) > EPS64D )
{/* Have cross */
cross->x = detx/det;
cross->y = (-direct1[0]*direct2[2] + direct2[0]*direct1[2])/det;
*result = 1;
}
else
{/* may be parallel */
if( fabs(detx) > EPS64D )
{/* parallel and not equal */
*result = 2;
}
else
{/* equals */
*result = 3;
}
}
return;
}
/*---------------------------------------------------------------------------------------*/
/* Get cross for piece p1,p2 and direction a,b,c */
/* Result = 0 - no cross */
/* Result = 1 - cross */
/* Result = 2 - parallel and not equal */
/* Result = 3 - parallel and equal */
void icvGetCrossPieceDirect( CvPoint2D64d p_start,CvPoint2D64d p_end,
double a,double b,double c,
CvPoint2D64d *cross,int* result)
{
if( (a*p_start.x + b*p_start.y + c) * (a*p_end.x + b*p_end.y + c) <= 0 )
{/* Have cross */
double det;
double detxc,detyc;
det = a * (p_end.x - p_start.x) + b * (p_end.y - p_start.y);
if( fabs(det) < EPS64D )
{/* lines are parallel and may be equal or line is point */
if( fabs(a*p_start.x + b*p_start.y + c) < EPS64D )
{/* line is point or not diff */
*result = 3;
return;
}
else
{
*result = 2;
}
return;
}
detxc = b*(p_end.y*p_start.x - p_start.y*p_end.x) + c*(p_start.x - p_end.x);
detyc = a*(p_end.x*p_start.y - p_start.x*p_end.y) + c*(p_start.y - p_end.y);
cross->x = detxc / det;
cross->y = detyc / det;
*result = 1;
}
else
{
*result = 0;
}
return;
}
/*--------------------------------------------------------------------------------------*/
void icvGetCrossPiecePiece( CvPoint2D64d p1_start,CvPoint2D64d p1_end,
CvPoint2D64d p2_start,CvPoint2D64d p2_end,
CvPoint2D64d* cross,
int* result)
{
double ex1,ey1,ex2,ey2;
double px1,py1,px2,py2;
double del;
double delA,delB,delX,delY;
double alpha,betta;
ex1 = p1_start.x;
ey1 = p1_start.y;
ex2 = p1_end.x;
ey2 = p1_end.y;
px1 = p2_start.x;
py1 = p2_start.y;
px2 = p2_end.x;
py2 = p2_end.y;
del = (py1-py2)*(ex1-ex2)-(px1-px2)*(ey1-ey2);
if( fabs(del) <= EPS64D )
{/* May be they are parallel !!! */
*result = 0;
return;
}
delA = (ey1-ey2)*(ex1-px1) + (ex1-ex2)*(py1-ey1);
delB = (py1-py2)*(ex1-px1) + (px1-px2)*(py1-ey1);
alpha = delA / del;
betta = delB / del;
if( alpha < 0 || alpha > 1.0 || betta < 0 || betta > 1.0)
{
*result = 0;
return;
}
delX = (px1-px2)*(ey1*(ex1-ex2)-ex1*(ey1-ey2))+
(ex1-ex2)*(px1*(py1-py2)-py1*(px1-px2));
delY = (py1-py2)*(ey1*(ex1-ex2)-ex1*(ey1-ey2))+
(ey1-ey2)*(px1*(py1-py2)-py1*(px1-px2));
cross->x = delX / del;
cross->y = delY / del;
*result = 1;
return;
}
/*---------------------------------------------------------------------------------------*/
void icvGetPieceLength(CvPoint2D64d point1,CvPoint2D64d point2,double* dist)
{
double dx = point2.x - point1.x;
double dy = point2.y - point1.y;
*dist = sqrt( dx*dx + dy*dy );
return;
}
/*---------------------------------------------------------------------------------------*/
void icvGetPieceLength3D(CvPoint3D64d point1,CvPoint3D64d point2,double* dist)
{
double dx = point2.x - point1.x;
double dy = point2.y - point1.y;
double dz = point2.z - point1.z;
*dist = sqrt( dx*dx + dy*dy + dz*dz );
return;
}
/*---------------------------------------------------------------------------------------*/
/* Find line from epipole which cross image rect */
/* Find points of cross 0 or 1 or 2. Return number of points in cross */
void icvGetCrossRectDirect( CvSize imageSize,
double a,double b,double c,
CvPoint2D64d *start,CvPoint2D64d *end,
int* result)
{
CvPoint2D64d frameBeg;
CvPoint2D64d frameEnd;
CvPoint2D64d cross[4];
int haveCross[4];
haveCross[0] = 0;
haveCross[1] = 0;
haveCross[2] = 0;
haveCross[3] = 0;
frameBeg.x = 0;
frameBeg.y = 0;
frameEnd.x = imageSize.width;
frameEnd.y = 0;
icvGetCrossPieceDirect(frameBeg,frameEnd,a,b,c,&cross[0],&haveCross[0]);
frameBeg.x = imageSize.width;
frameBeg.y = 0;
frameEnd.x = imageSize.width;
frameEnd.y = imageSize.height;
icvGetCrossPieceDirect(frameBeg,frameEnd,a,b,c,&cross[1],&haveCross[1]);
frameBeg.x = imageSize.width;
frameBeg.y = imageSize.height;
frameEnd.x = 0;
frameEnd.y = imageSize.height;
icvGetCrossPieceDirect(frameBeg,frameEnd,a,b,c,&cross[2],&haveCross[2]);
frameBeg.x = 0;
frameBeg.y = imageSize.height;
frameEnd.x = 0;
frameEnd.y = 0;
icvGetCrossPieceDirect(frameBeg,frameEnd,a,b,c,&cross[3],&haveCross[3]);
double maxDist;
int maxI=0,maxJ=0;
int i,j;
maxDist = -1.0;
double distance;
for( i = 0; i < 3; i++ )
{
if( haveCross[i] == 1 )
{
for( j = i + 1; j < 4; j++ )
{
if( haveCross[j] == 1)
{/* Compute dist */
icvGetPieceLength(cross[i],cross[j],&distance);
if( distance > maxDist )
{
maxI = i;
maxJ = j;
maxDist = distance;
}
}
}
}
}
if( maxDist >= 0 )
{/* We have cross */
*start = cross[maxI];
*result = 1;
if( maxDist > 0 )
{
*end = cross[maxJ];
*result = 2;
}
}
else
{
*result = 0;
}
return;
}/* GetCrossRectDirect */
/*---------------------------------------------------------------------------------------*/
void icvProjectPointToImage( CvPoint3D64d point,
CvMatr64d camMatr,CvMatr64d rotMatr,CvVect64d transVect,
CvPoint2D64d* projPoint)
{
double tmpVect1[3];
double tmpVect2[3];
icvMulMatrix_64d ( rotMatr,
3,3,
(double*)&point,
1,3,
tmpVect1);
icvAddVector_64d ( tmpVect1, transVect,tmpVect2, 3);
icvMulMatrix_64d ( camMatr,
3,3,
tmpVect2,
1,3,
tmpVect1);
projPoint->x = tmpVect1[0] / tmpVect1[2];
projPoint->y = tmpVect1[1] / tmpVect1[2];
return;
}
/*---------------------------------------------------------------------------------------*/
/* Get quads for transform images */
void icvGetQuadsTransform(
CvSize imageSize,
CvMatr64d camMatr1,
CvMatr64d rotMatr1,
CvVect64d transVect1,
CvMatr64d camMatr2,
CvMatr64d rotMatr2,
CvVect64d transVect2,
CvSize* warpSize,
double quad1[4][2],
double quad2[4][2],
CvMatr64d fundMatr,
CvPoint3D64d* epipole1,
CvPoint3D64d* epipole2
)
{
/* First compute fundamental matrix and epipoles */
int res;
/* Compute epipoles and fundamental matrix using new functions */
{
double convRotMatr[9];
double convTransVect[3];
icvCreateConvertMatrVect( rotMatr1,
transVect1,
rotMatr2,
transVect2,
convRotMatr,
convTransVect);
float convRotMatr_32f[9];
float convTransVect_32f[3];
icvCvt_64d_32f(convRotMatr,convRotMatr_32f,9);
icvCvt_64d_32f(convTransVect,convTransVect_32f,3);
/* We know R and t */
/* Compute essential matrix */
float essMatr[9];
float fundMatr_32f[9];
float camMatr1_32f[9];
float camMatr2_32f[9];
icvCvt_64d_32f(camMatr1,camMatr1_32f,9);
icvCvt_64d_32f(camMatr2,camMatr2_32f,9);
cvComputeEssentialMatrix( convRotMatr_32f,
convTransVect_32f,
essMatr);
cvConvertEssential2Fundamental( essMatr,
fundMatr_32f,
camMatr1_32f,
camMatr2_32f);
CvPoint3D32f epipole1_32f;
CvPoint3D32f epipole2_32f;
cvComputeEpipolesFromFundMatrix( fundMatr_32f,
&epipole1_32f,
&epipole2_32f);
/* copy to 64d epipoles */
epipole1->x = epipole1_32f.x;
epipole1->y = epipole1_32f.y;
epipole1->z = epipole1_32f.z;
epipole2->x = epipole2_32f.x;
epipole2->y = epipole2_32f.y;
epipole2->z = epipole2_32f.z;
/* Convert fundamental matrix */
icvCvt_32f_64d(fundMatr_32f,fundMatr,9);
}
double coeff11[3];
double coeff12[3];
double coeff21[3];
double coeff22[3];
icvGetCommonArea( imageSize,
*epipole1,*epipole2,
fundMatr,
coeff11,coeff12,
coeff21,coeff22,
&res);
CvPoint2D64d point11, point12,point21, point22;
double width1,width2;
double height1,height2;
double tmpHeight1,tmpHeight2;
CvPoint2D64d epipole1_2d;
CvPoint2D64d epipole2_2d;
/* ----- Image 1 ----- */
if( fabs(epipole1->z) < 1e-8 )
{
return;
}
epipole1_2d.x = epipole1->x / epipole1->z;
epipole1_2d.y = epipole1->y / epipole1->z;
icvGetCutPiece( coeff11,coeff12,
epipole1_2d,
imageSize,
&point11,&point12,
&point21,&point22,
&res);
/* Compute distance */
icvGetPieceLength(point11,point21,&width1);
icvGetPieceLength(point11,point12,&tmpHeight1);
icvGetPieceLength(point21,point22,&tmpHeight2);
height1 = MAX(tmpHeight1,tmpHeight2);
quad1[0][0] = point11.x;
quad1[0][1] = point11.y;
quad1[1][0] = point21.x;
quad1[1][1] = point21.y;
quad1[2][0] = point22.x;
quad1[2][1] = point22.y;
quad1[3][0] = point12.x;
quad1[3][1] = point12.y;
/* ----- Image 2 ----- */
if( fabs(epipole2->z) < 1e-8 )
{
return;
}
epipole2_2d.x = epipole2->x / epipole2->z;
epipole2_2d.y = epipole2->y / epipole2->z;
icvGetCutPiece( coeff21,coeff22,
epipole2_2d,
imageSize,
&point11,&point12,
&point21,&point22,
&res);
/* Compute distance */
icvGetPieceLength(point11,point21,&width2);
icvGetPieceLength(point11,point12,&tmpHeight1);
icvGetPieceLength(point21,point22,&tmpHeight2);
height2 = MAX(tmpHeight1,tmpHeight2);
quad2[0][0] = point11.x;
quad2[0][1] = point11.y;
quad2[1][0] = point21.x;
quad2[1][1] = point21.y;
quad2[2][0] = point22.x;
quad2[2][1] = point22.y;
quad2[3][0] = point12.x;
quad2[3][1] = point12.y;
/*=======================================================*/
/* This is a new additional way to compute quads. */
/* We must correct quads */
{
double convRotMatr[9];
double convTransVect[3];
double newQuad1[4][2];
double newQuad2[4][2];
icvCreateConvertMatrVect( rotMatr1,
transVect1,
rotMatr2,
transVect2,
convRotMatr,
convTransVect);
/* -------------Compute for first image-------------- */
CvPoint2D32f pointb1;
CvPoint2D32f pointe1;
CvPoint2D32f pointb2;
CvPoint2D32f pointe2;
pointb1.x = (float)quad1[0][0];
pointb1.y = (float)quad1[0][1];
pointe1.x = (float)quad1[3][0];
pointe1.y = (float)quad1[3][1];
icvComputeeInfiniteProject1(convRotMatr,
camMatr1,
camMatr2,
pointb1,
&pointb2);
icvComputeeInfiniteProject1(convRotMatr,
camMatr1,
camMatr2,
pointe1,
&pointe2);
/* JUST TEST FOR POINT */
/* Compute distances */
double dxOld,dyOld;
double dxNew,dyNew;
double distOld,distNew;
dxOld = quad2[1][0] - quad2[0][0];
dyOld = quad2[1][1] - quad2[0][1];
distOld = dxOld*dxOld + dyOld*dyOld;
dxNew = quad2[1][0] - pointb2.x;
dyNew = quad2[1][1] - pointb2.y;
distNew = dxNew*dxNew + dyNew*dyNew;
if( distNew > distOld )
{/* Get new points for second quad */
newQuad2[0][0] = pointb2.x;
newQuad2[0][1] = pointb2.y;
newQuad2[3][0] = pointe2.x;
newQuad2[3][1] = pointe2.y;
newQuad1[0][0] = quad1[0][0];
newQuad1[0][1] = quad1[0][1];
newQuad1[3][0] = quad1[3][0];
newQuad1[3][1] = quad1[3][1];
}
else
{/* Get new points for first quad */
pointb2.x = (float)quad2[0][0];
pointb2.y = (float)quad2[0][1];
pointe2.x = (float)quad2[3][0];
pointe2.y = (float)quad2[3][1];
icvComputeeInfiniteProject2(convRotMatr,
camMatr1,
camMatr2,
&pointb1,
pointb2);
icvComputeeInfiniteProject2(convRotMatr,
camMatr1,
camMatr2,
&pointe1,
pointe2);
/* JUST TEST FOR POINT */
newQuad2[0][0] = quad2[0][0];
newQuad2[0][1] = quad2[0][1];
newQuad2[3][0] = quad2[3][0];
newQuad2[3][1] = quad2[3][1];
newQuad1[0][0] = pointb1.x;
newQuad1[0][1] = pointb1.y;
newQuad1[3][0] = pointe1.x;
newQuad1[3][1] = pointe1.y;
}
/* -------------Compute for second image-------------- */
pointb1.x = (float)quad1[1][0];
pointb1.y = (float)quad1[1][1];
pointe1.x = (float)quad1[2][0];
pointe1.y = (float)quad1[2][1];
icvComputeeInfiniteProject1(convRotMatr,
camMatr1,
camMatr2,
pointb1,
&pointb2);
icvComputeeInfiniteProject1(convRotMatr,
camMatr1,
camMatr2,
pointe1,
&pointe2);
/* Compute distances */
dxOld = quad2[0][0] - quad2[1][0];
dyOld = quad2[0][1] - quad2[1][1];
distOld = dxOld*dxOld + dyOld*dyOld;
dxNew = quad2[0][0] - pointb2.x;
dyNew = quad2[0][1] - pointb2.y;
distNew = dxNew*dxNew + dyNew*dyNew;
if( distNew > distOld )
{/* Get new points for second quad */
newQuad2[1][0] = pointb2.x;
newQuad2[1][1] = pointb2.y;
newQuad2[2][0] = pointe2.x;
newQuad2[2][1] = pointe2.y;
newQuad1[1][0] = quad1[1][0];
newQuad1[1][1] = quad1[1][1];
newQuad1[2][0] = quad1[2][0];
newQuad1[2][1] = quad1[2][1];
}
else
{/* Get new points for first quad */
pointb2.x = (float)quad2[1][0];
pointb2.y = (float)quad2[1][1];
pointe2.x = (float)quad2[2][0];
pointe2.y = (float)quad2[2][1];
icvComputeeInfiniteProject2(convRotMatr,
camMatr1,
camMatr2,
&pointb1,
pointb2);
icvComputeeInfiniteProject2(convRotMatr,
camMatr1,
camMatr2,
&pointe1,
pointe2);
newQuad2[1][0] = quad2[1][0];
newQuad2[1][1] = quad2[1][1];
newQuad2[2][0] = quad2[2][0];
newQuad2[2][1] = quad2[2][1];
newQuad1[1][0] = pointb1.x;
newQuad1[1][1] = pointb1.y;
newQuad1[2][0] = pointe1.x;
newQuad1[2][1] = pointe1.y;
}
/*-------------------------------------------------------------------------------*/
/* Copy new quads to old quad */
int i;
for( i = 0; i < 4; i++ )
{
{
quad1[i][0] = newQuad1[i][0];
quad1[i][1] = newQuad1[i][1];
quad2[i][0] = newQuad2[i][0];
quad2[i][1] = newQuad2[i][1];
}
}
}
/*=======================================================*/
double warpWidth,warpHeight;
warpWidth = MAX(width1,width2);
warpHeight = MAX(height1,height2);
warpSize->width = (int)warpWidth;
warpSize->height = (int)warpHeight;
warpSize->width = cvRound(warpWidth-1);
warpSize->height = cvRound(warpHeight-1);
/* !!! by Valery Mosyagin. this lines added just for test no warp */
warpSize->width = imageSize.width;
warpSize->height = imageSize.height;
return;
}
/*---------------------------------------------------------------------------------------*/
static void icvGetQuadsTransformNew( CvSize imageSize,
CvMatr32f camMatr1,
CvMatr32f camMatr2,
CvMatr32f rotMatr1,
CvVect32f transVect1,
CvSize* warpSize,
double quad1[4][2],
double quad2[4][2],
CvMatr32f fundMatr,
CvPoint3D32f* epipole1,
CvPoint3D32f* epipole2
)
{
/* Convert data */
/* Convert camera matrix */
double camMatr1_64d[9];
double camMatr2_64d[9];
double rotMatr1_64d[9];
double transVect1_64d[3];
double rotMatr2_64d[9];
double transVect2_64d[3];
double fundMatr_64d[9];
CvPoint3D64d epipole1_64d;
CvPoint3D64d epipole2_64d;
icvCvt_32f_64d(camMatr1,camMatr1_64d,9);
icvCvt_32f_64d(camMatr2,camMatr2_64d,9);
icvCvt_32f_64d(rotMatr1,rotMatr1_64d,9);
icvCvt_32f_64d(transVect1,transVect1_64d,3);
/* Create vector and matrix */
rotMatr2_64d[0] = 1;
rotMatr2_64d[1] = 0;
rotMatr2_64d[2] = 0;
rotMatr2_64d[3] = 0;
rotMatr2_64d[4] = 1;
rotMatr2_64d[5] = 0;
rotMatr2_64d[6] = 0;
rotMatr2_64d[7] = 0;
rotMatr2_64d[8] = 1;
transVect2_64d[0] = 0;
transVect2_64d[1] = 0;
transVect2_64d[2] = 0;
icvGetQuadsTransform( imageSize,
camMatr1_64d,
rotMatr1_64d,
transVect1_64d,
camMatr2_64d,
rotMatr2_64d,
transVect2_64d,
warpSize,
quad1,
quad2,
fundMatr_64d,
&epipole1_64d,
&epipole2_64d
);
/* Convert epipoles */
epipole1->x = (float)(epipole1_64d.x);
epipole1->y = (float)(epipole1_64d.y);
epipole1->z = (float)(epipole1_64d.z);
epipole2->x = (float)(epipole2_64d.x);
epipole2->y = (float)(epipole2_64d.y);
epipole2->z = (float)(epipole2_64d.z);
/* Convert fundamental matrix */
icvCvt_64d_32f(fundMatr_64d,fundMatr,9);
return;
}
/*---------------------------------------------------------------------------------------*/
void icvGetQuadsTransformStruct( CvStereoCamera* stereoCamera)
{
/* Wrapper for icvGetQuadsTransformNew */
double quad1[4][2];
double quad2[4][2];
icvGetQuadsTransformNew( cvSize(cvRound(stereoCamera->camera[0]->imgSize[0]),cvRound(stereoCamera->camera[0]->imgSize[1])),
stereoCamera->camera[0]->matrix,
stereoCamera->camera[1]->matrix,
stereoCamera->rotMatrix,
stereoCamera->transVector,
&(stereoCamera->warpSize),
quad1,
quad2,
stereoCamera->fundMatr,
&(stereoCamera->epipole[0]),
&(stereoCamera->epipole[1])
);
int i;
for( i = 0; i < 4; i++ )
{
stereoCamera->quad[0][i] = cvPoint2D32f(quad1[i][0],quad1[i][1]);
stereoCamera->quad[1][i] = cvPoint2D32f(quad2[i][0],quad2[i][1]);
}
return;
}
/*---------------------------------------------------------------------------------------*/
void icvComputeStereoParamsForCameras(CvStereoCamera* stereoCamera)
{
/* For given intrinsic and extrinsic parameters computes rest parameters
** such as fundamental matrix. warping coeffs, epipoles, ...
*/
/* compute rotate matrix and translate vector */
double rotMatr1[9];
double rotMatr2[9];
double transVect1[3];
double transVect2[3];
double convRotMatr[9];
double convTransVect[3];
/* fill matrices */
icvCvt_32f_64d(stereoCamera->camera[0]->rotMatr,rotMatr1,9);
icvCvt_32f_64d(stereoCamera->camera[1]->rotMatr,rotMatr2,9);
icvCvt_32f_64d(stereoCamera->camera[0]->transVect,transVect1,3);
icvCvt_32f_64d(stereoCamera->camera[1]->transVect,transVect2,3);
icvCreateConvertMatrVect( rotMatr1,
transVect1,
rotMatr2,
transVect2,
convRotMatr,
convTransVect);
/* copy to stereo camera params */
icvCvt_64d_32f(convRotMatr,stereoCamera->rotMatrix,9);
icvCvt_64d_32f(convTransVect,stereoCamera->transVector,3);
icvGetQuadsTransformStruct(stereoCamera);
icvComputeRestStereoParams(stereoCamera);
}
/*---------------------------------------------------------------------------------------*/
/* Get cut line for one image */
void icvGetCutPiece( CvVect64d areaLineCoef1,CvVect64d areaLineCoef2,
CvPoint2D64d epipole,
CvSize imageSize,
CvPoint2D64d* point11,CvPoint2D64d* point12,
CvPoint2D64d* point21,CvPoint2D64d* point22,
int* result)
{
/* Compute nearest cut line to epipole */
/* Get corners inside sector */
/* Collect all candidate point */
CvPoint2D64d candPoints[8];
CvPoint2D64d midPoint;
int numPoints = 0;
int res;
int i;
double cutLine1[3];
double cutLine2[3];
/* Find middle line of sector */
double midLine[3]={0,0,0};
/* Different way */
CvPoint2D64d pointOnLine1; pointOnLine1.x = pointOnLine1.y = 0;
CvPoint2D64d pointOnLine2; pointOnLine2.x = pointOnLine2.y = 0;
CvPoint2D64d start1,end1;
icvGetCrossRectDirect( imageSize,
areaLineCoef1[0],areaLineCoef1[1],areaLineCoef1[2],
&start1,&end1,&res);
if( res > 0 )
{
pointOnLine1 = start1;
}
icvGetCrossRectDirect( imageSize,
areaLineCoef2[0],areaLineCoef2[1],areaLineCoef2[2],
&start1,&end1,&res);
if( res > 0 )
{
pointOnLine2 = start1;
}
icvGetMiddleAnglePoint(epipole,pointOnLine1,pointOnLine2,&midPoint);
icvGetCoefForPiece(epipole,midPoint,&midLine[0],&midLine[1],&midLine[2],&res);
/* Test corner points */
CvPoint2D64d cornerPoint;
CvPoint2D64d tmpPoints[2];
cornerPoint.x = 0;
cornerPoint.y = 0;
icvTestPoint( cornerPoint, areaLineCoef1, areaLineCoef2, epipole, &res);
if( res == 1 )
{/* Add point */
candPoints[numPoints] = cornerPoint;
numPoints++;
}
cornerPoint.x = imageSize.width;
cornerPoint.y = 0;
icvTestPoint( cornerPoint, areaLineCoef1, areaLineCoef2, epipole, &res);
if( res == 1 )
{/* Add point */
candPoints[numPoints] = cornerPoint;
numPoints++;
}
cornerPoint.x = imageSize.width;
cornerPoint.y = imageSize.height;
icvTestPoint( cornerPoint, areaLineCoef1, areaLineCoef2, epipole, &res);
if( res == 1 )
{/* Add point */
candPoints[numPoints] = cornerPoint;
numPoints++;
}
cornerPoint.x = 0;
cornerPoint.y = imageSize.height;
icvTestPoint( cornerPoint, areaLineCoef1, areaLineCoef2, epipole, &res);
if( res == 1 )
{/* Add point */
candPoints[numPoints] = cornerPoint;
numPoints++;
}
/* Find cross line 1 with image border */
icvGetCrossRectDirect( imageSize,
areaLineCoef1[0],areaLineCoef1[1],areaLineCoef1[2],
&tmpPoints[0], &tmpPoints[1],
&res);
for( i = 0; i < res; i++ )
{
candPoints[numPoints++] = tmpPoints[i];
}
/* Find cross line 2 with image border */
icvGetCrossRectDirect( imageSize,
areaLineCoef2[0],areaLineCoef2[1],areaLineCoef2[2],
&tmpPoints[0], &tmpPoints[1],
&res);
for( i = 0; i < res; i++ )
{
candPoints[numPoints++] = tmpPoints[i];
}
if( numPoints < 2 )
{
*result = 0;
return;/* Error. Not enought points */
}
/* Project all points to middle line and get max and min */
CvPoint2D64d projPoint;
CvPoint2D64d minPoint; minPoint.x = minPoint.y = FLT_MAX;
CvPoint2D64d maxPoint; maxPoint.x = maxPoint.y = -FLT_MAX;
double dist;
double maxDist = 0;
double minDist = 10000000;
for( i = 0; i < numPoints; i++ )
{
icvProjectPointToDirect(candPoints[i], midLine, &projPoint);
icvGetPieceLength(epipole,projPoint,&dist);
if( dist < minDist)
{
minDist = dist;
minPoint = projPoint;
}
if( dist > maxDist)
{
maxDist = dist;
maxPoint = projPoint;
}
}
/* We know maximum and minimum points. Now we can compute cut lines */
icvGetNormalDirect(midLine,minPoint,cutLine1);
icvGetNormalDirect(midLine,maxPoint,cutLine2);
/* Test for begin of line. */
CvPoint2D64d tmpPoint2;
/* Get cross with */
icvGetCrossDirectDirect(areaLineCoef1,cutLine1,point11,&res);
icvGetCrossDirectDirect(areaLineCoef2,cutLine1,point12,&res);
icvGetCrossDirectDirect(areaLineCoef1,cutLine2,point21,&res);
icvGetCrossDirectDirect(areaLineCoef2,cutLine2,point22,&res);
if( epipole.x > imageSize.width * 0.5 )
{/* Need to change points */
tmpPoint2 = *point11;
*point11 = *point21;
*point21 = tmpPoint2;
tmpPoint2 = *point12;
*point12 = *point22;
*point22 = tmpPoint2;
}
return;
}
/*---------------------------------------------------------------------------------------*/
/* Get middle angle */
void icvGetMiddleAnglePoint( CvPoint2D64d basePoint,
CvPoint2D64d point1,CvPoint2D64d point2,
CvPoint2D64d* midPoint)
{/* !!! May be need to return error */
double dist1;
double dist2;
icvGetPieceLength(basePoint,point1,&dist1);
icvGetPieceLength(basePoint,point2,&dist2);
CvPoint2D64d pointNew1;
CvPoint2D64d pointNew2;
double alpha = dist2/dist1;
pointNew1.x = basePoint.x + (1.0/alpha) * ( point2.x - basePoint.x );
pointNew1.y = basePoint.y + (1.0/alpha) * ( point2.y - basePoint.y );
pointNew2.x = basePoint.x + alpha * ( point1.x - basePoint.x );
pointNew2.y = basePoint.y + alpha * ( point1.y - basePoint.y );
int res;
icvGetCrossPiecePiece(point1,point2,pointNew1,pointNew2,midPoint,&res);
return;
}
/*---------------------------------------------------------------------------------------*/
/* Get normal direct to direct in line */
void icvGetNormalDirect(CvVect64d direct,CvPoint2D64d point,CvVect64d normDirect)
{
normDirect[0] = direct[1];
normDirect[1] = - direct[0];
normDirect[2] = -(normDirect[0]*point.x + normDirect[1]*point.y);
return;
}
/*---------------------------------------------------------------------------------------*/
CV_IMPL double icvGetVect(CvPoint2D64d basePoint,CvPoint2D64d point1,CvPoint2D64d point2)
{
return (point1.x - basePoint.x)*(point2.y - basePoint.y) -
(point2.x - basePoint.x)*(point1.y - basePoint.y);
}
/*---------------------------------------------------------------------------------------*/
/* Test for point in sector */
/* Return 0 - point not inside sector */
/* Return 1 - point inside sector */
void icvTestPoint( CvPoint2D64d testPoint,
CvVect64d line1,CvVect64d line2,
CvPoint2D64d basePoint,
int* result)
{
CvPoint2D64d point1,point2;
icvProjectPointToDirect(testPoint,line1,&point1);
icvProjectPointToDirect(testPoint,line2,&point2);
double sign1 = icvGetVect(basePoint,point1,point2);
double sign2 = icvGetVect(basePoint,point1,testPoint);
if( sign1 * sign2 > 0 )
{/* Correct for first line */
sign1 = - sign1;
sign2 = icvGetVect(basePoint,point2,testPoint);
if( sign1 * sign2 > 0 )
{/* Correct for both lines */
*result = 1;
}
else
{
*result = 0;
}
}
else
{
*result = 0;
}
return;
}
/*---------------------------------------------------------------------------------------*/
/* Project point to line */
void icvProjectPointToDirect( CvPoint2D64d point,CvVect64d lineCoeff,
CvPoint2D64d* projectPoint)
{
double a = lineCoeff[0];
double b = lineCoeff[1];
double det = 1.0 / ( a*a + b*b );
double delta = a*point.y - b*point.x;
projectPoint->x = ( -a*lineCoeff[2] - b * delta ) * det;
projectPoint->y = ( -b*lineCoeff[2] + a * delta ) * det ;
return;
}
/*---------------------------------------------------------------------------------------*/
/* Get distance from point to direction */
void icvGetDistanceFromPointToDirect( CvPoint2D64d point,CvVect64d lineCoef,double*dist)
{
CvPoint2D64d tmpPoint;
icvProjectPointToDirect(point,lineCoef,&tmpPoint);
double dx = point.x - tmpPoint.x;
double dy = point.y - tmpPoint.y;
*dist = sqrt(dx*dx+dy*dy);
return;
}
/*---------------------------------------------------------------------------------------*/
CV_IMPL IplImage* icvCreateIsometricImage( IplImage* src, IplImage* dst,
int desired_depth, int desired_num_channels )
{
CvSize src_size ;
src_size.width = src->width;
src_size.height = src->height;
CvSize dst_size = src_size;
if( dst )
{
dst_size.width = dst->width;
dst_size.height = dst->height;
}
if( !dst || dst->depth != desired_depth ||
dst->nChannels != desired_num_channels ||
dst_size.width != src_size.width ||
dst_size.height != dst_size.height )
{
cvReleaseImage( &dst );
dst = cvCreateImage( src_size, desired_depth, desired_num_channels );
CvRect rect = cvRect(0,0,src_size.width,src_size.height);
cvSetImageROI( dst, rect );
}
return dst;
}
static int
icvCvt_32f_64d( float *src, double *dst, int size )
{
int t;
if( !src || !dst )
return CV_NULLPTR_ERR;
if( size <= 0 )
return CV_BADRANGE_ERR;
for( t = 0; t < size; t++ )
{
dst[t] = (double) (src[t]);
}
return CV_OK;
}
/*======================================================================================*/
/* Type conversion double -> float */
static int
icvCvt_64d_32f( double *src, float *dst, int size )
{
int t;
if( !src || !dst )
return CV_NULLPTR_ERR;
if( size <= 0 )
return CV_BADRANGE_ERR;
for( t = 0; t < size; t++ )
{
dst[t] = (float) (src[t]);
}
return CV_OK;
}
/*----------------------------------------------------------------------------------*/
#if 0
/* Find line which cross frame by line(a,b,c) */
static void FindLineForEpiline( CvSize imageSize,
float a,float b,float c,
CvPoint2D32f *start,CvPoint2D32f *end,
int*)
{
CvPoint2D32f frameBeg;
CvPoint2D32f frameEnd;
CvPoint2D32f cross[4];
int haveCross[4];
float dist;
haveCross[0] = 0;
haveCross[1] = 0;
haveCross[2] = 0;
haveCross[3] = 0;
frameBeg.x = 0;
frameBeg.y = 0;
frameEnd.x = (float)(imageSize.width);
frameEnd.y = 0;
haveCross[0] = icvGetCrossLineDirect(frameBeg,frameEnd,a,b,c,&cross[0]);
frameBeg.x = (float)(imageSize.width);
frameBeg.y = 0;
frameEnd.x = (float)(imageSize.width);
frameEnd.y = (float)(imageSize.height);
haveCross[1] = icvGetCrossLineDirect(frameBeg,frameEnd,a,b,c,&cross[1]);
frameBeg.x = (float)(imageSize.width);
frameBeg.y = (float)(imageSize.height);
frameEnd.x = 0;
frameEnd.y = (float)(imageSize.height);
haveCross[2] = icvGetCrossLineDirect(frameBeg,frameEnd,a,b,c,&cross[2]);
frameBeg.x = 0;
frameBeg.y = (float)(imageSize.height);
frameEnd.x = 0;
frameEnd.y = 0;
haveCross[3] = icvGetCrossLineDirect(frameBeg,frameEnd,a,b,c,&cross[3]);
int n;
float minDist = (float)(INT_MAX);
float maxDist = (float)(INT_MIN);
int maxN = -1;
int minN = -1;
double midPointX = imageSize.width / 2.0;
double midPointY = imageSize.height / 2.0;
for( n = 0; n < 4; n++ )
{
if( haveCross[n] > 0 )
{
dist = (float)((midPointX - cross[n].x)*(midPointX - cross[n].x) +
(midPointY - cross[n].y)*(midPointY - cross[n].y));
if( dist < minDist )
{
minDist = dist;
minN = n;
}
if( dist > maxDist )
{
maxDist = dist;
maxN = n;
}
}
}
if( minN >= 0 && maxN >= 0 && (minN != maxN) )
{
*start = cross[minN];
*end = cross[maxN];
}
else
{
start->x = 0;
start->y = 0;
end->x = 0;
end->y = 0;
}
return;
}
/*----------------------------------------------------------------------------------*/
static int GetAngleLinee( CvPoint2D32f epipole, CvSize imageSize,CvPoint2D32f point1,CvPoint2D32f point2)
{
float width = (float)(imageSize.width);
float height = (float)(imageSize.height);
/* Get crosslines with image corners */
/* Find four lines */
CvPoint2D32f pa,pb,pc,pd;
pa.x = 0;
pa.y = 0;
pb.x = width;
pb.y = 0;
pd.x = width;
pd.y = height;
pc.x = 0;
pc.y = height;
/* We can compute points for angle */
/* Test for place section */
float x,y;
x = epipole.x;
y = epipole.y;
if( x < 0 )
{/* 1,4,7 */
if( y < 0)
{/* 1 */
point1 = pb;
point2 = pc;
}
else if( y > height )
{/* 7 */
point1 = pa;
point2 = pd;
}
else
{/* 4 */
point1 = pa;
point2 = pc;
}
}
else if ( x > width )
{/* 3,6,9 */
if( y < 0 )
{/* 3 */
point1 = pa;
point2 = pd;
}
else if ( y > height )
{/* 9 */
point1 = pc;
point2 = pb;
}
else
{/* 6 */
point1 = pb;
point2 = pd;
}
}
else
{/* 2,5,8 */
if( y < 0 )
{/* 2 */
point1 = pa;
point2 = pb;
}
else if( y > height )
{/* 8 */
point1 = pc;
point2 = pd;
}
else
{/* 5 - point in the image */
return 2;
}
}
return 0;
}
/*--------------------------------------------------------------------------------------*/
static void icvComputePerspectiveCoeffs(const CvPoint2D32f srcQuad[4],const CvPoint2D32f dstQuad[4],double coeffs[3][3])
{/* Computes perspective coeffs for transformation from src to dst quad */
CV_FUNCNAME( "icvComputePerspectiveCoeffs" );
__BEGIN__;
double A[64];
double b[8];
double c[8];
CvPoint2D32f pt[4];
int i;
pt[0] = srcQuad[0];
pt[1] = srcQuad[1];
pt[2] = srcQuad[2];
pt[3] = srcQuad[3];
for( i = 0; i < 4; i++ )
{
#if 0
double x = dstQuad[i].x;
double y = dstQuad[i].y;
double X = pt[i].x;
double Y = pt[i].y;
#else
double x = pt[i].x;
double y = pt[i].y;
double X = dstQuad[i].x;
double Y = dstQuad[i].y;
#endif
double* a = A + i*16;
a[0] = x;
a[1] = y;
a[2] = 1;
a[3] = 0;
a[4] = 0;
a[5] = 0;
a[6] = -X*x;
a[7] = -X*y;
a += 8;
a[0] = 0;
a[1] = 0;
a[2] = 0;
a[3] = x;
a[4] = y;
a[5] = 1;
a[6] = -Y*x;
a[7] = -Y*y;
b[i*2] = X;
b[i*2 + 1] = Y;
}
{
double invA[64];
CvMat matA = cvMat( 8, 8, CV_64F, A );
CvMat matInvA = cvMat( 8, 8, CV_64F, invA );
CvMat matB = cvMat( 8, 1, CV_64F, b );
CvMat matX = cvMat( 8, 1, CV_64F, c );
CV_CALL( cvPseudoInverse( &matA, &matInvA ));
CV_CALL( cvMatMulAdd( &matInvA, &matB, 0, &matX ));
}
coeffs[0][0] = c[0];
coeffs[0][1] = c[1];
coeffs[0][2] = c[2];
coeffs[1][0] = c[3];
coeffs[1][1] = c[4];
coeffs[1][2] = c[5];
coeffs[2][0] = c[6];
coeffs[2][1] = c[7];
coeffs[2][2] = 1.0;
__END__;
return;
}
#endif
/*--------------------------------------------------------------------------------------*/
CV_IMPL void cvComputePerspectiveMap(const double c[3][3], CvArr* rectMapX, CvArr* rectMapY )
{
CV_FUNCNAME( "cvComputePerspectiveMap" );
__BEGIN__;
CvSize size;
CvMat stubx, *mapx = (CvMat*)rectMapX;
CvMat stuby, *mapy = (CvMat*)rectMapY;
int i, j;
CV_CALL( mapx = cvGetMat( mapx, &stubx ));
CV_CALL( mapy = cvGetMat( mapy, &stuby ));
if( CV_MAT_TYPE( mapx->type ) != CV_32FC1 || CV_MAT_TYPE( mapy->type ) != CV_32FC1 )
CV_ERROR( CV_StsUnsupportedFormat, "" );
size = cvGetMatSize(mapx);
assert( fabs(c[2][2] - 1.) < FLT_EPSILON );
for( i = 0; i < size.height; i++ )
{
float* mx = (float*)(mapx->data.ptr + mapx->step*i);
float* my = (float*)(mapy->data.ptr + mapy->step*i);
for( j = 0; j < size.width; j++ )
{
double w = 1./(c[2][0]*j + c[2][1]*i + 1.);
double x = (c[0][0]*j + c[0][1]*i + c[0][2])*w;
double y = (c[1][0]*j + c[1][1]*i + c[1][2])*w;
mx[j] = (float)x;
my[j] = (float)y;
}
}
__END__;
}
/*--------------------------------------------------------------------------------------*/
CV_IMPL void cvInitPerspectiveTransform( CvSize size, const CvPoint2D32f quad[4], double matrix[3][3],
CvArr* rectMap )
{
/* Computes Perspective Transform coeffs and map if need
for given image size and given result quad */
CV_FUNCNAME( "cvInitPerspectiveTransform" );
__BEGIN__;
double A[64];
double b[8];
double c[8];
CvPoint2D32f pt[4];
CvMat mapstub, *map = (CvMat*)rectMap;
int i, j;
if( map )
{
CV_CALL( map = cvGetMat( map, &mapstub ));
if( CV_MAT_TYPE( map->type ) != CV_32FC2 )
CV_ERROR( CV_StsUnsupportedFormat, "" );
if( map->width != size.width || map->height != size.height )
CV_ERROR( CV_StsUnmatchedSizes, "" );
}
pt[0] = cvPoint2D32f( 0, 0 );
pt[1] = cvPoint2D32f( size.width, 0 );
pt[2] = cvPoint2D32f( size.width, size.height );
pt[3] = cvPoint2D32f( 0, size.height );
for( i = 0; i < 4; i++ )
{
#if 0
double x = quad[i].x;
double y = quad[i].y;
double X = pt[i].x;
double Y = pt[i].y;
#else
double x = pt[i].x;
double y = pt[i].y;
double X = quad[i].x;
double Y = quad[i].y;
#endif
double* a = A + i*16;
a[0] = x;
a[1] = y;
a[2] = 1;
a[3] = 0;
a[4] = 0;
a[5] = 0;
a[6] = -X*x;
a[7] = -X*y;
a += 8;
a[0] = 0;
a[1] = 0;
a[2] = 0;
a[3] = x;
a[4] = y;
a[5] = 1;
a[6] = -Y*x;
a[7] = -Y*y;
b[i*2] = X;
b[i*2 + 1] = Y;
}
{
double invA[64];
CvMat matA = cvMat( 8, 8, CV_64F, A );
CvMat matInvA = cvMat( 8, 8, CV_64F, invA );
CvMat matB = cvMat( 8, 1, CV_64F, b );
CvMat matX = cvMat( 8, 1, CV_64F, c );
CV_CALL( cvPseudoInverse( &matA, &matInvA ));
CV_CALL( cvMatMulAdd( &matInvA, &matB, 0, &matX ));
}
matrix[0][0] = c[0];
matrix[0][1] = c[1];
matrix[0][2] = c[2];
matrix[1][0] = c[3];
matrix[1][1] = c[4];
matrix[1][2] = c[5];
matrix[2][0] = c[6];
matrix[2][1] = c[7];
matrix[2][2] = 1.0;
if( map )
{
for( i = 0; i < size.height; i++ )
{
CvPoint2D32f* maprow = (CvPoint2D32f*)(map->data.ptr + map->step*i);
for( j = 0; j < size.width; j++ )
{
double w = 1./(c[6]*j + c[7]*i + 1.);
double x = (c[0]*j + c[1]*i + c[2])*w;
double y = (c[3]*j + c[4]*i + c[5])*w;
maprow[j].x = (float)x;
maprow[j].y = (float)y;
}
}
}
__END__;
return;
}
/*-----------------------------------------------------------------------*/
/* Compute projected infinite point for second image if first image point is known */
void icvComputeeInfiniteProject1( CvMatr64d rotMatr,
CvMatr64d camMatr1,
CvMatr64d camMatr2,
CvPoint2D32f point1,
CvPoint2D32f* point2)
{
double invMatr1[9];
icvInvertMatrix_64d(camMatr1,3,invMatr1);
double P1[3];
double p1[3];
p1[0] = (double)(point1.x);
p1[1] = (double)(point1.y);
p1[2] = 1;
icvMulMatrix_64d( invMatr1,
3,3,
p1,
1,3,
P1);
double invR[9];
icvTransposeMatrix_64d( rotMatr, 3, 3, invR );
/* Change system 1 to system 2 */
double P2[3];
icvMulMatrix_64d( invR,
3,3,
P1,
1,3,
P2);
/* Now we can project this point to image 2 */
double projP[3];
icvMulMatrix_64d( camMatr2,
3,3,
P2,
1,3,
projP);
point2->x = (float)(projP[0] / projP[2]);
point2->y = (float)(projP[1] / projP[2]);
return;
}
/*-----------------------------------------------------------------------*/
/* Compute projected infinite point for second image if first image point is known */
void icvComputeeInfiniteProject2( CvMatr64d rotMatr,
CvMatr64d camMatr1,
CvMatr64d camMatr2,
CvPoint2D32f* point1,
CvPoint2D32f point2)
{
double invMatr2[9];
icvInvertMatrix_64d(camMatr2,3,invMatr2);
double P2[3];
double p2[3];
p2[0] = (double)(point2.x);
p2[1] = (double)(point2.y);
p2[2] = 1;
icvMulMatrix_64d( invMatr2,
3,3,
p2,
1,3,
P2);
/* Change system 1 to system 2 */
double P1[3];
icvMulMatrix_64d( rotMatr,
3,3,
P2,
1,3,
P1);
/* Now we can project this point to image 2 */
double projP[3];
icvMulMatrix_64d( camMatr1,
3,3,
P1,
1,3,
projP);
point1->x = (float)(projP[0] / projP[2]);
point1->y = (float)(projP[1] / projP[2]);
return;
}
/* Select best R and t for given cameras, points, ... */
/* For both cameras */
static int icvSelectBestRt( int numImages,
int* numPoints,
CvPoint2D32f* imagePoints1,
CvPoint2D32f* imagePoints2,
CvPoint3D32f* objectPoints,
CvMatr32f cameraMatrix1,
CvVect32f distortion1,
CvMatr32f rotMatrs1,
CvVect32f transVects1,
CvMatr32f cameraMatrix2,
CvVect32f distortion2,
CvMatr32f rotMatrs2,
CvVect32f transVects2,
CvMatr32f bestRotMatr,
CvVect32f bestTransVect
)
{
/* Need to convert input data 32 -> 64 */
CvPoint3D64d* objectPoints_64d;
double* rotMatrs1_64d;
double* rotMatrs2_64d;
double* transVects1_64d;
double* transVects2_64d;
double cameraMatrix1_64d[9];
double cameraMatrix2_64d[9];
double distortion1_64d[4];
double distortion2_64d[4];
/* allocate memory for 64d data */
int totalNum = 0;
for(int i = 0; i < numImages; i++ )
{
totalNum += numPoints[i];
}
objectPoints_64d = (CvPoint3D64d*)calloc(totalNum,sizeof(CvPoint3D64d));
rotMatrs1_64d = (double*)calloc(numImages,sizeof(double)*9);
rotMatrs2_64d = (double*)calloc(numImages,sizeof(double)*9);
transVects1_64d = (double*)calloc(numImages,sizeof(double)*3);
transVects2_64d = (double*)calloc(numImages,sizeof(double)*3);
/* Convert input data to 64d */
icvCvt_32f_64d((float*)objectPoints, (double*)objectPoints_64d, totalNum*3);
icvCvt_32f_64d(rotMatrs1, rotMatrs1_64d, numImages*9);
icvCvt_32f_64d(rotMatrs2, rotMatrs2_64d, numImages*9);
icvCvt_32f_64d(transVects1, transVects1_64d, numImages*3);
icvCvt_32f_64d(transVects2, transVects2_64d, numImages*3);
/* Convert to arrays */
icvCvt_32f_64d(cameraMatrix1, cameraMatrix1_64d, 9);
icvCvt_32f_64d(cameraMatrix2, cameraMatrix2_64d, 9);
icvCvt_32f_64d(distortion1, distortion1_64d, 4);
icvCvt_32f_64d(distortion2, distortion2_64d, 4);
/* for each R and t compute error for image pair */
float* errors;
errors = (float*)calloc(numImages*numImages,sizeof(float));
if( errors == 0 )
{
return CV_OUTOFMEM_ERR;
}
int currImagePair;
int currRt;
for( currRt = 0; currRt < numImages; currRt++ )
{
int begPoint = 0;
for(currImagePair = 0; currImagePair < numImages; currImagePair++ )
{
/* For current R,t R,t compute relative position of cameras */
double convRotMatr[9];
double convTransVect[3];
icvCreateConvertMatrVect( rotMatrs1_64d + currRt*9,
transVects1_64d + currRt*3,
rotMatrs2_64d + currRt*9,
transVects2_64d + currRt*3,
convRotMatr,
convTransVect);
/* Project points using relative position of cameras */
double convRotMatr2[9];
double convTransVect2[3];
convRotMatr2[0] = 1;
convRotMatr2[1] = 0;
convRotMatr2[2] = 0;
convRotMatr2[3] = 0;
convRotMatr2[4] = 1;
convRotMatr2[5] = 0;
convRotMatr2[6] = 0;
convRotMatr2[7] = 0;
convRotMatr2[8] = 1;
convTransVect2[0] = 0;
convTransVect2[1] = 0;
convTransVect2[2] = 0;
/* Compute error for given pair and Rt */
/* We must project points to image and compute error */
CvPoint2D64d* projImagePoints1;
CvPoint2D64d* projImagePoints2;
CvPoint3D64d* points1;
CvPoint3D64d* points2;
int numberPnt;
numberPnt = numPoints[currImagePair];
projImagePoints1 = (CvPoint2D64d*)calloc(numberPnt,sizeof(CvPoint2D64d));
projImagePoints2 = (CvPoint2D64d*)calloc(numberPnt,sizeof(CvPoint2D64d));
points1 = (CvPoint3D64d*)calloc(numberPnt,sizeof(CvPoint3D64d));
points2 = (CvPoint3D64d*)calloc(numberPnt,sizeof(CvPoint3D64d));
/* Transform object points to first camera position */
for(int i = 0; i < numberPnt; i++ )
{
/* Create second camera point */
CvPoint3D64d tmpPoint;
tmpPoint.x = (double)(objectPoints[i].x);
tmpPoint.y = (double)(objectPoints[i].y);
tmpPoint.z = (double)(objectPoints[i].z);
icvConvertPointSystem( tmpPoint,
points2+i,
rotMatrs2_64d + currImagePair*9,
transVects2_64d + currImagePair*3);
/* Create first camera point using R, t */
icvConvertPointSystem( points2[i],
points1+i,
convRotMatr,
convTransVect);
CvPoint3D64d tmpPoint2 = { 0, 0, 0 };
icvConvertPointSystem( tmpPoint,
&tmpPoint2,
rotMatrs1_64d + currImagePair*9,
transVects1_64d + currImagePair*3);
/*double err;
double dx,dy,dz;
dx = tmpPoint2.x - points1[i].x;
dy = tmpPoint2.y - points1[i].y;
dz = tmpPoint2.z - points1[i].z;
err = sqrt(dx*dx + dy*dy + dz*dz);*/
}
#if 0
cvProjectPointsSimple( numPoints[currImagePair],
objectPoints_64d + begPoint,
rotMatrs1_64d + currRt*9,
transVects1_64d + currRt*3,
cameraMatrix1_64d,
distortion1_64d,
projImagePoints1);
cvProjectPointsSimple( numPoints[currImagePair],
objectPoints_64d + begPoint,
rotMatrs2_64d + currRt*9,
transVects2_64d + currRt*3,
cameraMatrix2_64d,
distortion2_64d,
projImagePoints2);
#endif
/* Project with no translate and no rotation */
#if 0
{
double nodist[4] = {0,0,0,0};
cvProjectPointsSimple( numPoints[currImagePair],
points1,
convRotMatr2,
convTransVect2,
cameraMatrix1_64d,
nodist,
projImagePoints1);
cvProjectPointsSimple( numPoints[currImagePair],
points2,
convRotMatr2,
convTransVect2,
cameraMatrix2_64d,
nodist,
projImagePoints2);
}
#endif
cvProjectPointsSimple( numPoints[currImagePair],
points1,
convRotMatr2,
convTransVect2,
cameraMatrix1_64d,
distortion1_64d,
projImagePoints1);
cvProjectPointsSimple( numPoints[currImagePair],
points2,
convRotMatr2,
convTransVect2,
cameraMatrix2_64d,
distortion2_64d,
projImagePoints2);
/* points are projected. Compute error */
int currPoint;
double err1 = 0;
double err2 = 0;
double err;
for( currPoint = 0; currPoint < numberPnt; currPoint++ )
{
double len1,len2;
double dx1,dy1;
dx1 = imagePoints1[begPoint+currPoint].x - projImagePoints1[currPoint].x;
dy1 = imagePoints1[begPoint+currPoint].y - projImagePoints1[currPoint].y;
len1 = sqrt(dx1*dx1 + dy1*dy1);
err1 += len1;
double dx2,dy2;
dx2 = imagePoints2[begPoint+currPoint].x - projImagePoints2[currPoint].x;
dy2 = imagePoints2[begPoint+currPoint].y - projImagePoints2[currPoint].y;
len2 = sqrt(dx2*dx2 + dy2*dy2);
err2 += len2;
}
err1 /= (float)(numberPnt);
err2 /= (float)(numberPnt);
err = (err1+err2) * 0.5;
begPoint += numberPnt;
/* Set this error to */
errors[numImages*currImagePair+currRt] = (float)err;
free(points1);
free(points2);
free(projImagePoints1);
free(projImagePoints2);
}
}
/* Just select R and t with minimal average error */
int bestnumRt = 0;
float minError = 0;/* Just for no warnings. Uses 'first' flag. */
int first = 1;
for( currRt = 0; currRt < numImages; currRt++ )
{
float avErr = 0;
for(currImagePair = 0; currImagePair < numImages; currImagePair++ )
{
avErr += errors[numImages*currImagePair+currRt];
}
avErr /= (float)(numImages);
if( first )
{
bestnumRt = 0;
minError = avErr;
first = 0;
}
else
{
if( avErr < minError )
{
bestnumRt = currRt;
minError = avErr;
}
}
}
double bestRotMatr_64d[9];
double bestTransVect_64d[3];
icvCreateConvertMatrVect( rotMatrs1_64d + bestnumRt * 9,
transVects1_64d + bestnumRt * 3,
rotMatrs2_64d + bestnumRt * 9,
transVects2_64d + bestnumRt * 3,
bestRotMatr_64d,
bestTransVect_64d);
icvCvt_64d_32f(bestRotMatr_64d,bestRotMatr,9);
icvCvt_64d_32f(bestTransVect_64d,bestTransVect,3);
free(errors);
return CV_OK;
}
/* ----------------- Stereo calibration functions --------------------- */
float icvDefinePointPosition(CvPoint2D32f point1,CvPoint2D32f point2,CvPoint2D32f point)
{
float ax = point2.x - point1.x;
float ay = point2.y - point1.y;
float bx = point.x - point1.x;
float by = point.y - point1.y;
return (ax*by - ay*bx);
}
/* Convert function for stereo warping */
int icvConvertWarpCoordinates(double coeffs[3][3],
CvPoint2D32f* cameraPoint,
CvPoint2D32f* warpPoint,
int direction)
{
double x,y;
double det;
if( direction == CV_WARP_TO_CAMERA )
{/* convert from camera image to warped image coordinates */
x = warpPoint->x;
y = warpPoint->y;
det = (coeffs[2][0] * x + coeffs[2][1] * y + coeffs[2][2]);
if( fabs(det) > 1e-8 )
{
cameraPoint->x = (float)((coeffs[0][0] * x + coeffs[0][1] * y + coeffs[0][2]) / det);
cameraPoint->y = (float)((coeffs[1][0] * x + coeffs[1][1] * y + coeffs[1][2]) / det);
return CV_OK;
}
}
else if( direction == CV_CAMERA_TO_WARP )
{/* convert from warped image to camera image coordinates */
x = cameraPoint->x;
y = cameraPoint->y;
det = (coeffs[2][0]*x-coeffs[0][0])*(coeffs[2][1]*y-coeffs[1][1])-(coeffs[2][1]*x-coeffs[0][1])*(coeffs[2][0]*y-coeffs[1][0]);
if( fabs(det) > 1e-8 )
{
warpPoint->x = (float)(((coeffs[0][2]-coeffs[2][2]*x)*(coeffs[2][1]*y-coeffs[1][1])-(coeffs[2][1]*x-coeffs[0][1])*(coeffs[1][2]-coeffs[2][2]*y))/det);
warpPoint->y = (float)(((coeffs[2][0]*x-coeffs[0][0])*(coeffs[1][2]-coeffs[2][2]*y)-(coeffs[0][2]-coeffs[2][2]*x)*(coeffs[2][0]*y-coeffs[1][0]))/det);
return CV_OK;
}
}
return CV_BADFACTOR_ERR;
}
/* Compute stereo params using some camera params */
/* by Valery Mosyagin. int ComputeRestStereoParams(StereoParams *stereoparams) */
int icvComputeRestStereoParams(CvStereoCamera *stereoparams)
{
icvGetQuadsTransformStruct(stereoparams);
cvInitPerspectiveTransform( stereoparams->warpSize,
stereoparams->quad[0],
stereoparams->coeffs[0],
0);
cvInitPerspectiveTransform( stereoparams->warpSize,
stereoparams->quad[1],
stereoparams->coeffs[1],
0);
/* Create border for warped images */
CvPoint2D32f corns[4];
corns[0].x = 0;
corns[0].y = 0;
corns[1].x = (float)(stereoparams->camera[0]->imgSize[0]-1);
corns[1].y = 0;
corns[2].x = (float)(stereoparams->camera[0]->imgSize[0]-1);
corns[2].y = (float)(stereoparams->camera[0]->imgSize[1]-1);
corns[3].x = 0;
corns[3].y = (float)(stereoparams->camera[0]->imgSize[1]-1);
for(int i = 0; i < 4; i++ )
{
/* For first camera */
icvConvertWarpCoordinates( stereoparams->coeffs[0],
corns+i,
stereoparams->border[0]+i,
CV_CAMERA_TO_WARP);
/* For second camera */
icvConvertWarpCoordinates( stereoparams->coeffs[1],
corns+i,
stereoparams->border[1]+i,
CV_CAMERA_TO_WARP);
}
/* Test compute */
{
CvPoint2D32f warpPoints[4];
warpPoints[0] = cvPoint2D32f(0,0);
warpPoints[1] = cvPoint2D32f(stereoparams->warpSize.width-1,0);
warpPoints[2] = cvPoint2D32f(stereoparams->warpSize.width-1,stereoparams->warpSize.height-1);
warpPoints[3] = cvPoint2D32f(0,stereoparams->warpSize.height-1);
CvPoint2D32f camPoints1[4];
CvPoint2D32f camPoints2[4];
for( int i = 0; i < 4; i++ )
{
icvConvertWarpCoordinates(stereoparams->coeffs[0],
camPoints1+i,
warpPoints+i,
CV_WARP_TO_CAMERA);
icvConvertWarpCoordinates(stereoparams->coeffs[1],
camPoints2+i,
warpPoints+i,
CV_WARP_TO_CAMERA);
}
}
/* Allocate memory for scanlines coeffs */
stereoparams->lineCoeffs = (CvStereoLineCoeff*)calloc(stereoparams->warpSize.height,sizeof(CvStereoLineCoeff));
/* Compute coeffs for epilines */
icvComputeCoeffForStereo( stereoparams);
/* all coeffs are known */
return CV_OK;
}
/*-------------------------------------------------------------------------------------------*/
int icvStereoCalibration( int numImages,
int* nums,
CvSize imageSize,
CvPoint2D32f* imagePoints1,
CvPoint2D32f* imagePoints2,
CvPoint3D32f* objectPoints,
CvStereoCamera* stereoparams
)
{
/* Firstly we must calibrate both cameras */
/* Alocate memory for data */
/* Allocate for translate vectors */
float* transVects1;
float* transVects2;
float* rotMatrs1;
float* rotMatrs2;
transVects1 = (float*)calloc(numImages,sizeof(float)*3);
transVects2 = (float*)calloc(numImages,sizeof(float)*3);
rotMatrs1 = (float*)calloc(numImages,sizeof(float)*9);
rotMatrs2 = (float*)calloc(numImages,sizeof(float)*9);
/* Calibrate first camera */
cvCalibrateCamera( numImages,
nums,
imageSize,
imagePoints1,
objectPoints,
stereoparams->camera[0]->distortion,
stereoparams->camera[0]->matrix,
transVects1,
rotMatrs1,
1);
/* Calibrate second camera */
cvCalibrateCamera( numImages,
nums,
imageSize,
imagePoints2,
objectPoints,
stereoparams->camera[1]->distortion,
stereoparams->camera[1]->matrix,
transVects2,
rotMatrs2,
1);
/* Cameras are calibrated */
stereoparams->camera[0]->imgSize[0] = (float)imageSize.width;
stereoparams->camera[0]->imgSize[1] = (float)imageSize.height;
stereoparams->camera[1]->imgSize[0] = (float)imageSize.width;
stereoparams->camera[1]->imgSize[1] = (float)imageSize.height;
icvSelectBestRt( numImages,
nums,
imagePoints1,
imagePoints2,
objectPoints,
stereoparams->camera[0]->matrix,
stereoparams->camera[0]->distortion,
rotMatrs1,
transVects1,
stereoparams->camera[1]->matrix,
stereoparams->camera[1]->distortion,
rotMatrs2,
transVects2,
stereoparams->rotMatrix,
stereoparams->transVector
);
/* Free memory */
free(transVects1);
free(transVects2);
free(rotMatrs1);
free(rotMatrs2);
icvComputeRestStereoParams(stereoparams);
return CV_NO_ERR;
}
#if 0
/* Find line from epipole */
static void FindLine(CvPoint2D32f epipole,CvSize imageSize,CvPoint2D32f point,CvPoint2D32f *start,CvPoint2D32f *end)
{
CvPoint2D32f frameBeg;
CvPoint2D32f frameEnd;
CvPoint2D32f cross[4];
int haveCross[4];
float dist;
haveCross[0] = 0;
haveCross[1] = 0;
haveCross[2] = 0;
haveCross[3] = 0;
frameBeg.x = 0;
frameBeg.y = 0;
frameEnd.x = (float)(imageSize.width);
frameEnd.y = 0;
haveCross[0] = icvGetCrossPieceVector(frameBeg,frameEnd,epipole,point,&cross[0]);
frameBeg.x = (float)(imageSize.width);
frameBeg.y = 0;
frameEnd.x = (float)(imageSize.width);
frameEnd.y = (float)(imageSize.height);
haveCross[1] = icvGetCrossPieceVector(frameBeg,frameEnd,epipole,point,&cross[1]);
frameBeg.x = (float)(imageSize.width);
frameBeg.y = (float)(imageSize.height);
frameEnd.x = 0;
frameEnd.y = (float)(imageSize.height);
haveCross[2] = icvGetCrossPieceVector(frameBeg,frameEnd,epipole,point,&cross[2]);
frameBeg.x = 0;
frameBeg.y = (float)(imageSize.height);
frameEnd.x = 0;
frameEnd.y = 0;
haveCross[3] = icvGetCrossPieceVector(frameBeg,frameEnd,epipole,point,&cross[3]);
int n;
float minDist = (float)(INT_MAX);
float maxDist = (float)(INT_MIN);
int maxN = -1;
int minN = -1;
for( n = 0; n < 4; n++ )
{
if( haveCross[n] > 0 )
{
dist = (epipole.x - cross[n].x)*(epipole.x - cross[n].x) +
(epipole.y - cross[n].y)*(epipole.y - cross[n].y);
if( dist < minDist )
{
minDist = dist;
minN = n;
}
if( dist > maxDist )
{
maxDist = dist;
maxN = n;
}
}
}
if( minN >= 0 && maxN >= 0 && (minN != maxN) )
{
*start = cross[minN];
*end = cross[maxN];
}
else
{
start->x = 0;
start->y = 0;
end->x = 0;
end->y = 0;
}
return;
}
/* Find line which cross frame by line(a,b,c) */
static void FindLineForEpiline(CvSize imageSize,float a,float b,float c,CvPoint2D32f *start,CvPoint2D32f *end)
{
CvPoint2D32f frameBeg;
CvPoint2D32f frameEnd;
CvPoint2D32f cross[4];
int haveCross[4];
float dist;
haveCross[0] = 0;
haveCross[1] = 0;
haveCross[2] = 0;
haveCross[3] = 0;
frameBeg.x = 0;
frameBeg.y = 0;
frameEnd.x = (float)(imageSize.width);
frameEnd.y = 0;
haveCross[0] = icvGetCrossLineDirect(frameBeg,frameEnd,a,b,c,&cross[0]);
frameBeg.x = (float)(imageSize.width);
frameBeg.y = 0;
frameEnd.x = (float)(imageSize.width);
frameEnd.y = (float)(imageSize.height);
haveCross[1] = icvGetCrossLineDirect(frameBeg,frameEnd,a,b,c,&cross[1]);
frameBeg.x = (float)(imageSize.width);
frameBeg.y = (float)(imageSize.height);
frameEnd.x = 0;
frameEnd.y = (float)(imageSize.height);
haveCross[2] = icvGetCrossLineDirect(frameBeg,frameEnd,a,b,c,&cross[2]);
frameBeg.x = 0;
frameBeg.y = (float)(imageSize.height);
frameEnd.x = 0;
frameEnd.y = 0;
haveCross[3] = icvGetCrossLineDirect(frameBeg,frameEnd,a,b,c,&cross[3]);
int n;
float minDist = (float)(INT_MAX);
float maxDist = (float)(INT_MIN);
int maxN = -1;
int minN = -1;
double midPointX = imageSize.width / 2.0;
double midPointY = imageSize.height / 2.0;
for( n = 0; n < 4; n++ )
{
if( haveCross[n] > 0 )
{
dist = (float)((midPointX - cross[n].x)*(midPointX - cross[n].x) +
(midPointY - cross[n].y)*(midPointY - cross[n].y));
if( dist < minDist )
{
minDist = dist;
minN = n;
}
if( dist > maxDist )
{
maxDist = dist;
maxN = n;
}
}
}
if( minN >= 0 && maxN >= 0 && (minN != maxN) )
{
*start = cross[minN];
*end = cross[maxN];
}
else
{
start->x = 0;
start->y = 0;
end->x = 0;
end->y = 0;
}
return;
}
/* Cross lines */
static int GetCrossLines(CvPoint2D32f p1_start,CvPoint2D32f p1_end,CvPoint2D32f p2_start,CvPoint2D32f p2_end,CvPoint2D32f *cross)
{
double ex1,ey1,ex2,ey2;
double px1,py1,px2,py2;
double del;
double delA,delB,delX,delY;
double alpha,betta;
ex1 = p1_start.x;
ey1 = p1_start.y;
ex2 = p1_end.x;
ey2 = p1_end.y;
px1 = p2_start.x;
py1 = p2_start.y;
px2 = p2_end.x;
py2 = p2_end.y;
del = (ex1-ex2)*(py2-py1)+(ey2-ey1)*(px2-px1);
if( del == 0)
{
return -1;
}
delA = (px1-ex1)*(py1-py2) + (ey1-py1)*(px1-px2);
delB = (ex1-px1)*(ey1-ey2) + (py1-ey1)*(ex1-ex2);
alpha = delA / del;
betta = -delB / del;
if( alpha < 0 || alpha > 1.0 || betta < 0 || betta > 1.0)
{
return -1;
}
delX = (ex1-ex2)*(py1*(px1-px2)-px1*(py1-py2))+
(px1-px2)*(ex1*(ey1-ey2)-ey1*(ex1-ex2));
delY = (ey1-ey2)*(px1*(py1-py2)-py1*(px1-px2))+
(py1-py2)*(ey1*(ex1-ex2)-ex1*(ey1-ey2));
cross->x = (float)( delX / del);
cross->y = (float)(-delY / del);
return 1;
}
#endif
int icvGetCrossPieceVector(CvPoint2D32f p1_start,CvPoint2D32f p1_end,CvPoint2D32f v2_start,CvPoint2D32f v2_end,CvPoint2D32f *cross)
{
double ex1 = p1_start.x;
double ey1 = p1_start.y;
double ex2 = p1_end.x;
double ey2 = p1_end.y;
double px1 = v2_start.x;
double py1 = v2_start.y;
double px2 = v2_end.x;
double py2 = v2_end.y;
double del = (ex1-ex2)*(py2-py1)+(ey2-ey1)*(px2-px1);
if( del == 0)
{
return -1;
}
double delA = (px1-ex1)*(py1-py2) + (ey1-py1)*(px1-px2);
//double delB = (ex1-px1)*(ey1-ey2) + (py1-ey1)*(ex1-ex2);
double alpha = delA / del;
//double betta = -delB / del;
if( alpha < 0 || alpha > 1.0 )
{
return -1;
}
double delX = (ex1-ex2)*(py1*(px1-px2)-px1*(py1-py2))+
(px1-px2)*(ex1*(ey1-ey2)-ey1*(ex1-ex2));
double delY = (ey1-ey2)*(px1*(py1-py2)-py1*(px1-px2))+
(py1-py2)*(ey1*(ex1-ex2)-ex1*(ey1-ey2));
cross->x = (float)( delX / del);
cross->y = (float)(-delY / del);
return 1;
}
int icvGetCrossLineDirect(CvPoint2D32f p1,CvPoint2D32f p2,float a,float b,float c,CvPoint2D32f* cross)
{
double del;
double delX,delY,delA;
double px1,px2,py1,py2;
double X,Y,alpha;
px1 = p1.x;
py1 = p1.y;
px2 = p2.x;
py2 = p2.y;
del = a * (px2 - px1) + b * (py2-py1);
if( del == 0 )
{
return -1;
}
delA = - c - a*px1 - b*py1;
alpha = delA / del;
if( alpha < 0 || alpha > 1.0 )
{
return -1;/* no cross */
}
delX = b * (py1*(px1-px2) - px1*(py1-py2)) + c * (px1-px2);
delY = a * (px1*(py1-py2) - py1*(px1-px2)) + c * (py1-py2);
X = delX / del;
Y = delY / del;
cross->x = (float)X;
cross->y = (float)Y;
return 1;
}
#if 0
static int cvComputeEpipoles( CvMatr32f camMatr1, CvMatr32f camMatr2,
CvMatr32f rotMatr1, CvMatr32f rotMatr2,
CvVect32f transVect1,CvVect32f transVect2,
CvVect32f epipole1,
CvVect32f epipole2)
{
/* Copy matrix */
CvMat ccamMatr1 = cvMat(3,3,CV_MAT32F,camMatr1);
CvMat ccamMatr2 = cvMat(3,3,CV_MAT32F,camMatr2);
CvMat crotMatr1 = cvMat(3,3,CV_MAT32F,rotMatr1);
CvMat crotMatr2 = cvMat(3,3,CV_MAT32F,rotMatr2);
CvMat ctransVect1 = cvMat(3,1,CV_MAT32F,transVect1);
CvMat ctransVect2 = cvMat(3,1,CV_MAT32F,transVect2);
CvMat cepipole1 = cvMat(3,1,CV_MAT32F,epipole1);
CvMat cepipole2 = cvMat(3,1,CV_MAT32F,epipole2);
CvMat cmatrP1 = cvMat(3,3,CV_MAT32F,0); cvmAlloc(&cmatrP1);
CvMat cmatrP2 = cvMat(3,3,CV_MAT32F,0); cvmAlloc(&cmatrP2);
CvMat cvectp1 = cvMat(3,1,CV_MAT32F,0); cvmAlloc(&cvectp1);
CvMat cvectp2 = cvMat(3,1,CV_MAT32F,0); cvmAlloc(&cvectp2);
CvMat ctmpF1 = cvMat(3,1,CV_MAT32F,0); cvmAlloc(&ctmpF1);
CvMat ctmpM1 = cvMat(3,3,CV_MAT32F,0); cvmAlloc(&ctmpM1);
CvMat ctmpM2 = cvMat(3,3,CV_MAT32F,0); cvmAlloc(&ctmpM2);
CvMat cinvP1 = cvMat(3,3,CV_MAT32F,0); cvmAlloc(&cinvP1);
CvMat cinvP2 = cvMat(3,3,CV_MAT32F,0); cvmAlloc(&cinvP2);
CvMat ctmpMatr = cvMat(3,3,CV_MAT32F,0); cvmAlloc(&ctmpMatr);
CvMat ctmpVect1 = cvMat(3,1,CV_MAT32F,0); cvmAlloc(&ctmpVect1);
CvMat ctmpVect2 = cvMat(3,1,CV_MAT32F,0); cvmAlloc(&ctmpVect2);
CvMat cmatrF1 = cvMat(3,3,CV_MAT32F,0); cvmAlloc(&cmatrF1);
CvMat ctmpF = cvMat(3,3,CV_MAT32F,0); cvmAlloc(&ctmpF);
CvMat ctmpE1 = cvMat(3,1,CV_MAT32F,0); cvmAlloc(&ctmpE1);
CvMat ctmpE2 = cvMat(3,1,CV_MAT32F,0); cvmAlloc(&ctmpE2);
/* Compute first */
cvmMul( &ccamMatr1, &crotMatr1, &cmatrP1);
cvmInvert( &cmatrP1,&cinvP1 );
cvmMul( &ccamMatr1, &ctransVect1, &cvectp1 );
/* Compute second */
cvmMul( &ccamMatr2, &crotMatr2, &cmatrP2 );
cvmInvert( &cmatrP2,&cinvP2 );
cvmMul( &ccamMatr2, &ctransVect2, &cvectp2 );
cvmMul( &cmatrP1, &cinvP2, &ctmpM1);
cvmMul( &ctmpM1, &cvectp2, &ctmpVect1);
cvmSub( &cvectp1,&ctmpVect1,&ctmpE1);
cvmMul( &cmatrP2, &cinvP1, &ctmpM2);
cvmMul( &ctmpM2, &cvectp1, &ctmpVect2);
cvmSub( &cvectp2, &ctmpVect2, &ctmpE2);
/* Need scale */
cvmScale(&ctmpE1,&cepipole1,1.0);
cvmScale(&ctmpE2,&cepipole2,1.0);
cvmFree(&cmatrP1);
cvmFree(&cmatrP1);
cvmFree(&cvectp1);
cvmFree(&cvectp2);
cvmFree(&ctmpF1);
cvmFree(&ctmpM1);
cvmFree(&ctmpM2);
cvmFree(&cinvP1);
cvmFree(&cinvP2);
cvmFree(&ctmpMatr);
cvmFree(&ctmpVect1);
cvmFree(&ctmpVect2);
cvmFree(&cmatrF1);
cvmFree(&ctmpF);
cvmFree(&ctmpE1);
cvmFree(&ctmpE2);
return CV_NO_ERR;
}/* cvComputeEpipoles */
#endif
/* Compute epipoles for fundamental matrix */
int cvComputeEpipolesFromFundMatrix(CvMatr32f fundMatr,
CvPoint3D32f* epipole1,
CvPoint3D32f* epipole2)
{
/* Decompose fundamental matrix using SVD ( A = U W V') */
CvMat fundMatrC = cvMat(3,3,CV_MAT32F,fundMatr);
CvMat* matrW = cvCreateMat(3,3,CV_MAT32F);
CvMat* matrU = cvCreateMat(3,3,CV_MAT32F);
CvMat* matrV = cvCreateMat(3,3,CV_MAT32F);
/* From svd we need just last vector of U and V or last row from U' and V' */
/* We get transposed matrixes U and V */
cvSVD(&fundMatrC,matrW,matrU,matrV,CV_SVD_V_T|CV_SVD_U_T);
/* Get last row from U' and compute epipole1 */
epipole1->x = matrU->data.fl[6];
epipole1->y = matrU->data.fl[7];
epipole1->z = matrU->data.fl[8];
/* Get last row from V' and compute epipole2 */
epipole2->x = matrV->data.fl[6];
epipole2->y = matrV->data.fl[7];
epipole2->z = matrV->data.fl[8];
cvReleaseMat(&matrW);
cvReleaseMat(&matrU);
cvReleaseMat(&matrV);
return CV_OK;
}
int cvConvertEssential2Fundamental( CvMatr32f essMatr,
CvMatr32f fundMatr,
CvMatr32f cameraMatr1,
CvMatr32f cameraMatr2)
{/* Fund = inv(CM1') * Ess * inv(CM2) */
CvMat essMatrC = cvMat(3,3,CV_MAT32F,essMatr);
CvMat fundMatrC = cvMat(3,3,CV_MAT32F,fundMatr);
CvMat cameraMatr1C = cvMat(3,3,CV_MAT32F,cameraMatr1);
CvMat cameraMatr2C = cvMat(3,3,CV_MAT32F,cameraMatr2);
CvMat* invCM2 = cvCreateMat(3,3,CV_MAT32F);
CvMat* tmpMatr = cvCreateMat(3,3,CV_MAT32F);
CvMat* invCM1T = cvCreateMat(3,3,CV_MAT32F);
cvTranspose(&cameraMatr1C,tmpMatr);
cvInvert(tmpMatr,invCM1T);
cvmMul(invCM1T,&essMatrC,tmpMatr);
cvInvert(&cameraMatr2C,invCM2);
cvmMul(tmpMatr,invCM2,&fundMatrC);
/* Scale fundamental matrix */
double scale;
scale = 1.0/fundMatrC.data.fl[8];
cvConvertScale(&fundMatrC,&fundMatrC,scale);
cvReleaseMat(&invCM2);
cvReleaseMat(&tmpMatr);
cvReleaseMat(&invCM1T);
return CV_OK;
}
/* Compute essential matrix */
int cvComputeEssentialMatrix( CvMatr32f rotMatr,
CvMatr32f transVect,
CvMatr32f essMatr)
{
float transMatr[9];
/* Make antisymmetric matrix from transpose vector */
transMatr[0] = 0;
transMatr[1] = - transVect[2];
transMatr[2] = transVect[1];
transMatr[3] = transVect[2];
transMatr[4] = 0;
transMatr[5] = - transVect[0];
transMatr[6] = - transVect[1];
transMatr[7] = transVect[0];
transMatr[8] = 0;
icvMulMatrix_32f(transMatr,3,3,rotMatr,3,3,essMatr);
return CV_OK;
}
Reference in New Issue View Git Blame Copy Permalink