generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

fixed 2 build problems on MacOSX (highgui with ffmpeg, opencv_world); added macro CV_INIT_ALGORITHM for simpler algorithm registration (ticket )

Browse Source
This commit is contained in:
Vadim Pisarevsky 2012-05-21 14:56:07 +00:00
parent 9bc5afd278
commit fd68cc768a
7 changed files with 139 additions and 329 deletions
modules
core/include/opencv2/core
internal.hpp
features2d/src
features2d_init.cpp
highgui
CMakeLists.txt
ml/src
ml_init.cpp
nonfree/src
nonfree_init.cpp
video/src
video_init.cpp
world
CMakeLists.txt

28
modules/core/include/opencv2/core/internal.hpp

@ -233,6 +233,34 @@ CV_INLINE IppiSize ippiSize(int width, int height)
} }
#endif #endif
#define CV_INIT_ALGORITHM(classname, algname, memberinit) \
static Algorithm* create##classname() \
{ \
return new classname; \
} \
\
static AlgorithmInfo& classname##_info() \
{ \
static AlgorithmInfo classname##_info_var(algname, create##classname); \
return classname##_info_var; \
} \
\
static AlgorithmInfo& classname##_info_auto = classname##_info(); \
\
AlgorithmInfo* classname::info() const \
{ \
static volatile bool initialized = false; \
\
if( !initialized ) \
{ \
initialized = true; \
classname obj; \
memberinit; \
} \
return &classname##_info(); \
}
#endif #endif
/* maximal size of vector to run matrix operations on it inline (i.e. w/o ipp calls) */ /* maximal size of vector to run matrix operations on it inline (i.e. w/o ipp calls) */

263
modules/features2d/src/features2d_init.cpp

