#include <vector>
-namespace cv
-{
class DetectionBasedTracker
{
public:
cv::Rect calcTrackedObjectPositionToShow(int i, ObjectStatus& status) const;
void detectInRegion(const cv::Mat& img, const cv::Rect& r, std::vector<cv::Rect>& detectedObjectsInRegions);
};
+
+namespace cv
+{
+ typedef ::DetectionBasedTracker DetectionBasedTracker;
+
} //end of cv namespace
#endif
return cv::Rect(x, y, cvRound(width), cvRound(height));
}
-namespace cv
-{
- void* workcycleObjectDetectorFunction(void* p);
-}
+void* workcycleObjectDetectorFunction(void* p);
-class cv::DetectionBasedTracker::SeparateDetectionWork
+class DetectionBasedTracker::SeparateDetectionWork
{
public:
- SeparateDetectionWork(cv::DetectionBasedTracker& _detectionBasedTracker, cv::Ptr<DetectionBasedTracker::IDetector> _detector);
+ SeparateDetectionWork(DetectionBasedTracker& _detectionBasedTracker, cv::Ptr<DetectionBasedTracker::IDetector> _detector);
virtual ~SeparateDetectionWork();
bool communicateWithDetectingThread(const Mat& imageGray, vector<Rect>& rectsWhereRegions);
bool run();
long long timeWhenDetectingThreadStartedWork;
};
-cv::DetectionBasedTracker::SeparateDetectionWork::SeparateDetectionWork(DetectionBasedTracker& _detectionBasedTracker, cv::Ptr<DetectionBasedTracker::IDetector> _detector)
+DetectionBasedTracker::SeparateDetectionWork::SeparateDetectionWork(DetectionBasedTracker& _detectionBasedTracker, cv::Ptr<DetectionBasedTracker::IDetector> _detector)
:detectionBasedTracker(_detectionBasedTracker),
cascadeInThread(),
isObjectDetectingReady(false),
}
}
-cv::DetectionBasedTracker::SeparateDetectionWork::~SeparateDetectionWork()
+DetectionBasedTracker::SeparateDetectionWork::~SeparateDetectionWork()
{
if(stateThread!=STATE_THREAD_STOPPED) {
LOGE("\n\n\nATTENTION!!! dangerous algorithm error: destructor DetectionBasedTracker::DetectionBasedTracker::~SeparateDetectionWork is called before stopping the workthread");
pthread_cond_destroy(&objectDetectorRun);
pthread_mutex_destroy(&mutex);
}
-bool cv::DetectionBasedTracker::SeparateDetectionWork::run()
+bool DetectionBasedTracker::SeparateDetectionWork::run()
{
LOGD("DetectionBasedTracker::SeparateDetectionWork::run() --- start");
pthread_mutex_lock(&mutex);
} while(0)
#endif
-void* cv::workcycleObjectDetectorFunction(void* p)
+void* workcycleObjectDetectorFunction(void* p)
{
- CATCH_ALL_AND_LOG({ ((cv::DetectionBasedTracker::SeparateDetectionWork*)p)->workcycleObjectDetector(); });
+ CATCH_ALL_AND_LOG({ ((DetectionBasedTracker::SeparateDetectionWork*)p)->workcycleObjectDetector(); });
try{
- ((cv::DetectionBasedTracker::SeparateDetectionWork*)p)->stateThread = cv::DetectionBasedTracker::SeparateDetectionWork::STATE_THREAD_STOPPED;
+ ((DetectionBasedTracker::SeparateDetectionWork*)p)->stateThread = DetectionBasedTracker::SeparateDetectionWork::STATE_THREAD_STOPPED;
} catch(...) {
LOGE0("DetectionBasedTracker: workcycleObjectDetectorFunction: ERROR concerning pointer, received as the function parameter");
}
return NULL;
}
-void cv::DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector()
+void DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector()
{
static double freq = getTickFrequency();
LOGD("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector() --- start");
LOGI("DetectionBasedTracker::SeparateDetectionWork::workcycleObjectDetector: Returning");
}
-void cv::DetectionBasedTracker::SeparateDetectionWork::stop()
+void DetectionBasedTracker::SeparateDetectionWork::stop()
{
//FIXME: TODO: should add quickStop functionality
pthread_mutex_lock(&mutex);
pthread_mutex_unlock(&mutex);
}
-void cv::DetectionBasedTracker::SeparateDetectionWork::resetTracking()
+void DetectionBasedTracker::SeparateDetectionWork::resetTracking()
{
LOGD("DetectionBasedTracker::SeparateDetectionWork::resetTracking");
pthread_mutex_lock(&mutex);
}
-bool cv::DetectionBasedTracker::SeparateDetectionWork::communicateWithDetectingThread(const Mat& imageGray, vector<Rect>& rectsWhereRegions)
+bool DetectionBasedTracker::SeparateDetectionWork::communicateWithDetectingThread(const Mat& imageGray, vector<Rect>& rectsWhereRegions)
{
static double freq = getTickFrequency();
return shouldHandleResult;
}
-cv::DetectionBasedTracker::Parameters::Parameters()
+DetectionBasedTracker::Parameters::Parameters()
{
maxTrackLifetime=5;
minDetectionPeriod=0;
}
-cv::DetectionBasedTracker::InnerParameters::InnerParameters()
+DetectionBasedTracker::InnerParameters::InnerParameters()
{
numLastPositionsToTrack=4;
numStepsToWaitBeforeFirstShow=6;
}
-cv::DetectionBasedTracker::DetectionBasedTracker(cv::Ptr<IDetector> mainDetector, cv::Ptr<IDetector> trackingDetector, const Parameters& params)
+DetectionBasedTracker::DetectionBasedTracker(cv::Ptr<IDetector> mainDetector, cv::Ptr<IDetector> trackingDetector, const Parameters& params)
:separateDetectionWork(),
parameters(params),
innerParameters(),
weightsSizesSmoothing.push_back(0.2);
}
-cv::DetectionBasedTracker::~DetectionBasedTracker()
+DetectionBasedTracker::~DetectionBasedTracker()
{
}
updateTrackedObjects(detectedObjectsInRegions);
}
-void cv::DetectionBasedTracker::getObjects(std::vector<cv::Rect>& result) const
+void DetectionBasedTracker::getObjects(std::vector<cv::Rect>& result) const
{
result.clear();
}
}
-void cv::DetectionBasedTracker::getObjects(std::vector<Object>& result) const
+void DetectionBasedTracker::getObjects(std::vector<Object>& result) const
{
result.clear();
LOGD("DetectionBasedTracker::process: found a object with SIZE %d x %d, rect={%d, %d, %d x %d}", r.width, r.height, r.x, r.y, r.width, r.height);
}
}
-void cv::DetectionBasedTracker::getObjects(std::vector<ExtObject>& result) const
+void DetectionBasedTracker::getObjects(std::vector<ExtObject>& result) const
{
result.clear();
}
}
-bool cv::DetectionBasedTracker::run()
+bool DetectionBasedTracker::run()
{
if (!separateDetectionWork.empty()) {
return separateDetectionWork->run();
return false;
}
-void cv::DetectionBasedTracker::stop()
+void DetectionBasedTracker::stop()
{
if (!separateDetectionWork.empty()) {
separateDetectionWork->stop();
}
}
-void cv::DetectionBasedTracker::resetTracking()
+void DetectionBasedTracker::resetTracking()
{
if (!separateDetectionWork.empty()) {
separateDetectionWork->resetTracking();
trackedObjects.clear();
}
-void cv::DetectionBasedTracker::updateTrackedObjects(const vector<Rect>& detectedObjects)
+void DetectionBasedTracker::updateTrackedObjects(const vector<Rect>& detectedObjects)
{
enum {
NEW_RECTANGLE=-1,
}
}
-int cv::DetectionBasedTracker::addObject(const Rect& location)
+int DetectionBasedTracker::addObject(const Rect& location)
{
LOGD("DetectionBasedTracker::addObject: new object {%d, %d %dx%d}",location.x, location.y, location.width, location.height);
trackedObjects.push_back(TrackedObject(location));
return newId;
}
-Rect cv::DetectionBasedTracker::calcTrackedObjectPositionToShow(int i) const
+Rect DetectionBasedTracker::calcTrackedObjectPositionToShow(int i) const
{
ObjectStatus status;
return calcTrackedObjectPositionToShow(i, status);
}
-Rect cv::DetectionBasedTracker::calcTrackedObjectPositionToShow(int i, ObjectStatus& status) const
+Rect DetectionBasedTracker::calcTrackedObjectPositionToShow(int i, ObjectStatus& status) const
{
if ( (i < 0) || (i >= (int)trackedObjects.size()) ) {
LOGE("DetectionBasedTracker::calcTrackedObjectPositionToShow: ERROR: wrong i=%d", i);
return res;
}
-void cv::DetectionBasedTracker::detectInRegion(const Mat& img, const Rect& r, vector<Rect>& detectedObjectsInRegions)
+void DetectionBasedTracker::detectInRegion(const Mat& img, const Rect& r, vector<Rect>& detectedObjectsInRegions)
{
Rect r0(Point(), img.size());
Rect r1 = scale_rect(r, innerParameters.coeffTrackingWindowSize);
}
}
-bool cv::DetectionBasedTracker::setParameters(const Parameters& params)
+bool DetectionBasedTracker::setParameters(const Parameters& params)
{
if ( params.maxTrackLifetime < 0 )
{
return true;
}
-const cv::DetectionBasedTracker::Parameters& DetectionBasedTracker::getParameters() const
+const DetectionBasedTracker::Parameters& DetectionBasedTracker::getParameters() const
{
return parameters;
}
//! makes multi-channel array out of several single-channel arrays
CV_EXPORTS void merge(const Mat* mv, size_t count, OutputArray dst);
+CV_EXPORTS void merge(const vector<Mat>& mv, OutputArray dst );
+
//! makes multi-channel array out of several single-channel arrays
CV_EXPORTS_W void merge(InputArrayOfArrays mv, OutputArray dst);
//! copies each plane of a multi-channel array to a dedicated array
CV_EXPORTS void split(const Mat& src, Mat* mvbegin);
+CV_EXPORTS void split(const Mat& src, vector<Mat>& mv );
+
//! copies each plane of a multi-channel array to a dedicated array
CV_EXPORTS_W void split(InputArray m, OutputArrayOfArrays mv);
Point offset=Point() );
//! draws one or more polygonal curves
-CV_EXPORTS void polylines(Mat& img, const Point* const* pts, const int* npts,
+CV_EXPORTS void polylines(Mat& img, const Point** pts, const int* npts,
int ncontours, bool isClosed, const Scalar& color,
int thickness=1, int lineType=8, int shift=0 );
//! closes the file and releases all the memory buffers
CV_WRAP virtual void release();
//! closes the file, releases all the memory buffers and returns the text string
- CV_WRAP virtual string releaseAndGetString();
+ CV_WRAP string releaseAndGetString();
//! returns the first element of the top-level mapping
CV_WRAP FileNode getFirstTopLevelNode() const;
class CV_EXPORTS CommandLineParser
{
public:
+ CommandLineParser(int argc, const char* const argv[], const char* keys);
CommandLineParser(int argc, const char* const argv[], const string& keys);
CommandLineParser(const CommandLineParser& parser);
CommandLineParser& operator = (const CommandLineParser& parser);
getByIndex(index, space_delete, ParamType<T>::type, (void*)&val);
return val;
}
-
- bool has(const string& name) const;
-
+
+ bool has(const string& name);
bool check() const;
void about(const string& message);
void printMessage() const;
void printErrors() const;
+ void printParams();
protected:
+ string getString(const string& name);
void getByName(const string& name, bool space_delete, int type, void* dst) const;
void getByIndex(int index, bool space_delete, int type, void* dst) const;
\r
static Ptr<GlFont> get(const std::string& family, int height = 12, Weight weight = WEIGHT_NORMAL, Style style = STYLE_NORMAL);\r
\r
- void draw(const char* str, size_t len) const;\r
+ void draw(const char* str, int len) const;\r
\r
inline const std::string& family() const { return family_; }\r
inline int height() const { return height_; }\r
\r
vector<CommandLineParserParams> data;\r
\r
+ Impl() { refcount = 1; }\r
+ Impl(int argc, const char* const argv[], const char* keys);\r
+ \r
vector<string> split_range_string(const string& str, char fs, char ss) const;\r
vector<string> split_string(const string& str, char symbol = ' ', bool create_empty_item = false) const;\r
- string cat_string(const string& str) const;\r
+ string trim_spaces(const string& str) const;\r
\r
void apply_params(const string& key, const string& value);\r
void apply_params(int i, string value);\r
}\r
}\r
\r
-void CommandLineParser::getByName(const string& name, bool space_delete, int type, void* dst) const\r
+string CommandLineParser::getString(const string& name)\r
{\r
- try\r
+ for (size_t i = 0; i < impl->data.size(); i++)\r
{\r
- for (size_t i = 0; i < impl->data.size(); i++)\r
+ for (size_t j = 0; j < impl->data[i].keys.size(); j++)\r
{\r
- for (size_t j = 0; j < impl->data[i].keys.size(); j++)\r
+ if (name.compare(impl->data[i].keys[j]) == 0)\r
{\r
- if (name.compare(impl->data[i].keys[j]) == 0)\r
- {\r
- string v = impl->data[i].def_value;\r
- if (space_delete)\r
- v = impl->cat_string(v);\r
- from_str(v, type, dst);\r
- return;\r
- }\r
+ string v = impl->data[i].def_value;\r
+ return v;\r
}\r
}\r
- impl->error = true;\r
- impl->error_message += "Unknown parametes " + name + "\n";\r
+ }\r
+ return string();\r
+}\r
+ \r
+void CommandLineParser::getByName(const string& name, bool space_delete, int type, void* dst) const\r
+{\r
+ try\r
+ {\r
+ string v = ((CommandLineParser*)this)->getString(name);\r
+ if( v.empty() )\r
+ {\r
+ impl->error = true;\r
+ impl->error_message += "Unknown parametes " + name + "\n";\r
+ }\r
+ else\r
+ {\r
+ if (space_delete)\r
+ v = impl->trim_spaces(v);\r
+ from_str(v, type, dst);\r
+ return;\r
+ }\r
}\r
catch (std::exception& e)\r
{\r
if (impl->data[i].number == index)\r
{\r
string v = impl->data[i].def_value;\r
- if (space_delete == true) v = impl->cat_string(v);\r
+ if (space_delete == true) v = impl->trim_spaces(v);\r
from_str(v, type, dst);\r
return;\r
}\r
\r
CommandLineParser::CommandLineParser(int argc, const char* const argv[], const string& keys)\r
{\r
- impl = new Impl;\r
- impl->refcount = 1;\r
+ impl = new Impl(argc, argv, keys.c_str());\r
+}\r
+\r
+CommandLineParser::CommandLineParser(int argc, const char* const argv[], const char* keys)\r
+{\r
+ impl = new Impl(argc, argv, keys);\r
+}\r
+ \r
+CommandLineParser::Impl::Impl(int argc, const char* const argv[], const char* keys)\r
+{\r
+ refcount = 1;\r
\r
// path to application\r
size_t pos_s = string(argv[0]).find_last_of("/\\");\r
if (pos_s == string::npos)\r
{\r
- impl->path_to_app = "";\r
- impl->app_name = string(argv[0]);\r
+ path_to_app = "";\r
+ app_name = string(argv[0]);\r
}\r
else\r
{\r
- impl->path_to_app = string(argv[0]).substr(0, pos_s);\r
- impl->app_name = string(argv[0]).substr(pos_s + 1, string(argv[0]).length() - pos_s);\r
+ path_to_app = string(argv[0]).substr(0, pos_s);\r
+ app_name = string(argv[0]).substr(pos_s + 1, string(argv[0]).length() - pos_s);\r
}\r
\r
- impl->error = false;\r
- impl->error_message = "";\r
+ error = false;\r
+ error_message = "";\r
\r
// parse keys\r
- vector<string> k = impl->split_range_string(keys, '{', '}');\r
+ vector<string> k = split_range_string(keys, '{', '}');\r
\r
int jj = 0;\r
for (size_t i = 0; i < k.size(); i++)\r
{\r
- vector<string> l = impl->split_string(k[i], '|', true);\r
+ vector<string> l = split_string(k[i], '|', true);\r
CommandLineParserParams p;\r
- p.keys = impl->split_string(l[0]);\r
+ p.keys = split_string(l[0]);\r
p.def_value = l[1];\r
- p.help_message = impl->cat_string(l[2]);\r
+ p.help_message = trim_spaces(l[2]);\r
p.number = -1;\r
if (p.keys[0][0] == '@')\r
{\r
jj++;\r
}\r
\r
- impl->data.push_back(p);\r
+ data.push_back(p);\r
}\r
\r
// parse argv\r
\r
if (s.find('=') != string::npos && s.find('=') < s.length())\r
{\r
- vector<string> k_v = impl->split_string(s, '=', true);\r
+ vector<string> k_v = split_string(s, '=', true);\r
for (int h = 0; h < 2; h++)\r
{\r
if (k_v[0][0] == '-')\r
k_v[0] = k_v[0].substr(1, k_v[0].length() -1);\r
}\r
- impl->apply_params(k_v[0], k_v[1]);\r
+ apply_params(k_v[0], k_v[1]);\r
}\r
else if (s.length() > 1 && s[0] == '-')\r
{\r
if (s[0] == '-')\r
s = s.substr(1, s.length() - 1);\r
}\r
- impl->apply_params(s, "true");\r
+ apply_params(s, "true");\r
}\r
else if (s[0] != '-')\r
{\r
- impl->apply_params(jj, s);\r
+ apply_params(jj, s);\r
jj++;\r
}\r
}\r
\r
- impl->sort_params();\r
+ sort_params();\r
}\r
\r
\r
sort (data.begin(), data.end(), cmp_params);\r
}\r
\r
-string CommandLineParser::Impl::cat_string(const string& str) const\r
+string CommandLineParser::Impl::trim_spaces(const string& str) const\r
{\r
int left = 0, right = (int)str.length();\r
while( left <= right && str[left] == ' ' )\r
return impl->path_to_app;\r
}\r
\r
-bool CommandLineParser::has(const string& name) const\r
+bool CommandLineParser::has(const string& name)\r
{\r
for (size_t i = 0; i < impl->data.size(); i++)\r
{\r
}\r
}\r
\r
+void CommandLineParser::printParams()\r
+{\r
+ printMessage();\r
+}\r
+ \r
void CommandLineParser::printMessage() const\r
{\r
if (impl->about_message != "")\r
std::cout << ", ";\r
}\r
}\r
- string dv = impl->cat_string(impl->data[i].def_value);\r
+ string dv = impl->trim_spaces(impl->data[i].def_value);\r
if (dv.compare("") != 0)\r
{\r
std::cout << " (value:" << dv << ")";\r
\r
std::cout << k;\r
\r
- string dv = impl->cat_string(impl->data[i].def_value);\r
+ string dv = impl->trim_spaces(impl->data[i].def_value);\r
if (dv.compare("") != 0)\r
{\r
std::cout << " (value:" << dv << ")";\r
split(m, dst);
}
+void cv::split(const Mat& src, vector<Mat>& mv)
+{
+ split(_InputArray(src), _OutputArray(mv));
+}
+
void cv::merge(const Mat* mv, size_t n, OutputArray _dst)
{
CV_Assert( mv && n > 0 );
merge(!mv.empty() ? &mv[0] : 0, mv.size(), _dst);
}
+void cv::merge(const vector<Mat>& _mv, OutputArray _dst)
+{
+ merge(_InputArray(_mv), _dst);
+}
+
/****************************************************************************************\
* Generalized split/merge: mixing channels *
\****************************************************************************************/
}
-void polylines( Mat& img, const Point* const* pts, const int* npts, int ncontours, bool isClosed,
+void polylines( Mat& img, const Point** pts, const int* npts, int ncontours, bool isClosed,
const Scalar& color, int thickness, int line_type, int shift )
{
if( line_type == CV_AA && img.depth() != CV_8U )
#endif\r
}\r
\r
-void cv::GlFont::draw(const char* str, size_t len) const\r
+void cv::GlFont::draw(const char* str, int len) const\r
{\r
#ifndef HAVE_OPENGL\r
(void)str;\r
\r
glRasterPos2d(2.0 * (viewport[0] + pos.x) / viewport[2] - 1.0, 1.0 - 2.0 * (viewport[1] + pos.y + font->height()) / viewport[3]);\r
\r
- font->draw(str.c_str(), str.length());\r
+ font->draw(str.c_str(), (int)str.length());\r
\r
glPopAttrib();\r
#endif\r
//! computes PSNR image/video quality metric
CV_EXPORTS_W double PSNR(InputArray src1, InputArray src2);
+CV_EXPORTS Point2d phaseCorrelate(InputArray src1, InputArray src2,
+ InputArray window = noArray());
CV_EXPORTS_W Point2d phaseCorrelate(InputArray src1, InputArray src2,
- InputArray window = noArray(), CV_OUT double* response=0);
+ InputArray window, CV_OUT double* response CV_WRAP_DEFAULT(0));
CV_EXPORTS_W void createHanningWindow(OutputArray dst, Size winSize, int type);
//! type of the threshold operation
return (center - t);
}
+cv::Point2d cv::phaseCorrelate(InputArray _src1, InputArray _src2, InputArray _window)
+{
+ return phaseCorrelate(_src1, _src2, _window, 0);
+}
void cv::createHanningWindow(OutputArray _dst, cv::Size winSize, int type)
{
virtual void setRadius(int val) { radius_ = val; }
virtual int radius() const { return radius_; }
- virtual void deblur(int idx, Mat &frame) = 0;
-
-
// data from stabilizer
virtual void setFrames(const std::vector<Mat> &val) { frames_ = &val; }
virtual void setBlurrinessRates(const std::vector<float> &val) { blurrinessRates_ = &val; }
virtual const std::vector<float>& blurrinessRates() const { return *blurrinessRates_; }
+ virtual void update() {}
+ virtual void deblur(int idx, Mat &frame) = 0;
+
protected:
int radius_;
const std::vector<Mat> *frames_;