Fixed Windows build warnings and configuration problem.

cmake/OpenCVDetectCXXCompiler.cmake

@@ -89,7 +89,7 @@ if(CMAKE_COMPILER_IS_GNUCXX)
     endif()
 endif()
 
-if(CMAKE_SYSTEM_PROCESSOR MATCHES amd64.*|x86_64.*)
+if(CMAKE_SYSTEM_PROCESSOR MATCHES amd64.*|x86_64.* OR CMAKE_GENERATOR MATCHES "Visual Studio.*Win64")
     set(X86_64 1)
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES i686.*|i386.*|x86.*)
     set(X86 1)

modules/core/include/opencv2/core/eigen.hpp

@@ -51,6 +51,7 @@
 #if defined _MSC_VER && _MSC_VER >= 1200
 #pragma warning( disable: 4714 ) //__forceinline is not inlined
 #pragma warning( disable: 4127 ) //conditional expression is constant
+#pragma warning( disable: 4244 ) //conversion from '__int64' to 'int', possible loss of data
 #endif
 
 namespace cv

modules/core/test/test_operations.cpp

@@ -955,13 +955,13 @@ bool CV_OperationsTest::TestSVD()
         Mat Q(3,3,CV_32FC1);
         Mat U,Vt,R,T,W;
         
-        Dp.at<float>(0,0)=0.86483884; Dp.at<float>(0,1)= -0.3077251; Dp.at<float>(0,2)=-0.55711365;
-        Dp.at<float>(1,0)=0.49294353; Dp.at<float>(1,1)=-0.24209651; Dp.at<float>(1,2)=-0.25084701;
-        Dp.at<float>(2,0)=0;          Dp.at<float>(2,1)=0;           Dp.at<float>(2,2)=0;
+        Dp.at<float>(0,0)=0.86483884f; Dp.at<float>(0,1)= -0.3077251f; Dp.at<float>(0,2)=-0.55711365f;
+        Dp.at<float>(1,0)=0.49294353f; Dp.at<float>(1,1)=-0.24209651f; Dp.at<float>(1,2)=-0.25084701f;
+        Dp.at<float>(2,0)=0;           Dp.at<float>(2,1)=0;            Dp.at<float>(2,2)=0;
         
-        Dc.at<float>(0,0)=0.75632739; Dc.at<float>(0,1)= -0.38859656; Dc.at<float>(0,2)=-0.36773083;
-        Dc.at<float>(1,0)=0.9699229; Dc.at<float>(1,1)=-0.49858192; Dc.at<float>(1,2)=-0.47134098;
-        Dc.at<float>(2,0)=0.10566688; Dc.at<float>(2,1)=-0.060333252; Dc.at<float>(2,2)=-0.045333147;
+        Dc.at<float>(0,0)=0.75632739f; Dc.at<float>(0,1)= -0.38859656f; Dc.at<float>(0,2)=-0.36773083f;
+        Dc.at<float>(1,0)=0.9699229f;  Dc.at<float>(1,1)=-0.49858192f;  Dc.at<float>(1,2)=-0.47134098f;
+        Dc.at<float>(2,0)=0.10566688f; Dc.at<float>(2,1)=-0.060333252f; Dc.at<float>(2,2)=-0.045333147f;
         
         Q=Dp*Dc.t();
         SVD decomp;

modules/features2d/src/freak.cpp