@ -51,208 +51,93 @@ namespace cv
All the AlgorithmInfo-related stuff should be in the same file as initModule_features2d(). All the AlgorithmInfo-related stuff should be in the same file as initModule_features2d().
Otherwise, linker may throw away some seemingly unused stuff. Otherwise, linker may throw away some seemingly unused stuff.
*/ */
static Algorithm* createBRIEF() { return new BriefDescriptorExtractor; }
static AlgorithmInfo& brief_info()
{
static AlgorithmInfo brief_info_var("Feature2D.BRIEF", createBRIEF);
return brief_info_var;
}
static AlgorithmInfo& brief_info_auto = brief_info(); CV_INIT_ALGORITHM(BriefDescriptorExtractor, "Feature2D.BRIEF",
obj.info()->addParam(obj, "bytes", obj.bytes_));
AlgorithmInfo* BriefDescriptorExtractor::info() const
{
static volatile bool initialized = false;
if( !initialized )
{
BriefDescriptorExtractor brief;
brief_info().addParam(brief, "bytes", brief.bytes_);
initialized = true;
}
return &brief_info();
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////
static Algorithm* createFAST() { return new FastFeatureDetector; }
static AlgorithmInfo& fast_info()
{
static AlgorithmInfo fast_info_var("Feature2D.FAST", createFAST);
return fast_info_var;
}
static AlgorithmInfo& fast_info_auto = fast_info();
AlgorithmInfo* FastFeatureDetector::info() const
{
static volatile bool initialized = false;
if( !initialized )
{
FastFeatureDetector obj;
fast_info().addParam(obj, "threshold", obj.threshold);
fast_info().addParam(obj, "nonmaxSuppression", obj.nonmaxSuppression);
initialized = true;
}
return &fast_info();
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////
static Algorithm* createStarDetector() { return new StarDetector; }
static AlgorithmInfo& star_info()
{
static AlgorithmInfo star_info_var("Feature2D.STAR", createStarDetector);
return star_info_var;
}
static AlgorithmInfo& star_info_auto = star_info();
AlgorithmInfo* StarDetector::info() const
{
static volatile bool initialized = false;
if( !initialized )
{
StarDetector obj;
star_info().addParam(obj, "maxSize", obj.maxSize);
star_info().addParam(obj, "responseThreshold", obj.responseThreshold);
star_info().addParam(obj, "lineThresholdProjected", obj.lineThresholdProjected);
star_info().addParam(obj, "lineThresholdBinarized", obj.lineThresholdBinarized);
star_info().addParam(obj, "suppressNonmaxSize", obj.suppressNonmaxSize);
initialized = true;
}
return &star_info();
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////
static Algorithm* createMSER() { return new MSER; }
static AlgorithmInfo& mser_info()
{
static AlgorithmInfo mser_info_var("Feature2D.MSER", createMSER);
return mser_info_var;
}
static AlgorithmInfo& mser_info_auto = mser_info();
AlgorithmInfo* MSER::info() const
{
static volatile bool initialized = false;
if( !initialized )
{
MSER obj;
mser_info().addParam(obj, "delta", obj.delta);
mser_info().addParam(obj, "minArea", obj.minArea);
mser_info().addParam(obj, "maxArea", obj.maxArea);
mser_info().addParam(obj, "maxVariation", obj.maxVariation);
mser_info().addParam(obj, "minDiversity", obj.minDiversity);
mser_info().addParam(obj, "maxEvolution", obj.maxEvolution);
mser_info().addParam(obj, "areaThreshold", obj.areaThreshold);
mser_info().addParam(obj, "minMargin", obj.minMargin);
mser_info().addParam(obj, "edgeBlurSize", obj.edgeBlurSize);
initialized = true;
}
return &mser_info();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////
static Algorithm* createORB() { return new ORB; } CV_INIT_ALGORITHM(FastFeatureDetector, "Feature2D.FAST",
static AlgorithmInfo& orb_info() obj.info()->addParam(obj, "threshold", obj.threshold);
{ obj.info()->addParam(obj, "nonmaxSuppression", obj.nonmaxSuppression));
static AlgorithmInfo orb_info_var("Feature2D.ORB", createORB);
return orb_info_var;
}
static AlgorithmInfo& orb_info_auto = orb_info(); ///////////////////////////////////////////////////////////////////////////////////////////////////////////
AlgorithmInfo* ORB::info() const CV_INIT_ALGORITHM(StarDetector, "Feature2D.STAR",
{ obj.info()->addParam(obj, "maxSize", obj.maxSize);
static volatile bool initialized = false; obj.info()->addParam(obj, "responseThreshold", obj.responseThreshold);
if( !initialized ) obj.info()->addParam(obj, "lineThresholdProjected", obj.lineThresholdProjected);
{ obj.info()->addParam(obj, "lineThresholdBinarized", obj.lineThresholdBinarized);
ORB obj; obj.info()->addParam(obj, "suppressNonmaxSize", obj.suppressNonmaxSize));
orb_info().addParam(obj, "nFeatures", obj.nfeatures);
orb_info().addParam(obj, "scaleFactor", obj.scaleFactor);
orb_info().addParam(obj, "nLevels", obj.nlevels);
orb_info().addParam(obj, "firstLevel", obj.firstLevel);
orb_info().addParam(obj, "edgeThreshold", obj.edgeThreshold);
orb_info().addParam(obj, "patchSize", obj.patchSize);
orb_info().addParam(obj, "WTA_K", obj.WTA_K);
orb_info().addParam(obj, "scoreType", obj.scoreType);
initialized = true;
}
return &orb_info();
}
static Algorithm* createGFTT() { return new GFTTDetector; }
static Algorithm* createHarris()
{
GFTTDetector* d = new GFTTDetector;
d->set("useHarris", true);
return d;
}
static AlgorithmInfo gftt_info("Feature2D.GFTT", createGFTT);
static AlgorithmInfo harris_info("Feature2D.HARRIS", createHarris);
AlgorithmInfo* GFTTDetector::info() const ///////////////////////////////////////////////////////////////////////////////////////////////////////////
{
static volatile bool initialized = false;
if( !initialized )
{
GFTTDetector obj;
gftt_info.addParam(obj, "nfeatures", obj.nfeatures);
gftt_info.addParam(obj, "qualityLevel", obj.qualityLevel);
gftt_info.addParam(obj, "minDistance", obj.minDistance);
gftt_info.addParam(obj, "useHarrisDetector", obj.useHarrisDetector);
gftt_info.addParam(obj, "k", obj.k);
harris_info.addParam(obj, "nfeatures", obj.nfeatures);
harris_info.addParam(obj, "qualityLevel", obj.qualityLevel);
harris_info.addParam(obj, "minDistance", obj.minDistance);
harris_info.addParam(obj, "useHarrisDetector", obj.useHarrisDetector);
harris_info.addParam(obj, "k", obj.k);
initialized = true;
}
return &gftt_info;
}
static Algorithm* createDense() { return new DenseFeatureDetector; } CV_INIT_ALGORITHM(MSER, "Feature2D.MSER",
static AlgorithmInfo dense_info("Feature2D.Dense", createDense); obj.info()->addParam(obj, "delta", obj.delta);
obj.info()->addParam(obj, "minArea", obj.minArea);
obj.info()->addParam(obj, "maxArea", obj.maxArea);
obj.info()->addParam(obj, "maxVariation", obj.maxVariation);
obj.info()->addParam(obj, "minDiversity", obj.minDiversity);
obj.info()->addParam(obj, "maxEvolution", obj.maxEvolution);
obj.info()->addParam(obj, "areaThreshold", obj.areaThreshold);
obj.info()->addParam(obj, "minMargin", obj.minMargin);
obj.info()->addParam(obj, "edgeBlurSize", obj.edgeBlurSize));
AlgorithmInfo* DenseFeatureDetector::info() const ///////////////////////////////////////////////////////////////////////////////////////////////////////////
CV_INIT_ALGORITHM(ORB, "Feature2D.ORB",
obj.info()->addParam(obj, "nFeatures", obj.nfeatures);
obj.info()->addParam(obj, "scaleFactor", obj.scaleFactor);
obj.info()->addParam(obj, "nLevels", obj.nlevels);
obj.info()->addParam(obj, "firstLevel", obj.firstLevel);
obj.info()->addParam(obj, "edgeThreshold", obj.edgeThreshold);
obj.info()->addParam(obj, "patchSize", obj.patchSize);
obj.info()->addParam(obj, "WTA_K", obj.WTA_K);
obj.info()->addParam(obj, "scoreType", obj.scoreType));
///////////////////////////////////////////////////////////////////////////////////////////////////////////
CV_INIT_ALGORITHM(GFTTDetector, "Feature2D.GFTT",
obj.info()->addParam(obj, "nfeatures", obj.nfeatures);
obj.info()->addParam(obj, "qualityLevel", obj.qualityLevel);
obj.info()->addParam(obj, "minDistance", obj.minDistance);
obj.info()->addParam(obj, "useHarrisDetector", obj.useHarrisDetector);
obj.info()->addParam(obj, "k", obj.k));
///////////////////////////////////////////////////////////////////////////////////////////////////////////
class CV_EXPORTS HarrisDetector : public GFTTDetector
{ {
static volatile bool initialized = false; public:
if( !initialized ) HarrisDetector( int maxCorners=1000, double qualityLevel=0.01, double minDistance=1,
{ int blockSize=3, bool useHarrisDetector=true, double k=0.04 )
DenseFeatureDetector obj; : GFTTDetector( maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k ) {}
dense_info.addParam(obj, "initFeatureScale", obj.initFeatureScale); AlgorithmInfo* info() const;
dense_info.addParam(obj, "featureScaleLevels", obj.featureScaleLevels); };
dense_info.addParam(obj, "featureScaleMul", obj.featureScaleMul);
dense_info.addParam(obj, "initXyStep", obj.initXyStep); CV_INIT_ALGORITHM(HarrisDetector, "Feature2D.HARRIS",
dense_info.addParam(obj, "initImgBound", obj.initImgBound); obj.info()->addParam(obj, "nfeatures", obj.nfeatures);
dense_info.addParam(obj, "varyXyStepWithScale", obj.varyXyStepWithScale); obj.info()->addParam(obj, "qualityLevel", obj.qualityLevel);
dense_info.addParam(obj, "varyImgBoundWithScale", obj.varyImgBoundWithScale); obj.info()->addParam(obj, "minDistance", obj.minDistance);
obj.info()->addParam(obj, "useHarrisDetector", obj.useHarrisDetector);
initialized = true; obj.info()->addParam(obj, "k", obj.k));
}
return &dense_info; ////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
CV_INIT_ALGORITHM(DenseFeatureDetector, "Feature2D.Dense",
obj.info()->addParam(obj, "initFeatureScale", obj.initFeatureScale);
obj.info()->addParam(obj, "featureScaleLevels", obj.featureScaleLevels);
obj.info()->addParam(obj, "featureScaleMul", obj.featureScaleMul);
obj.info()->addParam(obj, "initXyStep", obj.initXyStep);
obj.info()->addParam(obj, "initImgBound", obj.initImgBound);
obj.info()->addParam(obj, "varyXyStepWithScale", obj.varyXyStepWithScale);
obj.info()->addParam(obj, "varyImgBoundWithScale", obj.varyImgBoundWithScale));
bool initModule_features2d(void) bool initModule_features2d(void)
{ {
Ptr<Algorithm> brief = createBRIEF(), orb = createORB(), Ptr<Algorithm> brief = createBriefDescriptorExtractor(), orb = createORB(),
star = createStarDetector(), fastd = createFAST(), mser = createMSER(), star = createStarDetector(), fastd = createFastFeatureDetector(), mser = createMSER(),
dense = createDense(), gftt = createGFTT(), harris = createHarris(); dense = createDenseFeatureDetector(), gftt = createGFTTDetector(), harris = createHarrisDetector();
return brief->info() != 0 && orb->info() != 0 && star->info() != 0 && return brief->info() != 0 && orb->info() != 0 && star->info() != 0 &&
fastd->info() != 0 && mser->info() != 0 && dense->info() != 0 && fastd->info() != 0 && mser->info() != 0 && dense->info() != 0 &&

3
modules/highgui/CMakeLists.txt

@ -148,7 +148,8 @@ endif(HAVE_XIMEA)
if(HAVE_FFMPEG) if(HAVE_FFMPEG)
if(UNIX AND BZIP2_LIBRARIES) if(UNIX AND BZIP2_LIBRARIES)
list(APPEND HIGHGUI_LIBRARIES ${BZIP2_LIBRARIES}) list(APPEND HIGHGUI_LIBRARIES ${BZIP2_LIBRARIES})
elseif(APPLE) endif()
if(APPLE)
list(APPEND HIGHGUI_LIBRARIES "-framework VideoDecodeAcceleration") list(APPEND HIGHGUI_LIBRARIES "-framework VideoDecodeAcceleration")
endif() endif()
endif(HAVE_FFMPEG) endif(HAVE_FFMPEG)

33
modules/ml/src/ml_init.cpp

@ -45,31 +45,14 @@
namespace cv namespace cv
{ {
static Algorithm* createEM() CV_INIT_ALGORITHM(EM, "StatModel.EM",
{ obj.info()->addParam(obj, "nclusters", obj.nclusters);
return new EM; obj.info()->addParam(obj, "covMatType", obj.covMatType);
} obj.info()->addParam(obj, "maxIters", obj.maxIters);
static AlgorithmInfo em_info("StatModel.EM", createEM); obj.info()->addParam(obj, "epsilon", obj.epsilon);
obj.info()->addParam(obj, "weights", obj.weights, true);
AlgorithmInfo* EM::info() const obj.info()->addParam(obj, "means", obj.means, true);
{ obj.info()->addParam(obj, "covs", obj.covs, true));
static volatile bool initialized = false;
if( !initialized )
{
EM obj;
em_info.addParam(obj, "nclusters", obj.nclusters);
em_info.addParam(obj, "covMatType", obj.covMatType);
em_info.addParam(obj, "maxIters", obj.maxIters);
em_info.addParam(obj, "epsilon", obj.epsilon);
em_info.addParam(obj, "weights", obj.weights, true);
em_info.addParam(obj, "means", obj.means, true);
em_info.addParam(obj, "covs", obj.covs, true);
initialized = true;
}
return &em_info;
}
bool initModule_ml(void) bool initModule_ml(void)
{ {

67
modules/nonfree/src/nonfree_init.cpp

@ -46,65 +46,22 @@ namespace cv
{ {
/////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////
static Algorithm* createSURF()
{
return new SURF;
}
static AlgorithmInfo& surf_info() CV_INIT_ALGORITHM(SURF, "Feature2D.SURF",
{ obj.info()->addParam(obj, "hessianThreshold", obj.hessianThreshold);
static AlgorithmInfo surf_info_var("Feature2D.SURF", createSURF); obj.info()->addParam(obj, "nOctaves", obj.nOctaves);
return surf_info_var; obj.info()->addParam(obj, "nOctaveLayers", obj.nOctaveLayers);
} obj.info()->addParam(obj, "extended", obj.extended);
obj.info()->addParam(obj, "upright", obj.upright));
static AlgorithmInfo& surf_info_auto = surf_info();
AlgorithmInfo* SURF::info() const
{
static volatile bool initialized = false;
if( !initialized )
{
SURF obj;
surf_info().addParam(obj, "hessianThreshold", obj.hessianThreshold);
surf_info().addParam(obj, "nOctaves", obj.nOctaves);
surf_info().addParam(obj, "nOctaveLayers", obj.nOctaveLayers);
surf_info().addParam(obj, "extended", obj.extended);
surf_info().addParam(obj, "upright", obj.upright);
initialized = true;
}
return &surf_info();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////
static Algorithm* createSIFT() { return new SIFT; } CV_INIT_ALGORITHM(SIFT, "Feature2D.SIFT",
obj.info()->addParam(obj, "nFeatures", obj.nfeatures);
static AlgorithmInfo& sift_info() obj.info()->addParam(obj, "nOctaveLayers", obj.nOctaveLayers);
{ obj.info()->addParam(obj, "contrastThreshold", obj.contrastThreshold);
static AlgorithmInfo sift_info_var("Feature2D.SIFT", createSIFT); obj.info()->addParam(obj, "edgeThreshold", obj.edgeThreshold);
return sift_info_var; obj.info()->addParam(obj, "sigma", obj.sigma));
}
static AlgorithmInfo& sift_info_auto = sift_info();
AlgorithmInfo* SIFT::info() const
{
static volatile bool initialized = false;
if( !initialized )
{
SIFT obj;
sift_info().addParam(obj, "nFeatures", obj.nfeatures);
sift_info().addParam(obj, "nOctaveLayers", obj.nOctaveLayers);
sift_info().addParam(obj, "contrastThreshold", obj.contrastThreshold);
sift_info().addParam(obj, "edgeThreshold", obj.edgeThreshold);
sift_info().addParam(obj, "sigma", obj.sigma);
initialized = true;
}
return &sift_info();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////

68
modules/video/src/video_init.cpp

@ -47,72 +47,24 @@ namespace cv
/////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////
static Algorithm* createMOG() CV_INIT_ALGORITHM(BackgroundSubtractorMOG, "BackgroundSubtractor.MOG",
{ obj.info()->addParam(obj, "history", obj.history);
return new BackgroundSubtractorMOG; obj.info()->addParam(obj, "nmixtures", obj.nmixtures);
} obj.info()->addParam(obj, "backgroundRatio", obj.backgroundRatio);
obj.info()->addParam(obj, "noiseSigma", obj.noiseSigma));
static AlgorithmInfo& mog_info()
{
static AlgorithmInfo mog_info_var("BackgroundSubtractor.MOG", createMOG);
return mog_info_var;
}
static AlgorithmInfo& mog_info_auto = mog_info();
AlgorithmInfo* BackgroundSubtractorMOG::info() const
{
static volatile bool initialized = false;
if( !initialized )
{
BackgroundSubtractorMOG obj;
mog_info().addParam(obj, "history", obj.history);
mog_info().addParam(obj, "nmixtures", obj.nmixtures);
mog_info().addParam(obj, "backgroundRatio", obj.backgroundRatio);
mog_info().addParam(obj, "noiseSigma", obj.noiseSigma);
initialized = true;
}
return &mog_info();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////
static Algorithm* createMOG2() CV_INIT_ALGORITHM(BackgroundSubtractorMOG2, "BackgroundSubtractor.MOG2",
{ obj.info()->addParam(obj, "history", obj.history);
return new BackgroundSubtractorMOG2; obj.info()->addParam(obj, "varThreshold", obj.varThreshold);
} obj.info()->addParam(obj, "detectShadows", obj.bShadowDetection));
static AlgorithmInfo& mog2_info()
{
static AlgorithmInfo mog2_info_var("BackgroundSubtractor.MOG2", createMOG2);
return mog2_info_var;
}
static AlgorithmInfo& mog2_info_auto = mog2_info();
AlgorithmInfo* BackgroundSubtractorMOG2::info() const
{
static volatile bool initialized = false;
if( !initialized )
{
BackgroundSubtractorMOG2 obj;
mog2_info().addParam(obj, "history", obj.history);
mog2_info().addParam(obj, "varThreshold", obj.varThreshold);
mog2_info().addParam(obj, "detectShadows", obj.bShadowDetection);
initialized = true;
}
return &mog2_info();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////
bool initModule_video(void) bool initModule_video(void)
{ {
Ptr<Algorithm> mog = createMOG(), mog2 = createMOG2(); Ptr<Algorithm> mog = createBackgroundSubtractorMOG(), mog2 = createBackgroundSubtractorMOG2();
return mog->info() != 0 && mog2->info() != 0; return mog->info() != 0 && mog2->info() != 0;
} }

6
modules/world/CMakeLists.txt

@ -52,7 +52,11 @@ foreach(m ${OPENCV_MODULE_${the_module}_DEPS})
get_filename_component(srcname_we ${srcname} NAME_WE) get_filename_component(srcname_we ${srcname} NAME_WE)
string(REGEX REPLACE <SRC_NAME_WE> "${srcname_we}" objpath2 "${objpath1}") string(REGEX REPLACE <SRC_NAME_WE> "${srcname_we}" objpath2 "${objpath1}")
string(REGEX REPLACE <RELATIVE_SRC_NAME> "${srcname}" objpath3 "${objpath2}") string(REGEX REPLACE <RELATIVE_SRC_NAME> "${srcname}" objpath3 "${objpath2}")
file(RELATIVE_PATH objpath4 "${CMAKE_CURRENT_BINARY_DIR}" "${objpath3}") if(CMAKE_GENERATOR MATCHES Xcode)
set(objpath4 ${objpath3})
else()
file(RELATIVE_PATH objpath4 "${CMAKE_CURRENT_BINARY_DIR}" "${objpath3}")
endif()
list(APPEND objlist "\"${objpath4}\"") list(APPEND objlist "\"${objpath4}\"")
endif() endif()
endforeach() endforeach()