Changeset 338 in flair-src for trunk/lib/FlairVisionFilter/src/OpticalFlowData.cpp

Timestamp:

Oct 17, 2019, 2:49:35 PM (5 years ago)

Author:

Sanahuja Guillaume

Message:

remove opencv dep

Location:

trunk

Files:

• . (modified) (1 prop)
• lib/FlairVisionFilter/src/OpticalFlowData.cpp (modified) (1 diff)

trunk/lib/FlairVisionFilter/src/OpticalFlowData.cpp

@@ -12 +12 @@
 
 #include "OpticalFlowData.h"
+#include "VisionFilter.h"
+#include <string.h>
 
 using std::string;
 
-namespace flair
-{
-namespace filter
-{
+class OpticalFlowData_impl {
+public:
+    OpticalFlowData_impl(flair::filter::OpticalFlowData* self,uint32_t max_features) {
+        this->self=self;
+        this->max_features=max_features;
+        nb_features=0;
+        pointsA=(IntPoint*)malloc(max_features*sizeof(IntPoint));
+        pointsB=(FloatPoint*)malloc(max_features*sizeof(FloatPoint));
 
-OpticalFlowData::OpticalFlowData(const Object* parent,uint32_t max_features,string name,uint32_t n): io_data(parent,name,n)
-{
-    this->max_features=max_features;
-    nb_features=0;
+        found_features=(char*)malloc(max_features*sizeof(char));
+        features_error=(uint32_t*)malloc(max_features*sizeof(uint32_t));
+    }
 
-    pointsA=(CvPoint *)cvAlloc(max_features*sizeof(CvPoint));
-    pointsB=(CvPoint2D32f *)cvAlloc(max_features*sizeof(CvPoint2D32f));
+    ~OpticalFlowData_impl() {
+        free((char*)pointsA);
+        free((char*)pointsB);
 
-    found_features=(char *)cvAlloc(max_features*sizeof(char));
-    features_error=(uint32_t*)cvAlloc(max_features*sizeof(uint32_t));
+        free((char*)found_features);
+        free((char*)features_error);
+    }
+    
+    void Resize(uint32_t value) {
+        IntPoint *new_pointsA;
+        FloatPoint *new_pointsB;
+        char *new_found_features;
+        uint32_t *new_features_error;
+
+        new_pointsA=(IntPoint*)malloc(value*sizeof(IntPoint));
+        new_pointsB=(FloatPoint*)malloc(value*sizeof(FloatPoint));
+        new_found_features=(char*)malloc(value*sizeof(char));
+        new_features_error=(uint32_t*)malloc(value*sizeof(uint32_t));
+
+        self->GetMutex();
+        if(value>max_features) {
+            memcpy(new_pointsA,pointsA,max_features*sizeof(IntPoint));
+            memcpy(new_pointsB,pointsB,max_features*sizeof(FloatPoint));
+            memcpy(new_found_features,found_features,max_features*sizeof(char));
+            memcpy(new_features_error,features_error,max_features*sizeof(uint32_t));
+        } else {
+            memcpy(new_pointsA,pointsA,value*sizeof(IntPoint));
+            memcpy(new_pointsB,pointsB,value*sizeof(FloatPoint));
+            memcpy(new_found_features,found_features,value*sizeof(char));
+            memcpy(new_features_error,features_error,value*sizeof(uint32_t));
+            if(nb_features>value) nb_features=value; //si nb_features est le nombre de point qui ont effectivement une correspondande, ça me parait louche. Sauf si les points sont classés et que ceux qui ont une correpondance sont toujours au début
+        }
+        max_features=value;
+        self->ReleaseMutex();
+
+        free((char*)pointsA);
+        free((char*)pointsB);
+        free((char*)found_features);
+        free((char*)features_error);
+
+        pointsA=new_pointsA;
+        pointsB=new_pointsB;
+        found_features=new_found_features;
+        features_error=new_features_error;
+    }
+        
+    uint32_t max_features;
+    uint32_t nb_features;
+    IntPoint* pointsA;
+    FloatPoint* pointsB;
+    char *found_features;
+    uint32_t *features_error;
+
+private:
+    flair::filter::OpticalFlowData *self;
+};
+
+namespace flair {
+namespace filter {
+
+OpticalFlowData::OpticalFlowData(const Object* parent,uint32_t max_features,string name,uint32_t n): io_data(parent,name,n) {
+    pimpl_=new OpticalFlowData_impl(this,max_features);
 }
 
-OpticalFlowData::~OpticalFlowData()
-{
-    cvFree(&pointsA);
-    cvFree(&pointsB);
-
-    cvFree(&found_features);
-    cvFree(&features_error);
+OpticalFlowData::~OpticalFlowData() {
+    delete pimpl_;
 }
 
-CvPoint* OpticalFlowData::PointsA(void) const
-{
-    return pointsA;
+IntPoint* OpticalFlowData::PointsA(void) const {
+    return pimpl_->pointsA;
 }
 
-CvPoint2D32f* OpticalFlowData::PointsB(void) const
-{
-    return pointsB;
+FloatPoint* OpticalFlowData::PointsB(void) const {
+    return pimpl_->pointsB;
 }
 
-char *OpticalFlowData::FoundFeature(void) const
-{
-    return found_features;
+char *OpticalFlowData::FoundFeature(void) const {
+    return pimpl_->found_features;
 }
 
-uint32_t *OpticalFlowData::FeatureError(void) const
-{
-    return features_error;
+uint32_t *OpticalFlowData::FeatureError(void) const {
+    return pimpl_->features_error;
 }
 
 // value is new max_features value
 void OpticalFlowData::Resize(uint32_t value) {
-    CvPoint *new_pointsA;
-    CvPoint2D32f *new_pointsB;
-    char *new_found_features;
-    uint32_t *new_features_error;
-
-    new_pointsA=(CvPoint *)cvAlloc(value*sizeof(CvPoint));
-    new_pointsB=(CvPoint2D32f *)cvAlloc(value*sizeof(CvPoint2D32f));
-    new_found_features=(char *)cvAlloc(value*sizeof(char));
-    new_features_error=(uint32_t *)cvAlloc(value*sizeof(uint32_t));
-
-    GetMutex();
-    if(value>max_features)
-    {
-        memcpy(new_pointsA,pointsA,max_features*sizeof(CvPoint));
-        memcpy(new_pointsB,pointsB,max_features*sizeof(CvPoint2D32f));
-        memcpy(new_found_features,found_features,max_features*sizeof(char));
-        memcpy(new_features_error,features_error,max_features*sizeof(uint32_t));
-    }
-    else
-    {
-        memcpy(new_pointsA,pointsA,value*sizeof(CvPoint));
-        memcpy(new_pointsB,pointsB,value*sizeof(CvPoint2D32f));
-        memcpy(new_found_features,found_features,value*sizeof(char));
-        memcpy(new_features_error,features_error,value*sizeof(uint32_t));
-        if(nb_features>value) nb_features=value; //si nb_features est le nombre de point qui ont effectivement une correspondande, ça me parait louche. Sauf si les points sont classés et que ceux qui ont une correpondance sont toujours au début
-    }
-    max_features=value;
-    ReleaseMutex();
-
-    cvFree(&pointsA);
-    cvFree(&pointsB);
-    cvFree(&found_features);
-    cvFree(&features_error);
-
-    pointsA=new_pointsA;
-    pointsB=new_pointsB;
-    found_features=new_found_features;
-    features_error=new_features_error;
+    pimpl_->Resize(value);
 }
 
-void OpticalFlowData::RawRead(char* dst) const
-{
+void OpticalFlowData::RawRead(char* dst) const {
     Warn("non implementé\n");
 }
 
-void OpticalFlowData::SetPointsA(const CvPoint* points)
-{
+void OpticalFlowData::SetPointsA(const IntPoint* points) {
     GetMutex();
-    memcpy(pointsA,points,max_features*sizeof(CvPoint));
+    memcpy(pimpl_->pointsA,points,pimpl_->max_features*sizeof(IntPoint));
     ReleaseMutex();
 }
 
-void OpticalFlowData::SetPointsB(const CvPoint2D32f* points)
-{
+void OpticalFlowData::SetPointsB(const FloatPoint* points) {
     GetMutex();
-    memcpy(pointsB,points,max_features*sizeof(CvPoint2D32f));
+    memcpy(pimpl_->pointsB,points,pimpl_->max_features*sizeof(FloatPoint));
     ReleaseMutex();
 }
 
-void OpticalFlowData::SetFoundFeature(const char *found_features)
-{
+void OpticalFlowData::SetFoundFeature(const char *found_features) {
     GetMutex();
-    memcpy(this->found_features,found_features,max_features*sizeof(char));
+    memcpy(pimpl_->found_features,found_features,pimpl_->max_features*sizeof(char));
     ReleaseMutex();
 }
 
-void OpticalFlowData::SetFeatureError(const uint32_t *features_error)
-{
+void OpticalFlowData::SetFeatureError(const uint32_t *features_error) {
     GetMutex();
-    memcpy(this->features_error,features_error,max_features*sizeof(uint32_t));
+    memcpy(pimpl_->features_error,features_error,pimpl_->max_features*sizeof(uint32_t));
     ReleaseMutex();
 }
 
-uint32_t OpticalFlowData::MaxFeatures(void) const
-{
-    return max_features;
+uint32_t OpticalFlowData::MaxFeatures(void) const {
+    return pimpl_->max_features;
 }
 
-uint32_t OpticalFlowData::NbFeatures(void) const
-{
-    return nb_features;
+uint32_t OpticalFlowData::NbFeatures(void) const {
+    return pimpl_->nb_features;
 }
 
-void OpticalFlowData::SetNbFeatures(uint32_t value)
-{
+void OpticalFlowData::SetNbFeatures(uint32_t value) {
     GetMutex();
-    nb_features=value;
+    pimpl_->nb_features=value;
     ReleaseMutex();
 }