Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP

Comparing changes

Choose two branches to see what's changed or to start a new pull request. If you need to, you can also compare across forks.

Open a pull request

Create a new pull request by comparing changes across two branches. If you need to, you can also compare across forks.
base fork: cpichard/calibrig
base: fc572d51e6
...
head fork: cpichard/calibrig
compare: e005944b6d
  • 2 commits
  • 10 files changed
  • 0 commit comments
  • 1 contributor
View
4 src/Deformation.h
@@ -25,7 +25,9 @@ struct Deformation
static const unsigned int s_histogramBinSize = 64;
- double m_h[9];
+ double m_h1[9]; // Homography first image
+ double m_h2[9]; // Homography second image
+ double m_f[9]; // Fundamental matrix
bool m_succeed;
double m_rot;
double m_tx;
View
151 src/FMatrixAnalyzerCPU.cpp
@@ -0,0 +1,151 @@
+#include "FMatrixAnalyzerCPU.h"
+
+#include "NvSDIin.h"
+
+
+#include <vector>
+#include <iomanip>
+#include <iostream>
+
+using std::vector;
+
+extern void normalise( CvSeq* keyPoints, unsigned int imgWidth, unsigned int imgHeight );
+
+extern void
+findPairs(const CvSeq* rightKeypoints, const CvSeq* rightDescriptors,
+ const CvSeq* leftKeypoints, const CvSeq* leftDescriptors, std::vector<int>& ptpairs );
+// Constructor
+FMatrixAnalyzerCPU::FMatrixAnalyzerCPU( unsigned int nbChannelsInSDIVideo )
+: HomographyAnalyzerCPU( nbChannelsInSDIVideo )
+{}
+
+FMatrixAnalyzerCPU::~FMatrixAnalyzerCPU()
+{}
+
+int
+findFMatrix( const CvSeq* rightKeypoints, const CvSeq* rightDescriptors,
+ const CvSeq* leftKeypoints, const CvSeq* leftDescriptors,
+ double *f, double *h1, double *h2, vector<int> &ptpairs,
+ CvSize &imgSize)
+{
+ CvMat _f = cvMat(3, 3, CV_64F, f);
+ CvMat _h1 = cvMat(3, 3, CV_64F, h1);
+ CvMat _h2 = cvMat(3, 3, CV_64F, h2);
+
+ vector<CvPoint2D32f> pt1, pt2;
+ CvMat _pt1, _pt2;
+ int i, n;
+
+ findPairs( rightKeypoints, rightDescriptors, leftKeypoints, leftDescriptors, ptpairs );
+
+ n = ptpairs.size()/2;
+ if( n < 7 )
+ return 0;
+
+ pt1.resize(n);
+ pt2.resize(n);
+ for( i = 0; i < n; i++ )
+ {
+ pt1[i] = ((CvSURFPoint*)cvGetSeqElem(rightKeypoints,ptpairs[i*2]))->pt;
+ pt2[i] = ((CvSURFPoint*)cvGetSeqElem(leftKeypoints,ptpairs[i*2+1]))->pt;
+ }
+
+ _pt1 = cvMat(1, n, CV_32FC2, &pt1[0] );
+ _pt2 = cvMat(1, n, CV_32FC2, &pt2[0] );
+
+ // TODO : recuperer les points matches et faire la rectification avec
+ if( cvFindFundamentalMat( &_pt1, &_pt2, &_f, CV_LMEDS, 1.0, 0.99 /*, points matches*/ ))
+ {
+ cvStereoRectifyUncalibrated( &_pt1, &_pt2, &_f, imgSize, &_h1, &_h2);
+ return 1;
+ }
+
+ return 0;
+}
+
+// Launch analysis and return
+void FMatrixAnalyzerCPU::analyse()
+{
+ m_leftImageIsNew = m_rightImageIsNew = false;
+
+ if( m_imgWidth == 0 || m_imgHeight == 0 )
+ return;
+
+ // If no one has taken the result,
+ if( m_result != NULL )
+ {
+ return;
+ }
+
+ // Allocate new result
+ // BAD !! optimize here
+ // DO not allocate a result each time
+ ComputationDataCPU *resultTmp = new ComputationDataCPU();
+ m_result = resultTmp;
+
+ // Check if we have the buffers
+ if( m_imgRight == NULL || m_imgLeft == NULL )
+ {
+ return;
+ }
+
+ // Params
+ CvSURFParams params = cvSURFParams(m_surfThreshold, 1);
+ resultTmp->m_storage = cvCreateMemStorage(0);
+
+ // Extract surf descriptors
+ double tt = (double)cvGetTickCount();
+ cvExtractSURF( m_imgRight, NULL,
+ &resultTmp->m_rightKeypoints,
+ &resultTmp->m_rightDescriptors,
+ resultTmp->m_storage, params );
+
+ cvExtractSURF( m_imgLeft, NULL,
+ &resultTmp->m_leftKeypoints,
+ &resultTmp->m_leftDescriptors,
+ resultTmp->m_storage, params );
+
+ tt = (double)cvGetTickCount() - tt;
+ // TODO : is it needed in result ?
+ //printf( "Extraction time = %gms\n", tt/(cvGetTickFrequency()*1000.));
+
+ // No points found
+ if( ! resultTmp->m_rightKeypoints || ! resultTmp->m_leftKeypoints )
+ {
+ delete resultTmp;
+ resultTmp = NULL;
+ m_result = NULL;
+ return;
+ }
+
+ // Keypoints are in the image basis => normalize keypoints between -0.5 and 0.5
+ normalise( resultTmp->m_rightKeypoints, m_imgWidth, m_imgHeight );
+ normalise( resultTmp->m_leftKeypoints, m_imgWidth, m_imgHeight );
+
+ Deformation &d = resultTmp->m_d;
+ d.m_nbPtsRight = resultTmp->m_rightKeypoints->total;
+ d.m_nbPtsLeft = resultTmp->m_leftKeypoints->total;
+ d.m_nbMatches = 0;
+ d.m_mode = "CPU";
+
+ CvSize imgSize;
+ imgSize.width=m_imgWidth;
+ imgSize.height=m_imgHeight;
+ if( findFMatrix( resultTmp->m_leftKeypoints, resultTmp->m_leftDescriptors,
+ resultTmp->m_rightKeypoints, resultTmp->m_rightDescriptors,
+ d.m_f, d.m_h1, d.m_h2, resultTmp->m_ptpairs, imgSize ) )
+ {
+ // Copy result
+ d.m_succeed = true;
+ d.m_nbPtsRight = resultTmp->m_rightKeypoints->total;
+ d.m_nbPtsLeft = resultTmp->m_leftKeypoints->total;
+ d.m_nbMatches = resultTmp->m_ptpairs.size()/2;
+ resultTmp->m_thresholdUsed = m_surfThreshold;
+ resultTmp->setRightImage( m_imgRight);
+ resultTmp->setLeftImage ( m_imgLeft );
+ }
+
+ // TODO :
+ // computeDisparity();
+}
+
View
32 src/FMatrixAnalyzerCPU.h
@@ -0,0 +1,32 @@
+#ifndef __FMATRIXANALYZERCPU_H__
+#define __FMATRIXANALYZERCPU_H__
+
+#include "cv.h"
+#include "highgui.h"
+#include <GL/gl.h>
+#include <GL/glext.h>
+#include <GL/glx.h>
+#include <GL/glxext.h>
+#include <GL/glu.h>
+#include <GL/glut.h>
+#include <vector>
+#include "Utils.h"
+
+#include <boost/thread.hpp>
+#include "ComputationDataCPU.h"
+#include "HomographyAnalyzerCPU.h"
+
+// TODO : rename to StereoAnalyZerCPU
+class FMatrixAnalyzerCPU : public HomographyAnalyzerCPU
+{
+public:
+ // Constructor
+ FMatrixAnalyzerCPU( unsigned int nbChannelsInSDIVideo=2 );
+ ~FMatrixAnalyzerCPU();
+
+ // Launch analysis and return results
+ virtual void analyse();
+};
+
+#endif
+
View
2  src/GraphicSystemX11.cpp
@@ -31,7 +31,7 @@ GraphicSystemX11::GraphicSystemX11(UInt2 windowSize)
// TODO XSetWMProtocols(m_display, mainWin, &wmDeleteMessage, 1);
checkSystem();
-
+
// Grab the first GPU for now for DVP
m_gpu = &(m_gpuList[0]);
View
40 src/StereoAnalyzerCPU.cpp → src/HomographyAnalyzerCPU.cpp
@@ -1,4 +1,4 @@
-#include "StereoAnalyzerCPU.h"
+#include "HomographyAnalyzerCPU.h"
#include "NvSDIin.h"
@@ -7,6 +7,10 @@
#include <iomanip>
#include <iostream>
+// PI
+#include <boost/math/constants/constants.hpp>
+const float PI_FLOAT = boost::math::constants::pi<float>();
+
using std::vector;
// Utility
@@ -26,8 +30,8 @@ void printMat( std::string T, CvMat *H, int r, int c )
}
// Constructor
-StereoAnalyzerCPU::StereoAnalyzerCPU( unsigned int nbChannelsInSDIVideo )
-:StereoAnalyzer( nbChannelsInSDIVideo )
+HomographyAnalyzerCPU::HomographyAnalyzerCPU( unsigned int nbChannelsInSDIVideo )
+: StereoAnalyzer( nbChannelsInSDIVideo )
, m_imgWidth(0)
, m_imgHeight(0)
, m_surfThreshold(500)
@@ -45,7 +49,7 @@ StereoAnalyzerCPU::StereoAnalyzerCPU( unsigned int nbChannelsInSDIVideo )
cvSetIdentity(m_warpMatrix);
}
-StereoAnalyzerCPU::~StereoAnalyzerCPU()
+HomographyAnalyzerCPU::~HomographyAnalyzerCPU()
{
// Release OpenCV images
freeImages( );
@@ -58,27 +62,27 @@ StereoAnalyzerCPU::~StereoAnalyzerCPU()
}
}
-void StereoAnalyzerCPU::updateRightImageWithSDIVideo( ImageGL &videoPBO )
+void HomographyAnalyzerCPU::updateRightImageWithSDIVideo( ImageGL &videoPBO )
{
boost::mutex::scoped_lock sl(m_imgMutex);
updateImageWithSDIVideo(videoPBO, m_imgRight);
m_rightImageIsNew = true;
}
-void StereoAnalyzerCPU::updateLeftImageWithSDIVideo ( ImageGL &videoPBO )
+void HomographyAnalyzerCPU::updateLeftImageWithSDIVideo ( ImageGL &videoPBO )
{
boost::mutex::scoped_lock sl(m_imgMutex);
updateImageWithSDIVideo(videoPBO, m_imgLeft );
m_leftImageIsNew = true;
}
-void StereoAnalyzerCPU::resizeImages( UInt2 imgSize )
+void HomographyAnalyzerCPU::resizeImages( UInt2 imgSize )
{
freeImages();
allocImages( imgSize );
}
-void StereoAnalyzerCPU::allocImages( UInt2 imgSize )
+void HomographyAnalyzerCPU::allocImages( UInt2 imgSize )
{
m_imgWidth = Width(imgSize);
m_imgHeight = Height(imgSize);
@@ -113,7 +117,7 @@ void StereoAnalyzerCPU::allocImages( UInt2 imgSize )
cvmSet( m_fromNormMatrix, 2, 2, 1.0/L);
}
-void StereoAnalyzerCPU::freeImages( )
+void HomographyAnalyzerCPU::freeImages( )
{
if( m_imgRight )
{
@@ -143,7 +147,7 @@ void StereoAnalyzerCPU::freeImages( )
}
-void StereoAnalyzerCPU::acceptCommand( const Command &command )
+void HomographyAnalyzerCPU::acceptCommand( const Command &command )
{
if( command.m_action == "OCVTHRESHOLD" )
{
@@ -166,7 +170,7 @@ void StereoAnalyzerCPU::acceptCommand( const Command &command )
// }
//}
-void StereoAnalyzerCPU::updateImageWithSDIVideo( ImageGL &videoPBO, IplImage *ocvImg )
+void HomographyAnalyzerCPU::updateImageWithSDIVideo( ImageGL &videoPBO, IplImage *ocvImg )
{
if( m_imgWidth == 0 || m_imgHeight == 0 )
return;
@@ -206,7 +210,7 @@ void StereoAnalyzerCPU::updateImageWithSDIVideo( ImageGL &videoPBO, IplImage *oc
}
// TESTING PURPOSE
-void StereoAnalyzerCPU::setTransform(float tx, float ty, float scale, float rot )
+void HomographyAnalyzerCPU::setTransform(float tx, float ty, float scale, float rot )
{
// Create transform mat
CvMat *transform = cvCreateMat(3,3,CV_64FC1);
@@ -367,7 +371,7 @@ findHomography( const CvSeq* rightKeypoints, const CvSeq* rightDescriptors,
}
// Launch analysis and return
-void StereoAnalyzerCPU::analyse()
+void HomographyAnalyzerCPU::analyse()
{
m_leftImageIsNew = m_rightImageIsNew = false;
@@ -433,11 +437,11 @@ void StereoAnalyzerCPU::analyse()
// Compute homography
if( findHomography( resultTmp->m_leftKeypoints, resultTmp->m_leftDescriptors,
resultTmp->m_rightKeypoints, resultTmp->m_rightDescriptors,
- d.m_h, resultTmp->m_ptpairs ) )
+ d.m_h1, resultTmp->m_ptpairs ) )
{
//std::cout << "Found Homography" << std::endl;
- CvMat H = cvMat(3, 3, CV_64F, d.m_h);
-
+ CvMat H = cvMat(3, 3, CV_64F, d.m_h1);
+ // TODO : H2 with indentity matrix
// Simple decomposition
double Tx = cvmGet(&H,0,2);
double Ty = cvmGet(&H,1,2);
@@ -449,7 +453,7 @@ void StereoAnalyzerCPU::analyse()
d.m_tx = Tx*(float)m_imgWidth;
d.m_ty = -Ty*(float)m_imgWidth;
d.m_scale = scale;
- d.m_rot = rot*180.f/3.14; // approx
+ d.m_rot = rot*180.f/PI_FLOAT;
d.m_succeed = true;
d.m_nbPtsRight = resultTmp->m_rightKeypoints->total;
d.m_nbPtsLeft = resultTmp->m_leftKeypoints->total;
@@ -462,7 +466,7 @@ void StereoAnalyzerCPU::analyse()
}
}
-void StereoAnalyzerCPU::computeDisparity()
+void HomographyAnalyzerCPU::computeDisparity()
{
if( m_result )
{
View
12 src/StereoAnalyzerCPU.h → src/HomographyAnalyzerCPU.h
@@ -1,5 +1,5 @@
-#ifndef __STEREOANALYZERCPU_H__
-#define __STEREOANALYZERCPU_H__
+#ifndef __HOMOGRAPHYANALYZERCPU_H__
+#define __HOMOGRAPHYANALYZERCPU_H__
#include "cv.h"
#include "highgui.h"
@@ -17,12 +17,12 @@
#include "StereoAnalyzer.h"
// TODO : rename to StereoAnalyZerCPU
-class StereoAnalyzerCPU : public StereoAnalyzer
+class HomographyAnalyzerCPU : public StereoAnalyzer
{
public:
// Constructor
- StereoAnalyzerCPU( unsigned int nbChannelsInSDIVideo=2 );
- ~StereoAnalyzerCPU();
+ HomographyAnalyzerCPU( unsigned int nbChannelsInSDIVideo=2 );
+ ~HomographyAnalyzerCPU();
// Update left and right images
virtual void updateRightImageWithSDIVideo( ImageGL &videoPBO );
@@ -42,7 +42,7 @@ class StereoAnalyzerCPU : public StereoAnalyzer
// TESTING PURPOSE
void setTransform(float tx, float ty, float scale, float rot );
-private:
+protected:
void updateImageWithSDIVideo( ImageGL &videoPBO, IplImage * );
//void saveImage ( IplImage *img, const std::string &filename );
View
30 src/StereoAnalyzerGPU.cpp → src/HomographyAnalyzerGPU.cpp
@@ -1,4 +1,4 @@
-#include "StereoAnalyzerGPU.h"
+#include "HomographyAnalyzerGPU.h"
#include "ComputationDataGPU.h"
#include "CudaUtils.h"
@@ -11,7 +11,7 @@
#include "ImageProcessing.h"
-StereoAnalyzerGPU::StereoAnalyzerGPU()
+HomographyAnalyzerGPU::HomographyAnalyzerGPU()
: StereoAnalyzer()
, m_hessianData()
, m_rightDescriptors()
@@ -22,14 +22,14 @@ StereoAnalyzerGPU::StereoAnalyzerGPU()
, m_toDispose(NULL)
{}
-StereoAnalyzerGPU::~StereoAnalyzerGPU()
+HomographyAnalyzerGPU::~HomographyAnalyzerGPU()
{
if(m_result)
delete m_result;
freeImages();
}
-void StereoAnalyzerGPU::updateRightImageWithSDIVideo( ImageGL &videoPBO )
+void HomographyAnalyzerGPU::updateRightImageWithSDIVideo( ImageGL &videoPBO )
{
boost::mutex::scoped_lock sl(m_imgMutex);
convertYCbYCrToY(videoPBO, m_imgRight );
@@ -42,7 +42,7 @@ void StereoAnalyzerGPU::updateRightImageWithSDIVideo( ImageGL &videoPBO )
cudaDeviceSynchronize();
}
-void StereoAnalyzerGPU::updateLeftImageWithSDIVideo ( ImageGL &videoPBO )
+void HomographyAnalyzerGPU::updateLeftImageWithSDIVideo ( ImageGL &videoPBO )
{
boost::mutex::scoped_lock sl(m_imgMutex);
convertYCbYCrToY(videoPBO, m_imgLeft );
@@ -55,7 +55,7 @@ void StereoAnalyzerGPU::updateLeftImageWithSDIVideo ( ImageGL &videoPBO )
cudaDeviceSynchronize();
}
-void StereoAnalyzerGPU::acceptCommand( const Command &command )
+void HomographyAnalyzerGPU::acceptCommand( const Command &command )
{
if( command.m_action == "OCVTHRESHOLD" )
{
@@ -69,7 +69,7 @@ void StereoAnalyzerGPU::acceptCommand( const Command &command )
}
}
-void StereoAnalyzerGPU::analyse()
+void HomographyAnalyzerGPU::analyse()
{
if( m_imgWidth == 0 || m_imgHeight == 0 )
return;
@@ -115,7 +115,7 @@ void StereoAnalyzerGPU::analyse()
CvMat _pt1, _pt2;
_pt1 = cvMat(1, d.m_nbMatches, CV_32FC2, &m_result->m_leftMatchedPts[0] );
_pt2 = cvMat(1, d.m_nbMatches, CV_32FC2, &m_result->m_rightMatchedPts[0] );
- CvMat _h = cvMat(3, 3, CV_64F, d.m_h);
+ CvMat _h = cvMat(3, 3, CV_64F, d.m_h1);
if( cvFindHomography( &_pt1, &_pt2, &_h, CV_LMEDS, 1.0 ) )
{
// Simple decomposition
@@ -141,7 +141,7 @@ void StereoAnalyzerGPU::analyse()
}
}
-void StereoAnalyzerGPU::resizeImages( UInt2 imgSize )
+void HomographyAnalyzerGPU::resizeImages( UInt2 imgSize )
{
freeImages();
allocImages( imgSize );
@@ -149,7 +149,7 @@ void StereoAnalyzerGPU::resizeImages( UInt2 imgSize )
m_hessianData.resizeImages(imgSize);
}
-void StereoAnalyzerGPU::allocImages( UInt2 imgSize )
+void HomographyAnalyzerGPU::allocImages( UInt2 imgSize )
{
m_imgWidth = Width(imgSize);
m_imgHeight = Height(imgSize);
@@ -183,7 +183,7 @@ void StereoAnalyzerGPU::allocImages( UInt2 imgSize )
}
-void StereoAnalyzerGPU::freeImages()
+void HomographyAnalyzerGPU::freeImages()
{
m_hessianData.freeImages();
releaseBuffer( m_hesImage );
@@ -197,7 +197,7 @@ void StereoAnalyzerGPU::freeImages()
checkLastError();
}
-void StereoAnalyzerGPU::computeSurfDescriptors( CudaImageBuffer<float> &satImage, DescriptorData &descriptorsData )
+void HomographyAnalyzerGPU::computeSurfDescriptors( CudaImageBuffer<float> &satImage, DescriptorData &descriptorsData )
{
// Create integral image
convertToIntegral( satImage );
@@ -225,7 +225,7 @@ void StereoAnalyzerGPU::computeSurfDescriptors( CudaImageBuffer<float> &satImage
checkLastError();
}
-ComputationData * StereoAnalyzerGPU::acquireLastResult()
+ComputationData * HomographyAnalyzerGPU::acquireLastResult()
{
ComputationData *ret = NULL;
ret = m_result;
@@ -233,13 +233,13 @@ ComputationData * StereoAnalyzerGPU::acquireLastResult()
return ret;
}
-void StereoAnalyzerGPU::disposeResult(ComputationData *toDispose)
+void HomographyAnalyzerGPU::disposeResult(ComputationData *toDispose)
{
m_toDispose = (ComputationDataGPU*)toDispose;
}
-void StereoAnalyzerGPU::computeDisparity()
+void HomographyAnalyzerGPU::computeDisparity()
{
if( m_result && Width(m_imgLeft) > 0 )
{
View
13 src/StereoAnalyzerGPU.h → src/HomographyAnalyzerGPU.h
@@ -1,5 +1,5 @@
-#ifndef __STEREOANALYZERGPU_H__
-#define __STEREOANALYZERGPU_H__
+#ifndef __HOMOGRAPHYANALYZERGPU_H___
+#define __HOMOGRAPHYANALYZERGPU_H___
#include "StereoAnalyzer.h"
#include "SurfGPUData.h"
@@ -7,11 +7,12 @@
#include "SurfDescriptor.h"
#include "SurfCollectPoints.h"
#include "ComputationDataGPU.h"
-class StereoAnalyzerGPU : public StereoAnalyzer
+
+class HomographyAnalyzerGPU : public StereoAnalyzer
{
public:
- StereoAnalyzerGPU();
- virtual ~StereoAnalyzerGPU();
+ HomographyAnalyzerGPU();
+ virtual ~HomographyAnalyzerGPU();
void updateRightImageWithSDIVideo( ImageGL &videoPBO );
void updateLeftImageWithSDIVideo ( ImageGL &videoPBO );
@@ -57,5 +58,5 @@ class StereoAnalyzerGPU : public StereoAnalyzer
float m_sentThreshold;
};
-#endif // __STEREOANALYSERGPU_H__
+#endif // __HOMOGRAPHYANALYZERGPU_H__
View
5 src/Makefile.am
@@ -14,8 +14,9 @@ NvSDIin.h NvSDIin.cpp \
NvSDIutils.h NvSDIutils.cpp \
Monitor.h Monitor.cpp\
StereoAnalyzer.h StereoAnalyzer.cpp\
-StereoAnalyzerCPU.h StereoAnalyzerCPU.cpp\
-StereoAnalyzerGPU.h StereoAnalyzerGPU.cpp\
+HomographyAnalyzerCPU.h HomographyAnalyzerCPU.cpp\
+HomographyAnalyzerGPU.h HomographyAnalyzerGPU.cpp\
+FMatrixAnalyzerCPU.h FMatrixAnalyzerCPU.cpp\
ScreenLayout.h ScreenLayout.cpp\
QuadViewScreen.h QuadViewScreen.cpp\
DiffScreen.h DiffScreen.cpp\
View
11 src/main.cpp
@@ -24,8 +24,8 @@
#include <cstdlib>
#include "AnalyzerFunctor.h"
-#include "StereoAnalyzerCPU.h"
-#include "StereoAnalyzerGPU.h"
+#include "HomographyAnalyzerCPU.h"
+#include "HomographyAnalyzerGPU.h"
#include "NvSDIin.h"
#include "ImageProcessing.h"
@@ -46,6 +46,7 @@
const char *version = "20022012";
+
int main(int argc, char *argv[])
{
// Parse command line for program options
@@ -88,7 +89,6 @@ int main(int argc, char *argv[])
// Create an image grabber
Grabber *grabber=NULL;
-
//grabber = new GrabberSDI(gs.m_display, gs.m_gpu, gs.m_glxContext);
grabber = new GrabberTest(gs.m_display, gs.m_gpu, gs.m_glxContext);
@@ -119,9 +119,9 @@ int main(int argc, char *argv[])
// Create an analyzer
StereoAnalyzer *analyzer = NULL;
if(po.m_useGPU)
- analyzer = new StereoAnalyzerGPU();
+ analyzer = new HomographyAnalyzerGPU();
else
- analyzer = new StereoAnalyzerCPU();
+ analyzer = new HomographyAnalyzerCPU();
// Create a thread to run analysis on background
// Launch analyser in background
@@ -279,7 +279,6 @@ int main(int argc, char *argv[])
{
analyzer->updateLeftImageWithSDIVideo (grabber->stream1());
-
#if TEST // Transform image for tests
convertYCbYCrToY( grabber->stream2(), m_YTmp );

No commit comments for this range

Something went wrong with that request. Please try again.