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)
#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
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;
// 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
}
}
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--; ) {
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);
bool cv::gpu::CascadeClassifier_GPU_LBP::empty() const { throw_nogpu(); return true; }\r
bool cv::gpu::CascadeClassifier_GPU_LBP::load(const string&) { throw_nogpu(); return true; }\r
Size cv::gpu::CascadeClassifier_GPU_LBP::getClassifierSize() const { throw_nogpu(); return Size(); }\r
-void cv::gpu::CascadeClassifier_GPU_LBP::preallocateIntegralBuffer(cv::Size desired) { throw_nogpu();}\r
+void cv::gpu::CascadeClassifier_GPU_LBP::preallocateIntegralBuffer(cv::Size /*desired*/) { throw_nogpu();}\r
\r
int cv::gpu::CascadeClassifier_GPU_LBP::detectMultiScale(const cv::gpu::GpuMat&, cv::gpu::GpuMat&, cv::gpu::GpuMat&, double, int) { throw_nogpu(); return 0; }\r
\r
cv::swap(temp, frame);
}
- mog(loadMat(frame, useRoi), foreground, learningRate);
+ mog(loadMat(frame, useRoi), foreground, (float)learningRate);
mog_gold(frame, foreground_gold, learningRate);
double fps();
private:
- std::string path_;
- bool volatileFrame_;
-
- struct VideoReader;
- const VideoReader& reader_;
+ Ptr<IFrameSource> impl;
};
} // namespace videostab
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
projects / profile / ivi / opencv.git / commitdiff