public:
FastX(const Parameters &config = Parameters());
- virtual ~FastX(){};
+ virtual ~FastX(){}
void reconfigure(const Parameters ¶);
std::vector<std::vector<float> > calcAngles(const std::vector<cv::Mat> &rotated_images,
std::vector<cv::KeyPoint> &keypoints)const;
// define pure virtual methods
- virtual int descriptorSize()const override{return 0;};
- virtual int descriptorType()const override{return 0;};
+ virtual int descriptorSize()const override{return 0;}
+ virtual int descriptorType()const override{return 0;}
virtual void operator()( cv::InputArray image, cv::InputArray mask, std::vector<cv::KeyPoint>& keypoints, cv::OutputArray descriptors, bool useProvidedKeypoints=false )const
{
descriptors.clear();
*/
void swap(Chessboard::Board &other);
- bool operator==(const Chessboard::Board& other) const {return rows*cols == other.rows*other.cols;};
- bool operator< (const Chessboard::Board& other) const {return rows*cols < other.rows*other.cols;};
- bool operator> (const Chessboard::Board& other) const {return rows*cols > other.rows*other.cols;};
- bool operator>= (const cv::Size& size)const { return rows*cols >= size.width*size.height; };
+ bool operator==(const Chessboard::Board& other) const {return rows*cols == other.rows*other.cols;}
+ bool operator< (const Chessboard::Board& other) const {return rows*cols < other.rows*other.cols;}
+ bool operator> (const Chessboard::Board& other) const {return rows*cols > other.rows*other.cols;}
+ bool operator>= (const cv::Size& size)const { return rows*cols >= size.width*size.height; }
/**
* \brief Returns a specific corner
Chessboard::Board detectImpl(const cv::Mat& image,std::vector<cv::Mat> &feature_maps,const cv::Mat& mask)const;
// define pure virtual methods
- virtual int descriptorSize()const override{return 0;};
- virtual int descriptorType()const override{return 0;};
+ virtual int descriptorSize()const override{return 0;}
+ virtual int descriptorType()const override{return 0;}
virtual void operator()( cv::InputArray image, cv::InputArray mask, std::vector<cv::KeyPoint>& keypoints, cv::OutputArray descriptors, bool useProvidedKeypoints=false )const
{
descriptors.clear();
int estimateModelNonMinimalSample(const std::vector<int> &sample, int sample_size,
std::vector<Mat> &models, const std::vector<double> &weights) const override {
return non_min_solver->estimate (sample, sample_size, models, weights);
- };
+ }
int getMaxNumSolutions () const override {
return min_solver->getMaxNumberOfSolutions();
}
int estimateModelNonMinimalSample(const std::vector<int> &sample, int sample_size,
std::vector<Mat> &models, const std::vector<double> &weights) const override {
return non_min_solver->estimate(sample, sample_size, models, weights);
- };
+ }
int getMaxNumSolutions () const override {
return min_solver->getMaxNumberOfSolutions();
}
class TraceStorage {
public:
TraceStorage() {}
- virtual ~TraceStorage() {};
+ virtual ~TraceStorage() {}
virtual bool put(const TraceMessage& msg) const = 0;
};
#endif
};
return g_backends;
-};
+}
static
bool sortByPriority(const ParallelBackendInfo &lhs, const ParallelBackendInfo &rhs)
_mm256_zeroupper();
}
- virtual ~FAST_t_patternSize16_AVX2_Impl() CV_OVERRIDE {};
+ virtual ~FAST_t_patternSize16_AVX2_Impl() CV_OVERRIDE {}
private:
int cols;
public:
static Ptr<FAST_t_patternSize16_AVX2> getImpl(int _cols, int _threshold, bool _nonmax_suppression, const int* _pixel);
virtual void process(int &j, const uchar* &ptr, uchar* curr, int* cornerpos, int &ncorners) = 0;
- virtual ~FAST_t_patternSize16_AVX2() {};
+ virtual ~FAST_t_patternSize16_AVX2() {}
};
#endif
}
Mat* operator->();
iterator& operator++();
iterator operator++(int);
- friend bool operator== (const iterator& a, const iterator& b) { return a.m_curr == b.m_curr; };
- friend bool operator!= (const iterator& a, const iterator& b) { return a.m_curr != b.m_curr; };
+ friend bool operator== (const iterator& a, const iterator& b) { return a.m_curr == b.m_curr; }
+ friend bool operator!= (const iterator& a, const iterator& b) { return a.m_curr != b.m_curr; }
private:
ImageCollection* m_pCollection;
Mat src(Size(width, height), stype, src_data, src_step);
Mat dst(Size(width, height), dtype, dst_data, dst_step);
f->apply(src, dst, Size(full_width, full_height), Point(offset_x, offset_y));
-};
+}
//===================================================================
// HAL functions
static Ptr<WarpPerspectiveLine_SSE4> getImpl(const double *M);
virtual void processNN(const double *M, short* xy, double X0, double Y0, double W0, int bw) = 0;
virtual void process(const double *M, short* xy, short* alpha, double X0, double Y0, double W0, int bw) = 0;
- virtual ~WarpPerspectiveLine_SSE4() {};
+ virtual ~WarpPerspectiveLine_SSE4() {}
};
#endif
}
(X & (INTER_TAB_SIZE - 1)));
}
}
- virtual ~WarpPerspectiveLine_SSE4_Impl() CV_OVERRIDE {};
+ virtual ~WarpPerspectiveLine_SSE4_Impl() CV_OVERRIDE {}
};
Ptr<WarpPerspectiveLine_SSE4> WarpPerspectiveLine_SSE4::getImpl(const double *M)
static void hlineResizeCn(ET* src, int cn, int *ofst, FT* m, FT* dst, int dst_min, int dst_max, int dst_width)
{
hline<ET, FT, n, mulall, cncnt>::ResizeCn(src, cn, ofst, m, dst, dst_min, dst_max, dst_width);
-};
+}
template <>
void hlineResizeCn<uint8_t, ufixedpoint16, 2, true, 1>(uint8_t* src, int, int *ofst, ufixedpoint16* m, ufixedpoint16* dst, int dst_min, int dst_max, int dst_width)
errStrip[idxErr]=err ;
- };
+ }
ParallelCalcError& operator=(const ParallelCalcError &) {
return *this;
- };
+ }
};
return NPY_U##dst; \
}
-CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(int8_t, INT8);
+CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(int8_t, INT8)
-CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(int16_t, INT16);
+CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(int16_t, INT16)
-CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(int32_t, INT32);
+CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(int32_t, INT32)
-CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(int64_t, INT64);
+CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(int64_t, INT64)
#undef CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION
bool isPythonBindingsDebugEnabled();
void emit_failmsg(PyObject * exc, const char *msg);
int failmsg(const char *fmt, ...);
-PyObject* failmsgp(const char *fmt, ...);;
+PyObject* failmsgp(const char *fmt, ...);
//======================================================================================================================