@@ -274,14 +274,14 @@ void FREAK::computeImpl( const Mat& image, std::vector<KeyPoint>& keypoints, Mat
     // allocate descriptor memory, estimate orientations, extract descriptors
     if( !extAll ) {
         // extract the best comparisons only
-        descriptors = cv::Mat::zeros(keypoints.size(), FREAK_NB_PAIRS/8, CV_8U);
+        descriptors = cv::Mat::zeros((int)keypoints.size(), FREAK_NB_PAIRS/8, CV_8U);
 #if CV_SSE2
         __m128i* ptr= (__m128i*) (descriptors.data+(keypoints.size()-1)*descriptors.step[0]);
         // binary: 10000000 => char: 128 or hex: 0x80
-        const __m128i binMask = _mm_set_epi8(0x80, 0x80, 0x80, 0x80,
-                                             0x80, 0x80, 0x80, 0x80,
-                                             0x80, 0x80, 0x80, 0x80,
-                                             0x80, 0x80, 0x80, 0x80);
+        const __m128i binMask = _mm_set_epi8('\x80', '\x80', '\x80', '\x80',
+                                             '\x80', '\x80', '\x80', '\x80',
+                                             '\x80', '\x80', '\x80', '\x80',
+                                             '\x80', '\x80', '\x80', '\x80');
 #else
         std::bitset<FREAK_NB_PAIRS>* ptr = (std::bitset<FREAK_NB_PAIRS>*) (descriptors.data+(keypoints.size()-1)*descriptors.step[0]);
 #endif
@@ -390,7 +390,7 @@ void FREAK::computeImpl( const Mat& image, std::vector<KeyPoint>& keypoints, Mat
         }
     }
     else { // extract all possible comparisons for selection
-        descriptors = cv::Mat::zeros(keypoints.size(), 128, CV_8U);
+        descriptors = cv::Mat::zeros((int)keypoints.size(), 128, CV_8U);
         std::bitset<1024>* ptr = (std::bitset<1024>*) (descriptors.data+(keypoints.size()-1)*descriptors.step[0]);
 
         for( size_t k = keypoints.size(); k--; ) {
@@ -522,16 +522,16 @@ vector<int> FREAK::selectPairs(const std::vector<Mat>& images
     Mat descriptorsFloat = Mat::zeros(descriptors.rows, 903, CV_32F);
 
     std::bitset<1024>* ptr = (std::bitset<1024>*) (descriptors.data+(descriptors.rows-1)*descriptors.step[0]);
-    for( size_t m = descriptors.rows; m--; ) {
-        for( size_t n = 903; n--; ) {
+    for( int m = descriptors.rows; m--; ) {
+        for( int n = 903; n--; ) {
             if( ptr->test(n) == true )
-                descriptorsFloat.at<float>(m,n)=1.0;
+                descriptorsFloat.at<float>(m,n)=1.0f;
         }
         --ptr;
     }
 
     std::vector<PairStat> pairStat;
-    for( size_t n = 903; n--; ) {
+    for( int n = 903; n--; ) {
         // the higher the variance, the better --> mean = 0.5
         PairStat tmp = { fabs( mean(descriptorsFloat.col(n))[0]-0.5 ) ,n};
         pairStat.push_back(tmp);

modules/gpu/src/cascadeclassifier.cpp

@@ -83,7 +83,7 @@ cv::gpu::CascadeClassifier_GPU_LBP::~CascadeClassifier_GPU_LBP()              {
 bool cv::gpu::CascadeClassifier_GPU_LBP::empty() const                               { throw_nogpu(); return true; }
 bool cv::gpu::CascadeClassifier_GPU_LBP::load(const string&)                         { throw_nogpu(); return true; }
 Size cv::gpu::CascadeClassifier_GPU_LBP::getClassifierSize() const                   { throw_nogpu(); return Size(); }
-void cv::gpu::CascadeClassifier_GPU_LBP::preallocateIntegralBuffer(cv::Size desired) { throw_nogpu();}
+void cv::gpu::CascadeClassifier_GPU_LBP::preallocateIntegralBuffer(cv::Size /*desired*/) { throw_nogpu();}
 
 int cv::gpu::CascadeClassifier_GPU_LBP::detectMultiScale(const cv::gpu::GpuMat&, cv::gpu::GpuMat&, cv::gpu::GpuMat&, double, int)  { throw_nogpu(); return 0; }
 

modules/gpu/test/test_video.cpp

@@ -545,7 +545,7 @@ TEST_P(MOG, Update)
             cv::swap(temp, frame);
         }
 
-        mog(loadMat(frame, useRoi), foreground, learningRate);
+        mog(loadMat(frame, useRoi), foreground, (float)learningRate);
 
         mog_gold(frame, foreground_gold, learningRate);
 

modules/videostab/include/opencv2/videostab/frame_source.hpp

@@ -81,11 +81,7 @@ public:
     double fps();
 
 private:
-    std::string path_;
-    bool volatileFrame_;
-
-    struct VideoReader;
-    const VideoReader& reader_;
+    Ptr<IFrameSource> impl;
 };
 
 } // namespace videostab

modules/videostab/src/frame_source.cpp

@@ -56,74 +56,67 @@ namespace cv
 namespace videostab
 {
 
-struct VideoFileSource::VideoReader
-{
-#ifdef HAVE_OPENCV_HIGHGUI
-    mutable VideoCapture vc;
-#endif
-};
-
-VideoFileSource::VideoFileSource(const string &path, bool volatileFrame)
-    : path_(path), volatileFrame_(volatileFrame), reader_(VideoReader()) { reset(); }
-
+namespace {
 
-void VideoFileSource::reset()
+class VideoFileSourceImpl : public IFrameSource
 {
+public:
+    VideoFileSourceImpl(const std::string &path, bool volatileFrame)
+        : path_(path), volatileFrame_(volatileFrame) { reset(); }
+
+    virtual void reset()
+    {
 #ifdef HAVE_OPENCV_HIGHGUI
-    reader_.vc.release();
-    reader_.vc.open(path_);
-    if (!reader_.vc.isOpened())
-        throw runtime_error("can't open file: " + path_);
+        vc.release();
+        vc.open(path_);
+        if (!vc.isOpened())
+            throw runtime_error("can't open file: " + path_);
 #else
-    CV_Error(CV_StsNotImplemented, "OpenCV has been compiled without video I/O support");
+        CV_Error(CV_StsNotImplemented, "OpenCV has been compiled without video I/O support");
 #endif
-}
-
+    }
 
-Mat VideoFileSource::nextFrame()
-{
-    Mat frame;
+    virtual Mat nextFrame()
+    {
+        Mat frame;
 #ifdef HAVE_OPENCV_HIGHGUI
-    reader_.vc >> frame;
+        vc >> frame;
 #endif
-    return volatileFrame_ ? frame : frame.clone();
-}
+        return volatileFrame_ ? frame : frame.clone();
+    }
 
-int VideoFileSource::width()
-{
 #ifdef HAVE_OPENCV_HIGHGUI
-    return static_cast<int>(reader_.vc.get(CV_CAP_PROP_FRAME_WIDTH));
+    int width() {return static_cast<int>(vc.get(CV_CAP_PROP_FRAME_WIDTH));}
+    int height() {return static_cast<int>(vc.get(CV_CAP_PROP_FRAME_HEIGHT));}
+    int count() {return static_cast<int>(vc.get(CV_CAP_PROP_FRAME_COUNT));}
+    double fps() {return vc.get(CV_CAP_PROP_FPS);}
 #else
-    return 0;
+    int width() {return 0;}
+    int height() {return 0;}
+    int count() {return 0;}
+    double fps() {return 0;}
 #endif
-}
 
-int VideoFileSource::height()
-{
+private:
+    std::string path_;
+    bool volatileFrame_;
 #ifdef HAVE_OPENCV_HIGHGUI
-    return static_cast<int>(reader_.vc.get(CV_CAP_PROP_FRAME_HEIGHT));
-#else
-    return 0;
+    VideoCapture vc;
 #endif
-}
+};
 
-int VideoFileSource::count()
-{
-#ifdef HAVE_OPENCV_HIGHGUI
-    return static_cast<int>(reader_.vc.get(CV_CAP_PROP_FRAME_COUNT));
-#else
-    return 0;
-#endif
-}
+}//namespace
 
-double VideoFileSource::fps()
-{
-#ifdef HAVE_OPENCV_HIGHGUI
-    return reader_.vc.get(CV_CAP_PROP_FPS);
-#else
-    return 0;
-#endif
-}
+VideoFileSource::VideoFileSource(const string &path, bool volatileFrame)
+    : impl(new VideoFileSourceImpl(path, volatileFrame)) {}
+
+void VideoFileSource::reset() { impl->reset(); }
+Mat VideoFileSource::nextFrame() { return impl->nextFrame(); }
+
+int VideoFileSource::width() { return ((VideoFileSourceImpl*)impl.obj)->width(); }
+int VideoFileSource::height() { return ((VideoFileSourceImpl*)impl.obj)->height(); }
+int VideoFileSource::count() { return ((VideoFileSourceImpl*)impl.obj)->count(); }
+double VideoFileSource::fps() { return ((VideoFileSourceImpl*)impl.obj)->fps(); }
 
 } // namespace videostab
 } // namespace cv