Changeset 338 in flair-src for trunk

Timestamp:

10/17/19 14:49:35 (5 years ago)

Author:

Sanahuja Guillaume

Message:

remove opencv dep

Location:

trunk

Files:

• . (modified) (1 prop)
• cmake-modules/FlairUseFile.cmake (modified) (2 diffs)
• demos/OpticalFlow/uav/src/DemoOpticalFlow.cpp (modified) (4 diffs)
• demos/OpticalFlow/uav/src/DemoOpticalFlow.h (modified) (1 diff)
• lib/FlairCore/src/Image.cpp (copied) (copied from branches/sanscv/lib/FlairCore/src/Image.cpp )
• lib/FlairCore/src/Image.h (copied) (copied from branches/sanscv/lib/FlairCore/src/Image.h )
• lib/FlairCore/src/Picture.cpp (modified) (2 diffs)
• lib/FlairCore/src/Picture.h (modified) (3 diffs)
• lib/FlairCore/src/cvimage.cpp (deleted)
• lib/FlairCore/src/cvimage.h (deleted)
• lib/FlairSensorActuator/CMakeLists.txt (modified) (1 diff)
• lib/FlairSensorActuator/src/Camera.cpp (modified) (9 diffs)
• lib/FlairSensorActuator/src/Camera.h (modified) (5 diffs)
• lib/FlairSensorActuator/src/Ps3Eye.cpp (modified) (1 diff)
• lib/FlairSensorActuator/src/SimulatedCamera.cpp (modified) (1 diff)
• lib/FlairSensorActuator/src/V4LCamera.cpp (modified) (9 diffs)
• lib/FlairSensorActuator/src/V4LCamera.h (modified) (3 diffs)
• lib/FlairVisionFilter/CMakeLists.txt (modified) (1 diff)
• lib/FlairVisionFilter/src/CvtColor.cpp (modified) (3 diffs)
• lib/FlairVisionFilter/src/CvtColor.h (modified) (3 diffs)
• lib/FlairVisionFilter/src/HoughLines.cpp (modified) (4 diffs)
• lib/FlairVisionFilter/src/HoughLines.h (modified) (3 diffs)
• lib/FlairVisionFilter/src/ImgThreshold.cpp (modified) (2 diffs)
• lib/FlairVisionFilter/src/ImgThreshold.h (modified) (3 diffs)
• lib/FlairVisionFilter/src/OpticalFlow.cpp (modified) (3 diffs)
• lib/FlairVisionFilter/src/OpticalFlow.h (modified) (2 diffs)
• lib/FlairVisionFilter/src/OpticalFlowCompensated.cpp (modified) (1 diff)
• lib/FlairVisionFilter/src/OpticalFlowCompensated.h (modified) (2 diffs)
• lib/FlairVisionFilter/src/OpticalFlowData.cpp (modified) (1 diff)
• lib/FlairVisionFilter/src/OpticalFlowData.h (modified) (6 diffs)
• lib/FlairVisionFilter/src/OpticalFlowSpeed.cpp (modified) (1 diff)
• lib/FlairVisionFilter/src/OpticalFlowSpeed.h (modified) (2 diffs)
• lib/FlairVisionFilter/src/Sobel.cpp (modified) (2 diffs)
• lib/FlairVisionFilter/src/Sobel.h (modified) (3 diffs)
• lib/FlairVisionFilter/src/VisionFilter.cpp (modified) (3 diffs)
• lib/FlairVisionFilter/src/VisionFilter.h (modified) (2 diffs)

trunk/cmake-modules/FlairUseFile.cmake

@@ -26 +26 @@
 
 SET(FLAIR_INCLUDE_DIR   
-#       ${LIBXML2_INCLUDE_DIR}  
-        ${CMAKE_SYSROOT}/usr/include/opencv1
         $ENV{FLAIR_ROOT}/flair-install/include/FlairCore
 )
@@ -36 +34 @@
 SET(FLAIR_LIBRARIES     
         ${LIBXML2_LIBRARIES}
-        udt pthread cv cxcore highgui FileLib rt z
+        udt pthread FileLib rt z
 )
 

trunk/demos/OpticalFlow/uav/src/DemoOpticalFlow.cpp

@@ -47 +47 @@
 
 DemoOpticalFlow::DemoOpticalFlow(TargetController *controller): UavStateMachine(controller) {
-  Uav* uav=GetUav();
+    Uav* uav=GetUav();
         if (uav->GetVerticalCamera() == NULL) {
                                 Err("no vertical camera found\n");
@@ -57 +57 @@
         greyCameraImage=new CvtColor(uav->GetVerticalCamera(),"gray",CvtColor::Conversion_t::ToGray);
 
-        uav->GetVerticalCamera()->UseDefaultPlot(greyCameraImage->Output()); // Le defaultPlot de la caméra peut afficher n'importe quoi?
+        uav->GetVerticalCamera()->UseDefaultPlot(greyCameraImage->Output());
 
         //optical flow stack
@@ -77 +77 @@
   DataPlot1D* xVelocityPlot=new DataPlot1D(opticalFlowTab->NewRow(),"x speed (px/s)",-250,250);
   DataPlot1D* yVelocityPlot=new DataPlot1D(opticalFlowTab->LastRowLastCol(),"y speed (px/s)",-250,250);
-  DataPlot1D* xFirstPointPlot=new DataPlot1D(opticalFlowTab->NewRow(),"x movement first point",-25,25);
-  DataPlot1D* yFirstPointPlot=new DataPlot1D(opticalFlowTab->LastRowLastCol(),"y movement first point",-25,25);
-//  DataPlot1D* xAccelerationPlot=new DataPlot1D(opticalFlowTab->NewRow(),"x_acceleration",-250,250);
-//  DataPlot1D* yAccelerationPlot=new DataPlot1D(opticalFlowTab->LastRowLastCol(),"y_acceleration",-250,250);
-
+  
   xVelocityPlot->AddCurve(opticalFlowSpeedRaw->Output()->Element(0,0));
   xVelocityPlot->AddCurve(opticalFlowSpeed->GetMatrix()->Element(0,0),DataPlot::Blue);
   yVelocityPlot->AddCurve(opticalFlowSpeedRaw->Output()->Element(1,0));
   yVelocityPlot->AddCurve(opticalFlowSpeed->GetMatrix()->Element(1,0),DataPlot::Blue);
-  xFirstPointPlot->AddCurve(opticalFlowCompensated->GetFirstPointDisplacement()->Element(0,0));
-  xFirstPointPlot->AddCurve(opticalFlowCompensated->GetFirstPointDisplacement()->Element(1,0),DataPlot::Blue);
-  xFirstPointPlot->AddCurve(opticalFlowCompensated->GetFirstPointDisplacement()->Element(2,0),DataPlot::Green);
-  yFirstPointPlot->AddCurve(opticalFlowCompensated->GetFirstPointDisplacement()->Element(0,1));
-  yFirstPointPlot->AddCurve(opticalFlowCompensated->GetFirstPointDisplacement()->Element(1,1),DataPlot::Blue);
-  yFirstPointPlot->AddCurve(opticalFlowCompensated->GetFirstPointDisplacement()->Element(2,1),DataPlot::Green);
-//  xAccelerationPlot->AddCurve(opticalFlowAccelerationRaw->Matrix()->Element(0,0));
-//  xAccelerationPlot->AddCurve(opticalFlowAcceleration->Matrix()->Element(0,0),DataPlot::Blue);
-//  yAccelerationPlot->AddCurve(opticalFlowAccelerationRaw->Matrix()->Element(1,0));
-//  yAccelerationPlot->AddCurve(opticalFlowAcceleration->Matrix()->Element(1,0),DataPlot::Blue);
-
+  
   u_x=new Pid(setupLawTab->At(1,0),"u_x");
   u_x->UseDefaultPlot(graphLawTab->NewRow());
@@ -129 +115 @@
 
 void DemoOpticalFlow::SignalEvent(Event_t event) {
+    UavStateMachine::SignalEvent(event);
     switch(event) {
     case Event_t::EnteringControlLoop:

trunk/demos/OpticalFlow/uav/src/DemoOpticalFlow.h

@@ -66 +66 @@
         flair::filter::OpticalFlowSpeed *opticalFlowSpeedRaw;
         flair::filter::EulerDerivative *opticalFlowAccelerationRaw;
-    flair::gui::PushButton *startOpticalflow,*stopOpticalflow;
-    void StartOpticalFlow(void);
+        flair::gui::PushButton *startOpticalflow,*stopOpticalflow;
+        void StartOpticalFlow(void);
         flair::filter::LowPassFilter* opticalFlowSpeed;
         flair::filter::LowPassFilter* opticalFlowAcceleration;

trunk/lib/FlairCore/src/Picture.cpp

@@ -17 +17 @@
 
 #include "Picture.h"
-#include "cvimage.h"
+#include "Image.h"
 #include "Layout.h"
 #include "LayoutPosition.h"
@@ -30 +30 @@
 
 Picture::Picture(const LayoutPosition *position, string name,
-                 const cvimage *image)
+                 const Image *image)
     : SendData(position, name, "Picture", 200) {
   this->image = image;

trunk/lib/FlairCore/src/Picture.h

@@ -18 +18 @@
 namespace flair {
 namespace core {
-class cvimage;
+class Image;
 }
 
@@ -45 +45 @@
   */
   Picture(const LayoutPosition *position, std::string name,
-          const core::cvimage *image);
+          const core::Image *image);
 
   /*!
@@ -70 +70 @@
   void ExtraXmlEvent(void){};
 
-  const core::cvimage *image;
+  const core::Image *image;
 };
 

trunk/lib/FlairSensorActuator/CMakeLists.txt

@@ -8 +8 @@
         ${CMAKE_CURRENT_SOURCE_DIR}/../FlairCore/src
         ${CMAKE_CURRENT_SOURCE_DIR}/../FlairVisionFilter/src
-        ${CMAKE_SYSROOT}/usr/include/opencv1
         ${CMAKE_SYSROOT}/usr/include/vrpn
 )

trunk/lib/FlairSensorActuator/src/Camera.cpp

@@ -24 +24 @@
 #include <DataPlot1D.h>
 #include <Picture.h>
-#include <VisionFilter.h>
-#include <highgui.h>
 #include <fstream>
 
@@ -36 +34 @@
 
 Camera::Camera(string name, uint16_t width,
-               uint16_t height, cvimage::Type::Format format)
+               uint16_t height, Image::Type::Format format)
     : IODevice(getFrameworkManager(), name) {
   plot_tab = NULL;
@@ -42 +40 @@
 
   // do not allocate imagedata, allocation is done by the camera
-  output = new cvimage((IODevice *)this, width, height, format, "out", false);
+  output = new Image((IODevice *)this, width, height, format, "out", false);
         
   // station sol
@@ -76 +74 @@
                 case LogFormat::RAW:
                         AddDataToLog(output);
-                        Warn("raw log of cvimage is not yet implemented\n");
+                        Warn("raw log of Image is not yet implemented\n");
                         break;
                 case LogFormat::JPG:
-                                Warn("logging cvimage to jpeg\n");
+                                Warn("logging Image to jpeg\n");
                                 Warn("jpeg are not included in classical dbt file, as dbt does not handle variable length\n");
                         break;
@@ -95 +93 @@
 GridLayout *Camera::GetLayout(void) const { return setup_layout; }
 
-void Camera::UseDefaultPlot(const core::cvimage *image) {
+void Camera::UseDefaultPlot(const core::Image *image) {
   if (tab == NULL) {
     Err("not applicable for simulation part.\n");
@@ -113 +111 @@
 }
 
-core::cvimage *Camera::Output(void) { return output; }
+core::Image *Camera::Output(void) { return output; }
 
 void Camera::ProcessUpdate(core::io_data* data) {
@@ -121 +119 @@
                 if(logFormat==LogFormat::JPG) {
                         data->GetMutex();
-      //IplImage *img=((cvimage*)data)->img;
-      const cvimage* input = dynamic_cast<const cvimage*>(data);
+      //IplImage *img=((Image*)data)->img;
+      const Image* input = dynamic_cast<const Image*>(data);
       if (!input) {
-          Warn("casting %s to cvimage failed\n",data->ObjectName().c_str());
+          Warn("casting %s to Image failed\n",data->ObjectName().c_str());
           return;
       }
@@ -130 +128 @@
      
                         string filename=getFrameworkManager()->GetLogPath()+"/"+ObjectName()+"_"+std::to_string(data->DataTime())+".jpg";
-                        switch(((cvimage*)data)->GetDataType().GetFormat()) {
-                                case cvimage::Type::Format::Gray:
+                        switch(((Image*)data)->GetDataType().GetFormat()) {
+                                case Image::Type::Format::Gray:
                                         saveToJpeg(img,filename,PictureFormat_t::Gray,PictureFormat_t::Gray);
                                         break;
-                                case cvimage::Type::Format::BGR:
+                                case Image::Type::Format::BGR:
                                         saveToJpeg(img,filename,PictureFormat_t::RGB,PictureFormat_t::RGB);
                                         break;
-                                case cvimage::Type::Format::UYVY:
+                                case Image::Type::Format::UYVY:
                                         saveToJpeg(img,filename,PictureFormat_t::YUV_422ile,PictureFormat_t::YUV_422p);
                                         break;
@@ -160 +158 @@
                 output->GetMutex();
                 if(extension=="jpg") {
-                        if(output->GetDataType().GetFormat()==cvimage::Type::Format::Gray) saveToJpeg(output->img,filename,PictureFormat_t::Gray,PictureFormat_t::Gray);
-                        if(output->GetDataType().GetFormat()==cvimage::Type::Format::BGR) saveToJpeg(output->img,filename,PictureFormat_t::RGB,PictureFormat_t::RGB);
-                        if(output->GetDataType().GetFormat()==cvimage::Type::Format::UYVY) saveToJpeg(output->img,filename,PictureFormat_t::YUV_422ile,PictureFormat_t::YUV_422p);
+                        if(output->GetDataType().GetFormat()==Image::Type::Format::Gray) saveToJpeg(output->img,filename,PictureFormat_t::Gray,PictureFormat_t::Gray);
+                        if(output->GetDataType().GetFormat()==Image::Type::Format::BGR) saveToJpeg(output->img,filename,PictureFormat_t::RGB,PictureFormat_t::RGB);
+                        if(output->GetDataType().GetFormat()==Image::Type::Format::UYVY) saveToJpeg(output->img,filename,PictureFormat_t::YUV_422ile,PictureFormat_t::YUV_422p);
                 } else {
                         cvSaveImage(filename.c_str(),output->img);

trunk/lib/FlairSensorActuator/src/Camera.h

@@ -16 +16 @@
 #include <IODevice.h>
 #include <stdint.h>
-#include <cvimage.h>
+#include <Image.h>
 
 namespace flair {
@@ -51 +51 @@
   */
   Camera(std::string name, uint16_t width,
-         uint16_t height, core::cvimage::Type::Format format);
+         uint16_t height, core::Image::Type::Format format);
 
   /*!
@@ -75 +75 @@
   * \param image image to display
   */
-  void UseDefaultPlot(const core::cvimage *image);
+  void UseDefaultPlot(const core::Image *image);
 
   /*!
@@ -126 +126 @@
  * \return the output matrix
  */
-  core::cvimage *Output(void);
+  core::Image *Output(void);
 
   core::DataType const &GetOutputDataType() const;
@@ -159 +159 @@
   gui::GroupBox *GetGroupBox(void) const;
 
-  core::cvimage *output;
+  core::Image *output;
 
 private:

trunk/lib/FlairSensorActuator/src/Ps3Eye.cpp

@@ -28 +28 @@
                uint8_t priority)
     : V4LCamera( name, camera_index, 320, 240,
-                cvimage::Type::Format::YUYV, priority) {
+                Image::Type::Format::YUYV, priority) {
   SetIsReady(true);                  
 }

trunk/lib/FlairSensorActuator/src/SimulatedCamera.cpp

@@ -36 +36 @@
                        uint32_t modelId,uint32_t deviceId, uint8_t priority)
     : Thread(getFrameworkManager(), name, priority),
-      Camera(name, width, height, cvimage::Type::Format::BGR) {
+      Camera(name, width, height, Image::Type::Format::BGR) {
 
   buf_size = width * height * channels+sizeof(Time);

trunk/lib/FlairSensorActuator/src/V4LCamera.cpp

@@ -21 +21 @@
 #include <CheckBox.h>
 #include <Label.h>
-#include <cvimage.h>
+#include <Image.h>
 #include <FrameworkManager.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
-
 #include <sys/ioctl.h>
 #include <unistd.h>
 #include <cstring>
 #include <sys/mman.h>
-
+#include <VisionFilter.h>
 
 #define DEFAULT_V4L_BUFFERS 4
@@ -43 +42 @@
 V4LCamera::V4LCamera(string name,
                      uint8_t camera_index, uint16_t width, uint16_t height,
-                     cvimage::Type::Format format, uint8_t priority)
+                     Image::Type::Format format, uint8_t priority)
     : Thread(getFrameworkManager(), name, priority),
       Camera(name, width, height, format) {
   
-  string deviceName="/dev/video"+std::to_string(camera_index);
-  device = open(deviceName.c_str(), O_RDWR | O_NONBLOCK);
-  if (device == -1) {
-     Thread::Err("Cannot open %s\n");
-  }
+    string deviceName="/dev/video"+std::to_string(camera_index);
+    device = open(deviceName.c_str(), O_RDWR | O_NONBLOCK);
+    if (device == -1) {
+        Thread::Err("Cannot open %s\n",deviceName.c_str());
+    } else {
+        Printf("V4LCamera %s, opened %s\n",name.c_str(),deviceName.c_str());
+    }
+
+    struct v4l2_capability cap;
+    memset(&cap, 0, sizeof (v4l2_capability));
+    if (xioctl (device, VIDIOC_QUERYCAP, &cap)==-1) {
+        Thread::Err("VIDIOC_QUERYCAP xioctl\n");
+    }
+    if ((cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == 0) {
+        Thread::Err("device is unable to capture video memory.\n");
+    }
+
+    //get v4l2_format
+    struct v4l2_format form;
+    form.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    if(xioctl (device, VIDIOC_G_FMT,&form)==-1) {
+        Thread::Err("VIDIOC_G_FMT xioctl\n");
+    }
+  
+    //set width, height and format
+    if (format == Image::Type::Format::UYVY) {
+        form.fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY; 
+    } else if (format == Image::Type::Format::YUYV) {
+        form.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; 
+    } else {
+        Thread::Err("format not supported\n");
+    }
+  
+    form.fmt.pix.width = width; 
+    form.fmt.pix.height = height;
+    form.fmt.win.chromakey = 0;
+    form.fmt.win.field = V4L2_FIELD_ANY;
+    form.fmt.win.clips = 0;
+    form.fmt.win.clipcount = 0;
+    form.fmt.pix.field = V4L2_FIELD_ANY;
+    if(xioctl (device, VIDIOC_S_FMT,&form)==-1) {
+        Thread::Err("VIDIOC_S_FMT xioctl\n");
+    }
+  
+    //alloc and queue bufs
+    AllocBuffers();
+    for (int bufferIndex = 0; bufferIndex < nbBuffers;++bufferIndex) {
+        QueueBuffer(bufferIndex);
+    }
     
-  //get v4l2_format
-  struct v4l2_format form;
-  form.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-  xioctl (device, VIDIOC_G_FMT,&form);
-  
-  //set width, height and format
-  if (format == cvimage::Type::Format::UYVY) {
-    form.fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY; 
-  } else if (format == cvimage::Type::Format::YUYV) {
-    form.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; 
-  } else {
-    Thread::Err("format not supported\n");
-  }
-  
-  form.fmt.pix.width = width; 
-  form.fmt.pix.height = height;
-  form.fmt.win.chromakey = 0;
-  form.fmt.win.field = V4L2_FIELD_ANY;
-  form.fmt.win.clips = 0;
-  form.fmt.win.clipcount = 0;
-  form.fmt.pix.field = V4L2_FIELD_ANY;
-  xioctl (device, VIDIOC_S_FMT, &form);
-  
-  /* This is just a technicality, but all buffers must be filled up before any
-   staggered SYNC is applied.  SO, filler up. (see V4L HowTo) */
-
-  AllocBuffers();
-
-  for (int bufferIndex = 0; bufferIndex < ((int)requestbuffers.count);++bufferIndex) {
-    struct v4l2_buffer buf;
-
-    memset(&buf, 0, sizeof (v4l2_buffer));
-
-    buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-    buf.memory      = V4L2_MEMORY_MMAP;
-    buf.index       = (unsigned long)bufferIndex;
-
-    if (-1 == xioctl (device, VIDIOC_QBUF, &buf)) {
-        Thread::Err("VIDIOC_QBUF xioctl\n");
-        break;
-    }
-  }
-
-  // enable the streaming
-  v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-  if (-1 == xioctl (device, VIDIOC_STREAMON,&type)) {
-      Thread::Err("VIDIOC_STREAMON xioctl\n");
-  }
-
-
-  // skip first frame. it is often bad -- this is unnotied in traditional apps,
-  //  but could be fatal if bad jpeg is enabled
-  GrabFrame();
-    
-    
-    
-  // station sol
-  gain = new DoubleSpinBox(GetGroupBox()->NewRow(), "gain:", 0, 1, 0.1);
-  exposure = new DoubleSpinBox(GetGroupBox()->LastRowLastCol(), "exposure:", 0,
-                               1, 0.1);
-  bright =
-      new DoubleSpinBox(GetGroupBox()->LastRowLastCol(), "bright:", 0, 1, 0.1);
-  contrast = new DoubleSpinBox(GetGroupBox()->LastRowLastCol(), "contrast:", 0,
-                               1, 0.1);
-  hue = new DoubleSpinBox(GetGroupBox()->LastRowLastCol(), "hue:", 0, 1, 0.1);
-  sharpness = new DoubleSpinBox(GetGroupBox()->LastRowLastCol(), "sharpness:",
-                                0, 1, 0.1);
-  sat = new DoubleSpinBox(GetGroupBox()->LastRowLastCol(), "saturation:", 0, 1,
-                          0.1);
-  autogain = new CheckBox(GetGroupBox()->NewRow(), "autogain:");
-  autoexposure = new CheckBox(GetGroupBox()->LastRowLastCol(), "autoexposure:");
-  awb = new CheckBox(GetGroupBox()->LastRowLastCol(), "awb:");
-  fps = new Label(GetGroupBox()->NewRow(), "fps");
-  
-  hasProblems=false;
+    // enable the streaming
+    v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    if (xioctl (device, VIDIOC_STREAMON,&type)==-1) {
+        Thread::Err("VIDIOC_STREAMON xioctl\n");
+    }
+
+    // skip first frame. it is often bad -- this is unnotied in traditional apps,
+    //  but could be fatal if bad jpeg is enabled
+    bufferIndex=-1;
+    GrabFrame();
+
+    // ground station
+    gain = new DoubleSpinBox(GetGroupBox()->NewRow(), "gain:", 0, 1, 0.1);
+    exposure = new DoubleSpinBox(GetGroupBox()->LastRowLastCol(), "exposure:", 0,1, 0.1);
+    bright = new DoubleSpinBox(GetGroupBox()->LastRowLastCol(), "bright:", 0, 1, 0.1);
+    contrast = new DoubleSpinBox(GetGroupBox()->LastRowLastCol(), "contrast:", 0,1, 0.1);
+    hue = new DoubleSpinBox(GetGroupBox()->LastRowLastCol(), "hue:", 0, 1, 0.1);
+    sharpness = new DoubleSpinBox(GetGroupBox()->LastRowLastCol(), "sharpness:", 0, 1, 0.1);
+    sat = new DoubleSpinBox(GetGroupBox()->LastRowLastCol(), "saturation:", 0, 1,0.1);
+    autogain = new CheckBox(GetGroupBox()->NewRow(), "autogain:");
+    autoexposure = new CheckBox(GetGroupBox()->LastRowLastCol(), "autoexposure:");
+    awb = new CheckBox(GetGroupBox()->LastRowLastCol(), "awb:");
+    fps = new Label(GetGroupBox()->NewRow(), "fps");
+
+    hasProblems=false;
 }
 
 V4LCamera::~V4LCamera() {
-  SafeStop();
-  Join();
+    for (int n_buffers = 0; n_buffers < nbBuffers; n_buffers++) {
+       FreeFunction((char*)buffers[n_buffers].start);
+   }
+    SafeStop();
+    Join();
 }
 
 void V4LCamera::Run(void) {
   Time cam_time, new_time, fpsNow, fpsPrev;
-  char* buffer; // raw image
   int fpsCounter = 0;
 
@@ -160 +155 @@
     fpsCounter++;
     if (GetTime() > (fpsPrev + 5 * (Time)1000000000)) {
-      // toute les 5 secondes
+      // every 5 secondes
       fpsNow = GetTime();
       fps->SetText("fps: %.1f",
@@ -204 +199 @@
       SetProperty(V4L2_CID_AUTO_WHITE_BALANCE, awb->Value());
 
-    // cam pictures
-    buffer = RetrieveRawFrame();
+    // get picture
     GrabFrame();
     new_time = GetTime();
@@ -216 +210 @@
 
     output->GetMutex();
-    output->buffer = buffer;
+    output->buffer=(char*)buffers[bufferIndex].start;
     output->ReleaseMutex();
 
@@ -228 +222 @@
 }
 
-void V4LCamera::GrabFrame(void) {
-    unsigned int count;
-
-    count = 1;
-
-    while (count-- > 0) {
-        for (;;) {
-            fd_set fds;
-            struct timeval tv;
-            int r;
-
-            FD_ZERO (&fds);
-            FD_SET (device, &fds);
-
-            /* Timeout. */
-            tv.tv_sec = 2;
-            tv.tv_usec = 0;
-
-            r = select (device+1, &fds, NULL, NULL, &tv);
-
-            if (-1 == r) {
-                if (EINTR == errno) continue;
-                Thread::Err("select\n");
+int V4LCamera::QueueBuffer(int index) {
+    struct v4l2_buffer buf;
+    if(index>=0 && index<nbBuffers) {
+        memset(&buf, 0, sizeof (v4l2_buffer));
+        buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        buf.memory      = V4L2_MEMORY_USERPTR;//V4L2_MEMORY_MMAP;
+        buf.index       = (unsigned long)index;
+        buf.m.userptr=(unsigned long)(buffers[index].start);
+        buf.length=buffers[index].length;
+        
+        int ret=xioctl (device, VIDIOC_QBUF, &buf);
+        if (ret==-1) {
+            Thread::Err("VIDIOC_QBUF xioctl %s\n",strerror(-ret));
+            return -1;
+        }
+    }
+    return 0;
+}
+
+int V4LCamera::GrabFrame(void) {
+    //queue previous buffer
+    if(QueueBuffer(bufferIndex)<0) return -1;
+   
+    fd_set fds;
+    struct timeval tv;
+    FD_ZERO (&fds);
+    FD_SET (device, &fds);
+
+    tv.tv_sec = 0;
+    tv.tv_usec = 100000;
+
+    int r = select (device+1, &fds, NULL, NULL, &tv);
+
+    if (-1 == r) {
+        char errorMsg[256];
+        Thread::Err("select (%s)\n", strerror_r(-r, errorMsg, sizeof(errorMsg)));
+        return -1;
+    }
+
+    if (0 == r) {
+        Thread::Err("select timeout\n");
+        return -1;
+    }
+
+    struct v4l2_buffer buf;
+    memset(&buf, 0, sizeof (v4l2_buffer));
+    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    buf.memory = V4L2_MEMORY_USERPTR;//V4L2_MEMORY_MMAP;
+
+    //get last captured image
+    int prevDQbuf=-1;
+    for(int i=0;i<4;i++) {
+        if (xioctl (device, VIDIOC_DQBUF, &buf)==-1) {
+            if (errno==EAGAIN) {
+                break;
+            } else {
+                Thread::Err("VIDIOC_DQBUF xioctl\n");
+                return -1;
             }
-
-            if (0 == r) {
-                Thread::Err("select timeout\n");
-                /* end the infinite loop */
-                break;
-            }
-
-            if (read_frame_v4l2 ()) break;
-        }
-    }
-}
-
-int V4LCamera::read_frame_v4l2(void) {
-  struct v4l2_buffer buf;
-  memset(&buf, 0, sizeof (v4l2_buffer));
-  
-
-    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-    buf.memory = V4L2_MEMORY_MMAP;
-
-    if (-1 == xioctl (device, VIDIOC_DQBUF, &buf)) {
-        switch (errno) {
-        case EAGAIN:
-            return 0;
-
-        case EIO:
-            /* Could ignore EIO, see spec. */
-
-            /* fall through */
-
-        default:
-            /* display the error and stop processing */
-            Thread::Err("VIDIOC_DQBUF xioctl\n");
-            return 1;
-        }
-   }
-
-   if(buf.index >= requestbuffers.count) {
-     Thread::Err("buf.index >= requestbuffers.count\n");
-   }
+       } else {
+           if(prevDQbuf!=-1) {
+               QueueBuffer(prevDQbuf);
+           }
+           for (int n_buffers = 0; n_buffers < nbBuffers; n_buffers++) {
+               if((void*)(buf.m.userptr)==buffers[n_buffers].start) {
+                   prevDQbuf=n_buffers;
+                   bufferIndex=n_buffers;
+                   break;
+               }
+           }
+       }
+    }
    
-#ifdef USE_TEMP_BUFFER
-   memcpy(capture->buffers[MAX_V4L_BUFFERS].start, 
-          capture->buffers[buf.index].start, 
-          capture->buffers[MAX_V4L_BUFFERS].length );
-   capture->bufferIndex = MAX_V4L_BUFFERS;
-   //printf("got data in buff %d, len=%d, flags=0x%X, seq=%d, used=%d)\n", 
-   //     buf.index, buf.length, buf.flags, buf.sequence, buf.bytesused);
-#else
-   bufferIndex = buf.index;
-#endif
-
-   if (-1 == xioctl (device, VIDIOC_QBUF, &buf)) {
-       Thread::Err ("VIDIOC_QBUF xioctl\n");
-   }
-
    return 1;
 }
 
 int V4LCamera::AllocBuffers(void) {
+    struct v4l2_requestbuffers requestbuffers;
    memset(&requestbuffers, 0, sizeof (v4l2_requestbuffers));
    
@@ -320 +308 @@
    requestbuffers.count = buffer_number;
    requestbuffers.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-   requestbuffers.memory = V4L2_MEMORY_MMAP;
-
-   if (-1 == xioctl (device, VIDIOC_REQBUFS, &requestbuffers)) {
-       if (EINVAL == errno) {
-         Thread::Err("not support memory mapping not supportted\n");
+   requestbuffers.memory = V4L2_MEMORY_USERPTR;//V4L2_MEMORY_MMAP;
+
+   if (xioctl (device, VIDIOC_REQBUFS, &requestbuffers)==-1) {
+       if (errno==EINVAL) {
+         Thread::Err("VIDIOC_REQBUFS user memory not supported\n");
        } else {
          Thread::Err ("VIDIOC_REQBUFS xioctl\n");
@@ -330 +318 @@
        return -1;
    }
-
-   if (requestbuffers.count < buffer_number) {
-       if (buffer_number == 1) {
-        Thread::Err("Insufficient buffer memory\n");
-        return -1;
-       } else {
-        buffer_number--;
-        Thread::Warn ("Insufficient buffer memory, decreasing buffers\n");
-        goto try_again;
-       }
+   
+   nbBuffers=DEFAULT_V4L_BUFFERS;
+   for (int n_buffers = 0; n_buffers < nbBuffers; n_buffers++) {
+       buffers[n_buffers].length = output->GetDataType().GetSize();
+       buffers[n_buffers].start =AllocFunction(output->GetDataType().GetSize());
    }
 
-   for (int n_buffers = 0; n_buffers < requestbuffers.count; ++n_buffers) {
-       struct v4l2_buffer buf;
-
-       memset(&buf, 0, sizeof (v4l2_buffer));
-
-       buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-       buf.memory = V4L2_MEMORY_MMAP;
-       buf.index = n_buffers;
-
-       if (-1 == xioctl (device, VIDIOC_QUERYBUF, &buf)) {
-           Thread::Err("VIDIOC_QUERYBUF xioctl\n");
-           return -1;
-       }
-
-       buffers[n_buffers].length = buf.length;
-       buffers[n_buffers].start =
-         mmap (NULL /* start anywhere */,
-               buf.length,
-               PROT_READ | PROT_WRITE /* required */,
-               MAP_SHARED /* recommended */,
-               device, buf.m.offset);
-
-       if (MAP_FAILED == buffers[n_buffers].start) {
-           Thread::Err("mmap\n");
-           return -1;
-       }
-   }
-
-  //todo: verifier cette alloc, pas de double buffeinrg?
-  //peut on initialiser l'image dans le constrcteur de la camera?
-   
-   output->buffer=output->allocFunction(output->dataType.GetSize());
    return 1;
 };
 
-char *V4LCamera::RetrieveRawFrame(void) {
-  
-  /* [FD] this really belongs here */
-  if (ioctl(device, VIDIOCSYNC, &mmaps[bufferIndex].frame) == -1) {
-    Thread::Err("Could not SYNC to video stream. %s\n", strerror(errno));
-  }
-
-  /* Now get what has already been captured as a IplImage return */
-  if (output->dataType.GetFormat() == cvimage::Type::Format::YUYV || output->dataType.GetFormat() == cvimage::Type::Format::UYVY) {
-    #ifdef USE_TEMP_BUFFER
-    capture->frame.imageData=(char*)capture->buffers[capture->bufferIndex].start;
-    #else
-Printf("frame is not allocated\n");
-    memcpy((char *)frame,(char *)buffers[bufferIndex].start,output->GetDataType().GetSize());
-    #endif
-  } else {
-    Thread::Err("palette %d not supported for raw output\n",output->dataType.GetFormat());
-  }
-
-  return(frame);
-}
-
 bool V4LCamera::HasProblems(void) {
   return hasProblems;
@@ -408 +337 @@
 
 void V4LCamera::SetAutoExposure(bool value) {
-  Thread::Warn("not implemented in opencv\n");
+  Thread::Warn("not implemented\n");
 }
 

trunk/lib/FlairSensorActuator/src/V4LCamera.h

@@ -23 +23 @@
 namespace flair {
 namespace core {
-class cvimage;
+class Image;
 }
 namespace gui {
@@ -55 +55 @@
   V4LCamera(std::string name,
             uint8_t camera_index, uint16_t width, uint16_t height,
-            core::cvimage::Type::Format format, uint8_t priority);
+            core::Image::Type::Format format, uint8_t priority);
 
   /*!
@@ -151 +151 @@
   void SetProperty(int property,float value);
   float GetProperty(int property);
-  void GrabFrame(void);
-  int read_frame_v4l2(void);
-  char *RetrieveRawFrame(void);
+  int GrabFrame(void);
   int AllocBuffers(void);
+  int QueueBuffer(int index);
   struct video_mmap *mmaps;
   int bufferIndex;
-  struct v4l2_requestbuffers requestbuffers;
   struct buffer {
     void *  start;
     size_t  length;
   };
-  buffer buffers[MAX_V4L_BUFFERS + 1];
+  buffer buffers[MAX_V4L_BUFFERS];
   char* frame;
+  int nbBuffers;
 };
 } // end namespace sensor

trunk/lib/FlairVisionFilter/CMakeLists.txt

@@ -7 +7 @@
         ${CMAKE_CURRENT_SOURCE_DIR}/../FlairCore/src
     ${CMAKE_CURRENT_SOURCE_DIR}/../FlairFilter/src
-        ${CMAKE_SYSROOT}/usr/include/opencv1
 )
 

trunk/lib/FlairVisionFilter/src/CvtColor.cpp

@@ -13 +13 @@
 
 #include "CvtColor.h"
-#include <cvimage.h>
+#include "VisionFilter.h"
+#include <Image.h>
 #include <typeinfo>
 
@@ -19 +20 @@
 using namespace flair::core;
 
+class CvtColor_impl {
+public:
+    CvtColor_impl(flair::filter::CvtColor *self,flair::filter::CvtColor::Conversion_t conversion):output(0) {
+        this->conversion=conversion;
+        this->self=self;
+
+        switch(conversion) {
+        case flair::filter::CvtColor::Conversion_t::ToGray:
+            try{
+                Image::Type const &imageType=dynamic_cast<Image::Type const &>(((IODevice*)(self->Parent()))->GetOutputDataType());
+                output=new Image(self,imageType.GetWidth(),imageType.GetHeight(),Image::Type::Format::Gray,"conversion",true,2);
+                //inIplImage = (IplImage*)AllocFunction(sizeof(IplImage));
+                //outIplImage = (IplImage*)AllocFunction(sizeof(IplImage));
+            } catch(std::bad_cast& bc) {
+                self->Err("io type mismatch\n");
+            }
+            break;
+        default:
+            self->Err("conversion not supported\n");
+        }
+    }
+
+    ~CvtColor_impl() {
+        //FreeFunction((char*)(inIplImage));
+        //FreeFunction((char*)(outIplImage));
+    }
+    
+    void UpdateFrom(const io_data *data){
+        Image *img=(Image*)data;
+
+        if(output!=NULL) {
+            data->GetMutex();/*
+            inIplImage->width=img->GetDataType().GetWidth();
+            inIplImage->height=img->GetDataType().GetHeight();
+            inIplImage->imageData=img->buffer;
+            inIplImage->imageSize=img->GetDataType().GetSize();
+            */
+            output->GetMutex();/*
+            outIplImage->width=output->GetDataType().GetWidth();
+            outIplImage->height=output->GetDataType().GetHeight();
+            outIplImage->imageData=output->buffer;
+            outIplImage->imageSize=output->GetDataType().GetSize();
+*/
+            switch(conversion) {
+            case flair::filter::CvtColor::Conversion_t::ToGray:
+                switch(((Image*)data)->GetDataType().GetFormat()) {
+                case Image::Type::Format::YUYV:
+                    //dspCvtColor(inIplImage,outIplImage,DSP_YUYV2GRAY);
+                    break;
+                case Image::Type::Format::UYVY:
+                    //dspCvtColor(inIplImage,outIplImage,DSP_UYVY2GRAY);
+                    break;
+                case Image::Type::Format::BGR:
+                    //dspCvtColor(inIplImage,outIplImage,DSP_BGR2GRAY);
+                    break;
+                default:
+                    self->Err("input format not supported\n");
+                }
+                break;
+            default:
+                self->Err("conversion not supported\n");
+            }
+
+            output->ReleaseMutex();
+            data->ReleaseMutex();
+
+            output->SetDataTime(data->DataTime());
+        }
+    };
+    
+    Image *output;
+
+private:
+    flair::filter::CvtColor::Conversion_t conversion;
+    //IplImage *inIplImage,*outIplImage;
+    flair::filter::CvtColor *self;
+};
+
+
 namespace flair { namespace filter {
 
-CvtColor::CvtColor(const core::IODevice* parent,std::string name,Conversion_t conversion) : IODevice(parent,name),output(0) {
-    this->conversion=conversion;
-
-    switch(conversion) {
-    case Conversion_t::ToGray:
-        try{
-            cvimage::Type const &imageType=dynamic_cast<cvimage::Type const &>(parent->GetOutputDataType());
-            output=new cvimage(this,imageType.GetWidth(),imageType.GetHeight(),cvimage::Type::Format::Gray,"conversion",true,2);
-
-        } catch(std::bad_cast& bc) {
-            Err("io type mismatch\n");
-        }
-        break;
-    default:
-        Err("conversion not supported\n");
-    }
-    
-    SetIsReady(true);
+CvtColor::CvtColor(const core::IODevice* parent,std::string name,Conversion_t conversion) : IODevice(parent,name) {
+    pimpl_=new CvtColor_impl(this,conversion);
 }
 
-CvtColor::~CvtColor(void) {}
+CvtColor::~CvtColor(void) {
+    delete pimpl_;
+}
 
-cvimage* CvtColor::Output(void) {
-    return output;
+Image* CvtColor::Output(void) {
+    return pimpl_->output;
 
 }
 
 DataType const &CvtColor::GetOutputDataType() const {
-    if(output!=NULL) {
-        return output->GetDataType();
+    if(pimpl_->output!=NULL) {
+        return pimpl_->output->GetDataType();
     } else {
         return dummyType;
@@ -57 +123 @@
 
 void CvtColor::UpdateFrom(const io_data *data) {
-    cvimage *img=(cvimage*)data;
-
-    data->GetMutex();
-    output->GetMutex();
-
-    switch(conversion) {
-    case Conversion_t::ToGray:
-        switch(img->GetDataType().GetFormat()) {
-        case cvimage::Type::Format::YUYV:
-            //dspCvtColor(img,output->img,DSP_YUYV2GRAY);
-            break;
-        case cvimage::Type::Format::UYVY:
-            //dspCvtColor(img,output->img,DSP_UYVY2GRAY);
-            break;
-        case cvimage::Type::Format::BGR:
-            //dspCvtColor(img,output->img,DSP_BGR2GRAY);
-            break;
-        default:
-            Err("input format not supported\n");
-        }
-        break;
-    default:
-        Err("conversion not supported\n");
-    }
-
-    output->ReleaseMutex();
-    data->ReleaseMutex();
-
-    output->SetDataTime(data->DataTime());
-    ProcessUpdate(output);
+    pimpl_->UpdateFrom(data);
+    if(pimpl_->output!=NULL) ProcessUpdate(pimpl_->output);
+    
 }
 

trunk/lib/FlairVisionFilter/src/CvtColor.h

@@ -13 +13 @@
 #include <IODevice.h>
 
-namespace flair
-{
-    namespace core
-    {
-        class cvimage;
+namespace flair {
+    namespace core {
+        class Image;
     }
 }
 
-namespace flair
-{
+class CvtColor_impl;
+
+namespace flair {
 namespace filter
 {
@@ -68 +67 @@
             * \return the output image
             */
-            core::cvimage* Output(void);
+            core::Image* Output(void);
 
             core::DataType const &GetOutputDataType() const;
@@ -82 +81 @@
             void UpdateFrom(const core::io_data *data);
 
-            core::cvimage *output;
-            Conversion_t conversion;
+            class CvtColor_impl *pimpl_;
     };
 } // end namespace filter

trunk/lib/FlairVisionFilter/src/HoughLines.cpp

@@ -13 +13 @@
 
 #include "HoughLines.h"
-#include <cvimage.h>
+#include "VisionFilter.h"
+#include <Image.h>
+#include <OneAxisRotation.h>
 #include <Matrix.h>
 #include <Layout.h>
@@ -20 +22 @@
 #include <DoubleSpinBox.h>
 #include <typeinfo>
+#include <math.h>
 
 #define MAX_LINES 100
@@ -27 +30 @@
 using namespace flair::gui;
 
+class HoughLines_impl {
+public:
+    HoughLines_impl(flair::filter::HoughLines *self,const LayoutPosition* position,string name,const Vector2Df *inPtRefGlobal,float inThetaRefGlobal) {
+        this->self=self;
+        GroupBox* reglages_groupbox=new GroupBox(position,name);
+        rotation=new OneAxisRotation(reglages_groupbox->NewRow(),"pre rotation",OneAxisRotation::PostRotation);
+        fullRhoStep=new SpinBox(reglages_groupbox->NewRow(),"full rho step:","pixels",0,255,1,1);
+        fullThetaStep=new DoubleSpinBox(reglages_groupbox->LastRowLastCol(),"full theta step:","degrees",0,90,1,1);
+        trackingRhoStep=new SpinBox(reglages_groupbox->NewRow(),"tracking rho step:","pixels",0,255,1,1);
+        trackingThetaStep=new DoubleSpinBox(reglages_groupbox->LastRowLastCol(),"tracking theta step:","degrees",0,90,1,1);
+        trackingDeltaTheta=new DoubleSpinBox(reglages_groupbox->LastRowLastCol(),"tracking delta theta:","degrees",0,90,1,1);
+        nbPoints=new SpinBox(reglages_groupbox->NewRow(),"nb points:",0,10000,10,100);
+
+        isTracking=false;
+        //linesStorage = (CvMat*)AllocFunction(sizeof(CvMat));
+        //linesStorage->data.fl = (float*)AllocFunction(MAX_LINES*2*sizeof(float));//was CV_32FC2, 2 channels
+        //gimg = (IplImage*)AllocFunction(sizeof(IplImage));
+
+        //init output matrix of same size as init
+        MatrixDescriptor* desc=new MatrixDescriptor(4,1);
+        desc->SetElementName(0,0,"distance");
+        desc->SetElementName(1,0,"orientation rad");
+        desc->SetElementName(2,0,"orientation deg");
+        desc->SetElementName(3,0,"line_detected");
+        output=new Matrix(self,desc,floatType,name);
+        delete desc;
+
+        try{
+            Image::Type const &imageType=dynamic_cast<Image::Type const &>(((IODevice*)(self->Parent()))->GetOutputDataType());
+            if(imageType.GetFormat()!=Image::Type::Format::Gray) {
+                self->Err("input image is not gray\n");
+            }
+        } catch(std::bad_cast& bc) {
+            self->Err("io type mismatch\n");
+        }
+
+        thetaRefGlobal=inThetaRefGlobal;
+        if (inPtRefGlobal==NULL) {
+            ptRefGlobal=NULL;
+        } else { //rotation from global coordinates to hough space
+            ptRefGlobal =new Vector2Df(inPtRefGlobal->x,inPtRefGlobal->y);
+        }
+        
+    }
+
+    ~HoughLines_impl() {
+        //FreeFunction((char*)(linesStorage->data.fl));
+        //FreeFunction((char*)linesStorage);
+        //FreeFunction((char*)gimg);
+        if(ptRefGlobal!=NULL) delete ptRefGlobal;
+    }
+    
+    void UpdateFrom(const io_data *data){
+        Image *img=(Image*)data;
+  /*
+        gimg->width=img->GetDataType().GetWidth();
+        gimg->height=img->GetDataType().GetHeight();
+        gimg->imageData=img->buffer;
+        gimg->imageSize=img->GetDataType().GetSize();
+    
+        size_t nbLines;
+        Vector2Df ptRef;
+        float thetaRef;
+
+        if (ptRefGlobal==NULL) {
+          ptRef.x=img->GetDataType().GetWidth()/2;
+          ptRef.y=img->GetDataType().GetHeight()/2;
+        } else { //rotation from global coordinates to hough space
+          Vector3Df ptRef3D(ptRefGlobal->x,ptRefGlobal->y,0);
+          rotation->ComputeRotation(ptRef3D);
+          ptRef.x=ptRef3D.x;
+          ptRef.y=ptRef3D.y;
+        }
+          
+        //orientation in global space is rotated by pi/2 compared to orientation in hough space
+        //eg: vertical line has a 0 orientation in global space (north), but a pi/2 (or -pi/2) orientation in hough space (theta)
+        thetaRef=thetaRefGlobal+CV_PI/2+rotation->GetAngle();
+        if (thetaRef>CV_PI) thetaRef-=CV_PI;
+        if (thetaRef<0) thetaRef+=CV_PI;
+
+        data->GetMutex();
+        if(!isTracking) {
+        nbLines=dspHoughLines2(gimg,linesStorage,CV_HOUGH_STANDARD,
+                                fullRhoStep->Value(),fullThetaStep->Value()*CV_PI/180,
+                                nbPoints->Value());
+        } else {
+        nbLines=dspHoughLinesTracking(gimg,linesStorage,CV_HOUGH_STANDARD,
+                                     trackingRhoStep->Value(),
+                                     theta,trackingDeltaTheta->Value()*CV_PI/180,
+                                     trackingThetaStep->Value()*CV_PI/180,
+                                     nbPoints->Value());
+        //        nbLines=dspHoughLines2_test(gimg,linesStorage,CV_HOUGH_STANDARD,trackingRhoStep->Value(),thetaPrev-trackingDeltaTheta->Value()*CV_PI/180,thetaPrev+trackingDeltaTheta->Value()*CV_PI/180,trackingThetaStep->Value()*CV_PI/180,nbPoints->Value());
+        }
+        data->ReleaseMutex();
+
+        //saturation sur le nb max de ligne, au cas ou le DSP n'aurait pas la meme valeur
+        if(nbLines>MAX_LINES) {
+            self->Warn("erreur nb lines %u>%u\n",nbLines,MAX_LINES);
+            nbLines=MAX_LINES;
+        }
+        float rho;
+        bool noLine=!SelectBestLine(linesStorage,nbLines,rho,theta);
+
+        if (noLine) {
+            isTracking=false;
+        } else {
+            isTracking=true;
+        //        float thetaRef=0;
+
+            //line equation is ax+by+c=0 with a=cos(theta), b=sin(theta) and c=-rho
+            //distance from point xRef,yRef to the line is (a.xRef+b.yRef+c)/sqrt(a*a+b*b)
+            distance=-(cosf(theta)*ptRef.x+sinf(theta)*ptRef.y-rho);
+
+            orientation=theta-thetaRef;
+            if (orientation<-CV_PI/2) {
+              orientation+=CV_PI;
+              distance=-distance;
+            }
+            if (orientation>CV_PI/2) {
+              orientation-=CV_PI;
+              distance=-distance;
+            }
+
+            //printf("=> pour theta=%f et rho=%f, distance au point(%f,%f)=%f\n",theta,rho,xRef,yRef,distance);
+        }
+
+        output->GetMutex();
+        output->SetValueNoMutex(0,0,distance);
+        output->SetValueNoMutex(1,0,orientation);
+        output->SetValueNoMutex(2,0,orientation*180/CV_PI);
+        if(noLine) {
+            output->SetValueNoMutex(3,0,0);
+        } else {
+            output->SetValueNoMutex(3,0,1);
+        }
+        output->ReleaseMutex();
+*/
+        output->SetDataTime(data->DataTime());
+    };
+    
+    Matrix *output;
+    
+private:/*
+    //select best line. Returns false if no line found
+    bool SelectBestLine(CvMat* linesStorage, size_t nbLines, float &rho, float &theta) {
+      if(nbLines==0) {
+        return false;
+      }
+      //one line is found
+      if (nbLines==1) {
+        rho=linesStorage->data.fl[0];
+        theta=linesStorage->data.fl[1];
+        //printf("rho=%f,theta=%f (one line)\n",rho,theta);
+        return true;
+      }
+      //lines are ordered by quality, the first one will be our reference
+      float thetaRef=linesStorage->data.fl[1];
+      float thetaRefErrorSum=0;
+      float rhoSum=linesStorage->data.fl[0];
+      //printf("rho=%f,theta=%f (first of multilines)\n",rhoSum,thetaRef);
+      for(int i=1;i<nbLines;i++) {
+        //printf("rho=%f,theta=%f (multilines)\n",linesStorage->data.fl[2*i],linesStorage->data.fl[2*i+1]);
+        float thetaDiff=linesStorage->data.fl[2*i+1]-thetaRef;
+        float rhoLine=linesStorage->data.fl[2*i];
+        if (thetaDiff>CV_PI/2) {
+          thetaDiff-=CV_PI;
+          rhoLine=-rhoLine;
+        } else if (thetaDiff<-CV_PI/2) {
+          thetaDiff+=CV_PI;
+          rhoLine=-rhoLine;
+        }
+        thetaRefErrorSum += thetaDiff;
+        rhoSum+=rhoLine;
+      }
+      rho=rhoSum/nbLines;
+      theta=thetaRef+thetaRefErrorSum/nbLines;
+      if (theta<0) {
+        theta+=CV_PI;
+        rho=-rho;
+      }
+      if (theta>CV_PI) {
+        theta-=CV_PI;
+        rho=-rho;
+      }
+      return true;
+    }
+*/
+    flair::filter::HoughLines *self;
+    OneAxisRotation* rotation;
+    SpinBox *fullRhoStep,*trackingRhoStep,*nbPoints;
+    DoubleSpinBox *fullThetaStep,*trackingThetaStep,*trackingDeltaTheta;
+    bool isTracking;
+    float theta;
+    float distance,orientation;
+    Vector2Df* ptRefGlobal;
+    float thetaRefGlobal;
+    //CvMat* linesStorage;
+    //IplImage *gimg;
+};
+
 namespace flair { namespace filter {
 
-HoughLines::HoughLines(const IODevice* parent,const LayoutPosition* position,string name) : IODevice(parent,name) {
-    GroupBox* reglages_groupbox=new GroupBox(position,name);
-    fullRhoStep=new SpinBox(reglages_groupbox->NewRow(),"full rho step:","pixels",0,255,1,1);
-    fullThetaStep=new DoubleSpinBox(reglages_groupbox->LastRowLastCol(),"full theta step:","degrees",0,90,1,1);
-    trackingRhoStep=new SpinBox(reglages_groupbox->NewRow(),"tracking rho step:","pixels",0,255,1,1);
-    trackingThetaStep=new DoubleSpinBox(reglages_groupbox->LastRowLastCol(),"tracking theta step:","degrees",0,90,1,1);
-    trackingDeltaTheta=new DoubleSpinBox(reglages_groupbox->LastRowLastCol(),"tracking delta theta:","degrees",0,90,1,1);
-    nbPoints=new SpinBox(reglages_groupbox->NewRow(),"nb points:",0,10000,10,100);
-
-    isTracking=false;
-    lostLine=false;
-    initLine=false;
-    linesStorage = cvCreateMat(MAX_LINES, 1, CV_32FC2);
-
-    //init output matrix of same size as init
-    MatrixDescriptor* desc=new MatrixDescriptor(4,1);
-    desc->SetElementName(0,0,"distance");
-    desc->SetElementName(1,0,"orientation rad");
-    desc->SetElementName(2,0,"orientation deg");
-    desc->SetElementName(3,0,"line_detected");
-    output=new Matrix(this,desc,floatType,name);
-    delete desc;
-
-    try{
-        cvimage::Type const &imageType=dynamic_cast<cvimage::Type const &>(parent->GetOutputDataType());
-        if(imageType.GetFormat()!=cvimage::Type::Format::Gray) {
-            Err("input image is not gray\n");
-            return;
-        }
-    } catch(std::bad_cast& bc) {
-        Err("io type mismatch\n");
-        return;
-    }
-    
-    SetIsReady(true);
+HoughLines::HoughLines(const IODevice* parent,const LayoutPosition* position,string name,const Vector2Df *inPtRefGlobal,float inThetaRefGlobal) : IODevice(parent,name) {
+  pimpl_=new HoughLines_impl(this,position,name,inPtRefGlobal,inThetaRefGlobal);
+   
 }
 
 HoughLines::~HoughLines(void) {
-    cvReleaseMat(&linesStorage);
+   delete  pimpl_;
 }
 
 void HoughLines::UpdateFrom(const io_data *data) {
- 
+    pimpl_->UpdateFrom(data);
+    ProcessUpdate(pimpl_->output);
 }
 
 bool HoughLines::isLineDetected() const {
-    if(output->Value(3,0)==1) {
+    if(pimpl_->output->Value(3,0)==1) {
         return true;
     } else {
@@ -83 +255 @@
 
 float HoughLines::GetOrientation(void) const {
-    return output->Value(1,0);
+    return pimpl_->output->Value(1,0);
 }
 
 float HoughLines::GetDistance(void) const {
-    return output->Value(0,0);
+    return pimpl_->output->Value(0,0);
 }
 
 Matrix *HoughLines::Output(void) const {
-    return output;
+    return pimpl_->output;
 }
 

trunk/lib/FlairVisionFilter/src/HoughLines.h

@@ -12 +12 @@
 
 #include <IODevice.h>
-#include <cv.h>
+#include <Vector2D.h>
 
 namespace flair {
     namespace core {
-        class cvimage;
         class Matrix;
     }
     namespace gui {
         class LayoutPosition;
-        class SpinBox;
-        class DoubleSpinBox;
     }
 }
+
+class HoughLines_impl;
 
 namespace flair { namespace filter {
@@ -44 +43 @@
             * \param position position
             * \param name name
+            * \param ptRefGlobal reference point used to compute distance to the line
+            * \param thetaRefGlobal reference angle used to compute orientation in range [-pi/2,pi/2]. Default value is 0 which defines a vertical line
             */
-            HoughLines(const core::IODevice* parent,const gui::LayoutPosition* position,std::string name);
+            HoughLines(const core::IODevice* parent,const gui::LayoutPosition* position,std::string name,const core::Vector2Df *ptRefGlobal=NULL,float thetaRefGlobal=0);
 
             /*!
@@ -60 +61 @@
         private:
             void UpdateFrom(const core::io_data *data);
-            gui::SpinBox *fullRhoStep,*trackingRhoStep,*nbPoints;
-            gui::DoubleSpinBox *fullThetaStep,*trackingThetaStep,*trackingDeltaTheta;
-            bool isTracking,lostLine,initLine,noLine;
-            int nbLines;
-            float yawMean,prevYawMean;
-            float prevRhoMean,rhoMean;
-            float prevThetaMean,thetaMean;
-            float distance,orientation;
-            CvMat* linesStorage;
-            core::Matrix *output;
+            class HoughLines_impl *pimpl_;
+            
+            
     };
 } // end namespace filter

trunk/lib/FlairVisionFilter/src/ImgThreshold.cpp

@@ -13 +13 @@
 
 #include "ImgThreshold.h"
-#include <cvimage.h>
+#include "VisionFilter.h"
+#include <Image.h>
 #include <Layout.h>
 #include <GroupBox.h>
@@ -23 +24 @@
 using namespace flair::gui;
 
+class ImgThreshold_impl {
+public:
+    ImgThreshold_impl(flair::filter::ImgThreshold *self,const LayoutPosition* position,string name):output(0) {
+        this->self=self;
+        
+        GroupBox* reglages_groupbox=new GroupBox(position,name);
+        threshold=new SpinBox(reglages_groupbox->NewRow(),"threshold:",0,255,1,127);
+
+        Printf("todo: pouvoir reutiliser la meme image en sortie\n");
+        try{
+            Image::Type const &imageType=dynamic_cast<Image::Type const &>(((IODevice*)(self->Parent()))->GetOutputDataType());
+            if(imageType.GetFormat()==Image::Type::Format::Gray) {
+                output=new Image(self,imageType.GetWidth(),imageType.GetHeight(),imageType.GetFormat(),"threshold");
+                //inIplImage = (IplImage*)AllocFunction(sizeof(IplImage));
+                //outIplImage = (IplImage*)AllocFunction(sizeof(IplImage));
+            } else {
+                self->Err("input image is not gray\n");
+            }
+        } catch(std::bad_cast& bc) {
+            self->Err("io type mismatch\n");
+        }
+
+        
+    }
+
+    ~ImgThreshold_impl() {
+        //FreeFunction((char*)(inIplImage));
+        //FreeFunction((char*)(outIplImage));
+    }
+    
+    void UpdateFrom(const io_data *data){
+        Image *img=(Image*)data;
+/*
+        data->GetMutex();
+        inIplImage->width=img->GetDataType().GetWidth();
+        inIplImage->height=img->GetDataType().GetHeight();
+        inIplImage->imageData=img->buffer;
+        inIplImage->imageSize=img->GetDataType().GetSize();
+        
+        output->GetMutex();
+        outIplImage->width=output->GetDataType().GetWidth();
+        outIplImage->height=output->GetDataType().GetHeight();
+        outIplImage->imageData=output->buffer;
+        outIplImage->imageSize=output->GetDataType().GetSize();
+                
+        dspThreshold(inIplImage,outIplImage, threshold->Value(), 255, CV_THRESH_BINARY);
+        output->ReleaseMutex();
+        data->ReleaseMutex();
+*/
+        output->SetDataTime(data->DataTime());
+    };
+    
+    Image *output;
+
+private:
+    flair::filter::ImgThreshold *self;
+    SpinBox *threshold;
+    //IplImage *inIplImage,*outIplImage;
+};
+
 namespace flair { namespace filter {
 
-ImgThreshold::ImgThreshold(const IODevice* parent,const LayoutPosition* position,string name) : IODevice(parent,name),output(0) {
-    GroupBox* reglages_groupbox=new GroupBox(position,name);
-    threshold=new SpinBox(reglages_groupbox->NewRow(),"threshold:",0,255,1,127);
-
-    Printf("todo: pouvoir reutiliser la meme image en sortie\n");
-    try{
-        cvimage::Type const &imageType=dynamic_cast<cvimage::Type const &>(parent->GetOutputDataType());
-        if(imageType.GetFormat()==cvimage::Type::Format::Gray) {
-            output=new cvimage(this,imageType.GetWidth(),imageType.GetHeight(),imageType.GetFormat(),"threshold");
-        } else {
-            Err("input image is not gray\n");
-            return;
-        }
-    } catch(std::bad_cast& bc) {
-        Err("io type mismatch\n");
-        return;
-    }
-    SetIsReady(true);
+ImgThreshold::ImgThreshold(const IODevice* parent,const LayoutPosition* position,string name) : IODevice(parent,name) {
+    pimpl_=new ImgThreshold_impl(this,position,name);
 }
 
 ImgThreshold::~ImgThreshold(void) {
+    delete pimpl_;
 }
 
-cvimage* ImgThreshold::Output(void) {
-    return output;
+Image* ImgThreshold::Output(void) {
+    return pimpl_->output;
 }
 
 void ImgThreshold::UpdateFrom(const io_data *data) {
- /*   cvimage *cvImage=(cvimage*)data;
-    IplImage *gimg=cvImage->img;
-
-    data->GetMutex();
-    output->GetMutex();
-    dspThreshold(gimg, output->img, threshold->Value(), 255, CV_THRESH_BINARY);
-    output->ReleaseMutex();
-    data->ReleaseMutex();
-*/
-    output->SetDataTime(data->DataTime());
-    ProcessUpdate(output);
+    pimpl_->UpdateFrom(data);
+    ProcessUpdate(pimpl_->output);
 }
 
 DataType const &ImgThreshold::GetOutputDataType() const {
-    if(output!=NULL) {
-        return output->GetDataType();
+    if(pimpl_->output!=NULL) {
+        return pimpl_->output->GetDataType();
     } else {
         return dummyType;

trunk/lib/FlairVisionFilter/src/ImgThreshold.h

@@ -12 +12 @@
 
 #include <IODevice.h>
-#include <cv.h>
 
 namespace flair {
     namespace core {
-        class cvimage;
+        class Image;
     }
     namespace gui {
         class LayoutPosition;
-        class SpinBox;
     }
 }
+
+class ImgThreshold_impl;
 
 namespace flair { namespace filter {
@@ -58 +58 @@
             * \return the output image
             */
-            core::cvimage* Output(void);
+            core::Image* Output(void);
 
             core::DataType const &GetOutputDataType() const;
@@ -64 +64 @@
         private:
             void UpdateFrom(const core::io_data *data);
-            core::cvimage *output;
-            gui::SpinBox *threshold;
+            class ImgThreshold_impl *pimpl_;
     };
 } // end namespace filter

trunk/lib/FlairVisionFilter/src/OpticalFlow.cpp

@@ -14 +14 @@
 #include "OpticalFlow.h"
 #include "OpticalFlowData.h"
-#include <cvimage.h>
+#include "VisionFilter.h"
+#include <Image.h>
 #include <Layout.h>
 #include <GroupBox.h>
 #include <SpinBox.h>
-//#include <algorithm>
 #include <OneAxisRotation.h>
-#include <Vector3D.h>
 #include <typeinfo>
 
@@ -30 +29 @@
 using namespace flair::gui;
 
+class OpticalFlow_impl {
+public:
+    OpticalFlow_impl(flair::filter::OpticalFlow *self,const LayoutPosition* position,string name) {
+        this->self=self;
+        is_init=false;
+
+        GroupBox* reglages_groupbox=new GroupBox(position,name);
+        rotation=new OneAxisRotation(reglages_groupbox->NewRow(),"post rotation",OneAxisRotation::PostRotation);
+        max_features=new SpinBox(reglages_groupbox->NewRow(),"max features:",1,65535,1,1);
+        
+        try{
+            Image::Type const &imageType=dynamic_cast<Image::Type const &>(((IODevice*)(self->Parent()))->GetOutputDataType());
+            pyr=new Image(self,imageType.GetWidth(),imageType.GetHeight(),Image::Type::Format::Gray);
+            pyr_old=new Image(self,imageType.GetWidth(),imageType.GetHeight(),Image::Type::Format::Gray);
+            output=new flair::filter::OpticalFlowData(self->Parent(),max_features->Value());
+/*
+            pointsA=(CvPoint*)AllocFunction(max_features->Value()*sizeof(CvPoint));
+            pointsB=(CvPoint*)AllocFunction(max_features->Value()*sizeof(CvPoint));
+
+            found_feature=(char*)AllocFunction(max_features->Value()*sizeof(char));
+            feature_error=(unsigned int*)AllocFunction(max_features->Value()*sizeof(unsigned int));
+            
+            iplgimg = (IplImage*)AllocFunction(sizeof(IplImage));
+            iplgimg_old = (IplImage*)AllocFunction(sizeof(IplImage));
+            iplpyr = (IplImage*)AllocFunction(sizeof(IplImage));
+            iplpyr_old = (IplImage*)AllocFunction(sizeof(IplImage));
+            
+            iplpyr->width=imageType.GetWidth();
+            iplpyr->height=imageType.GetHeight();
+            iplpyr->imageSize=imageType.GetSize();
+            iplpyr_old->width=imageType.GetWidth();
+            iplpyr_old->height=imageType.GetHeight();
+            iplpyr_old->imageSize=imageType.GetSize();
+            
+            iplgimg->roi=NULL;
+            iplgimg_old->roi=NULL;
+            iplpyr->roi=NULL;
+            iplpyr_old->roi=NULL;
+*/  
+      } catch(std::bad_cast& bc) {
+            self->Err("io type mismatch\n");
+            pyr=NULL;
+            pyr_old=NULL;
+        }
+      
+    }
+
+    ~OpticalFlow_impl() {
+        /*
+        FreeFunction((char*)pointsA);
+        FreeFunction((char*)pointsB);
+        FreeFunction((char*)found_feature);
+        FreeFunction((char*)feature_error);
+        FreeFunction((char*)iplgimg);
+        FreeFunction((char*)iplgimg_old);
+        FreeFunction((char*)iplpyr);
+        FreeFunction((char*)iplpyr_old);*/
+    }
+    
+    void UpdateFrom(const io_data *data){
+        //Time tStart=GetTime();
+        Image *img=(Image*)data;
+        Image *img_old=((Image*)data->Prev(1));
+/*
+        iplgimg->width=img->GetDataType().GetWidth();
+        iplgimg->height=img->GetDataType().GetHeight();
+        iplgimg->imageData=img->buffer;
+        iplgimg->imageSize=img->GetDataType().GetSize();
+        
+        iplgimg_old->width=img_old->GetDataType().GetWidth();
+        iplgimg_old->height=img_old->GetDataType().GetHeight();
+        iplgimg_old->imageData=img_old->buffer;
+        iplgimg_old->imageSize=img_old->GetDataType().GetSize();
+        
+        iplpyr->imageData=pyr->buffer;
+        iplpyr_old->imageData=pyr_old->buffer;
+
+        unsigned int count;
+        CvSize window = {3,3};
+        CvTermCriteria termination_criteria ={CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 20, .3 };
+        unsigned int i;
+
+        if(max_features->ValueChanged()==true) {
+            FreeFunction((char*)pointsA);
+            FreeFunction((char*)pointsB);
+            FreeFunction((char*)found_feature);
+            FreeFunction((char*)feature_error);
+            pointsA=(CvPoint*)AllocFunction(max_features->Value()*sizeof(CvPoint));
+            pointsB=(CvPoint*)AllocFunction(max_features->Value()*sizeof(CvPoint));
+            found_feature=(char*)AllocFunction(max_features->Value()*sizeof(char));
+            feature_error=(unsigned int*)AllocFunction(max_features->Value()*sizeof(unsigned int));
+
+            output->Resize(max_features->Value());
+        }
+
+        if(is_init==false) {
+            data->GetMutex();
+            //init image old
+            dspPyrDown(iplgimg,iplpyr_old,LEVEL_PYR);
+            data->ReleaseMutex();
+            is_init=true;
+            printf("ajouter mise a 0 des points\n");
+            return;
+        }
+
+        data->GetMutex();
+        data->Prev(1)->GetMutex();
+
+        //select good features
+        count=max_features->Value();
+        dspGoodFeaturesToTrack(iplgimg_old,pointsA,&count,0.08,5);
+        //pyramide
+        dspPyrDown(iplgimg,iplpyr,LEVEL_PYR);
+        //lk
+        dspCalcOpticalFlowPyrLK(iplgimg_old,iplgimg,iplpyr_old,iplpyr,pointsA,pointsB,count,window,LEVEL_PYR,found_feature,feature_error,termination_criteria,0) ;
+
+        data->Prev(1)->ReleaseMutex();
+        data->ReleaseMutex();
+
+        //apply rotation
+        for(i=0;i<count;i++) {
+            Vector3Df tmp;
+            tmp.x=pointsA[i].x;
+            tmp.y=pointsA[i].y;
+            tmp.z=0;
+            rotation->ComputeRotation(tmp);
+            pointsA[i].x=tmp.x;
+            pointsA[i].y=tmp.y;
+
+            tmp.x=pointsB[i].x;
+            tmp.y=pointsB[i].y;
+            tmp.z=0;
+            rotation->ComputeRotation(tmp);
+            pointsB[i].x=tmp.x;
+            pointsB[i].y=tmp.y;
+        }
+
+        output->GetMutex();
+        CvPoint2D32f* pointsBf= output->PointsB();
+        for(i=0;i<count;i++) {
+            pointsBf[i].x=pointsA[i].x+((float)pointsB[i].x)/256;
+            pointsBf[i].y=pointsA[i].y+((float)pointsB[i].y)/256;
+        }
+        output->ReleaseMutex();
+
+        output->SetPointsA(pointsA);
+        output->SetFoundFeature(found_feature);
+        output->SetFeatureError(feature_error);
+        output->SetNbFeatures(count);
+
+        //rotation
+        swap(pyr,pyr_old);
+*/
+        output->SetDataTime(data->DataTime());
+        //Printf("Optical flow computation time=%f\n",(GetTime()-tStart)/(1000.*1000));
+    };
+    
+    flair::filter::OpticalFlowData *output;
+
+private:
+    flair::filter::OpticalFlow *self;
+    SpinBox *max_features;
+    OneAxisRotation* rotation;
+
+    //CvPoint* pointsA;
+    //CvPoint* pointsB;
+    char *found_feature;
+    unsigned int *feature_error;
+    Image *pyr,*pyr_old;
+    //IplImage *iplgimg,*iplgimg_old;
+    //IplImage *iplpyr,*iplpyr_old;
+
+    bool is_init;
+};
+
+
 namespace flair
 {
@@ -35 +210 @@
 {
 
-OpticalFlow::OpticalFlow(const IODevice* parent,const LayoutPosition* position,string name) : IODevice(parent,name)
-{
+OpticalFlow::OpticalFlow(const IODevice* parent,const LayoutPosition* position,string name) : IODevice(parent,name) {
     Printf("optical flow: voir pour faire du multiple output\n");//pour pts A et B, found et error
-
-    try{
-        cvimage::Type const &imageType=dynamic_cast<cvimage::Type const &>(parent->GetOutputDataType());
-        pyr=cvCreateImage(cvSize(imageType.GetWidth(),imageType.GetHeight()),IPL_DEPTH_8U,1);
-        pyr_old=cvCreateImage(cvSize(imageType.GetWidth(),imageType.GetHeight()),IPL_DEPTH_8U,1);
-
-    } catch(std::bad_cast& bc) {
-        Err("io type mismatch\n");
-        pyr=NULL;
-        pyr_old=NULL;
-        return;
+    pimpl_=new OpticalFlow_impl(this,position,name);
+}
+
+OpticalFlow::~OpticalFlow(void) {
+    delete pimpl_;
+}
+
+void OpticalFlow::UpdateFrom(const io_data *data) {
+    pimpl_->UpdateFrom(data);
+    ProcessUpdate(pimpl_->output);
+}
+
+OpticalFlowData* OpticalFlow::Output(void) {
+    return pimpl_->output;
+
+}
+
+DataType const &OpticalFlow::GetOutputDataType() const {
+    if(pimpl_->output!=NULL) {
+        return pimpl_->output->GetDataType();
+    } else {
+        return dummyType;
     }
-
-    is_init=false;
-
-    GroupBox* reglages_groupbox=new GroupBox(position,name);
-    rotation=new OneAxisRotation(reglages_groupbox->NewRow(),"post rotation",OneAxisRotation::PostRotation);
-    max_features=new SpinBox(reglages_groupbox->NewRow(),"max features:",1,65535,1,1);
-
-    output=new OpticalFlowData(parent,max_features->Value());
-
-    pointsA=(CvPoint *)cvAlloc(max_features->Value()*sizeof(CvPoint));
-    pointsB=(CvPoint *)cvAlloc(max_features->Value()*sizeof(CvPoint));
-
-    found_feature=(char *)cvAlloc(max_features->Value()*sizeof(char));
-    feature_error=(unsigned int *)cvAlloc(max_features->Value()*sizeof(unsigned int));
-    
-    SetIsReady(true);
-}
-
-OpticalFlow::~OpticalFlow(void)
-{
-    cvReleaseImage(&pyr);
-    cvReleaseImage(&pyr_old);
-    cvFree(&pointsA);
-    cvFree(&pointsB);
-    cvFree(&found_feature);
-    cvFree(&feature_error);
-}
-
-void OpticalFlow::UpdateFrom(const io_data *data)
-{/*
-    IplImage *gimg=((cvimage*)data)->img;
-    IplImage *gimg_old=((cvimage*)data->Prev(1))->img;
-
-    unsigned int count;
-    CvSize window = cvSize(3,3);
-    CvTermCriteria termination_criteria = cvTermCriteria( CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 20, .3 );
-    unsigned int i;
-
-    if(max_features->ValueChanged()==true) {
-        cvFree(&pointsA);
-        cvFree(&pointsB);
-        cvFree(&found_feature);
-        cvFree(&feature_error);
-        pointsA=(CvPoint *)cvAlloc(max_features->Value()*sizeof(CvPoint));
-        pointsB=(CvPoint *)cvAlloc(max_features->Value()*sizeof(CvPoint));
-        found_feature=(char *)cvAlloc(max_features->Value()*sizeof(char));
-        feature_error=(unsigned int *)cvAlloc(max_features->Value()*sizeof(unsigned int));
-
-        output->Resize(max_features->Value());
-    }
-
-    if(is_init==false)
-    {
-        data->GetMutex();
-        //init image old
-        dspPyrDown(gimg,pyr_old,LEVEL_PYR);
-        data->ReleaseMutex();
-        is_init=true;
-        printf("ajouter mise a 0 des points\n");
-        return;
-    }
-
-    data->GetMutex();
-    data->Prev(1)->GetMutex();
-
-    //select good features
-    count=max_features->Value();
-    dspGoodFeaturesToTrack(gimg_old,pointsA,&count,0.08,5);
-    //pyramide
-    dspPyrDown(gimg,pyr,LEVEL_PYR);
-    //lk
-    dspCalcOpticalFlowPyrLK(gimg_old,gimg,pyr_old,pyr,pointsA,pointsB,count,window,LEVEL_PYR,found_feature,feature_error,termination_criteria,0) ;
-
-    data->Prev(1)->ReleaseMutex();
-    data->ReleaseMutex();
-
-    //apply rotation
-    for(i=0;i<count;i++) {
-        Vector3Df tmp;
-        tmp.x=pointsA[i].x;
-        tmp.y=pointsA[i].y;
-        tmp.z=0;
-        rotation->ComputeRotation(tmp);
-        pointsA[i].x=tmp.x;
-        pointsA[i].y=tmp.y;
-
-        tmp.x=pointsB[i].x;
-        tmp.y=pointsB[i].y;
-        tmp.z=0;
-        rotation->ComputeRotation(tmp);
-        pointsB[i].x=tmp.x;
-        pointsB[i].y=tmp.y;
-    }
-
-    output->GetMutex();
-    CvPoint2D32f* pointsBf= output->PointsB();
-    for(i=0;i<count;i++)
-    {
-        pointsBf[i].x=pointsA[i].x+((float)pointsB[i].x)/256;
-        pointsBf[i].y=pointsA[i].y+((float)pointsB[i].y)/256;
-    }
-    output->ReleaseMutex();
-
-    output->SetPointsA(pointsA);
-    output->SetFoundFeature(found_feature);
-    output->SetFeatureError(feature_error);
-    output->SetNbFeatures(count);
-
-    //rotation
-    swap(pyr,pyr_old);
-*/
-    output->SetDataTime(data->DataTime());
-    ProcessUpdate(output);
 }
 

trunk/lib/FlairVisionFilter/src/OpticalFlow.h

@@ -12 +12 @@
 
 #include <IODevice.h>
-#include <cv.h>
 
-namespace flair
-{
-    namespace core
-    {
-        class cvimage;
-        class OneAxisRotation;
+namespace flair {
+    namespace gui {
+        class LayoutPosition;
     }
-    namespace gui
-    {
-        class LayoutPosition;
-        class SpinBox;
-    }
-    namespace filter
-    {
+    namespace filter {
         class OpticalFlowData;
     }
 }
 
-namespace flair
-{
-namespace filter
-{
+class OpticalFlow_impl;
+
+namespace flair {
+namespace filter {
     /*! \class OpticalFlow
     *
@@ -63 +53 @@
             */
             ~OpticalFlow();
+            
+            filter::OpticalFlowData* Output(void);
+
+            core::DataType const &GetOutputDataType() const;
 
         private:
             void UpdateFrom(const core::io_data *data);
-            OpticalFlowData *output;
-            gui::SpinBox *max_features;
-            core::OneAxisRotation* rotation;
-
-            CvPoint* pointsA;
-            CvPoint* pointsB;
-            char *found_feature;
-            unsigned int *feature_error;
-            IplImage *pyr,*pyr_old;
-
-            bool is_init;
+            
+            class OpticalFlow_impl *pimpl_;
+            
     };
 } // end namespace filter

trunk/lib/FlairVisionFilter/src/OpticalFlowCompensated.cpp

@@ -32 +32 @@
 using namespace flair::gui;
 
+class OpticalFlowCompensated_impl {
+public:
+    OpticalFlowCompensated_impl(flair::filter::OpticalFlowCompensated *self,const flair::filter::Ahrs *ahrs, const LayoutPosition* position, string name): ahrs(ahrs), output(NULL) {
+        this->self=self;
+        previousStepsAngularRates=new Vector3Df*[10];
+        for (int i=0; i<10; i++) previousStepsAngularRates[i]=NULL;
+        previousStepsAngularRatesIndex=0;
+
+        GroupBox* reglages_groupbox=new GroupBox(position,name);
+        //TODO: the gyroDelay is set to compensate for the time difference between image snapshot et gyro measurements
+        //it is equal to the time between 2 images (because optical flow always lags 1 frame) + the time to compute optical flow
+        //here it is approximated by 2 video frames
+        gyroDelay=new SpinBox(reglages_groupbox->NewRow(),"gyro delay (in video frames):",0,10,1,2);
+        gyroGain=new DoubleSpinBox(reglages_groupbox->LastRowLastCol(),"gyro gain:",0.,500.,10.,2,300.);
+
+       
+    }
+
+    ~OpticalFlowCompensated_impl() {
+        delete output;
+    }
+    
+    void UpdateFrom(const io_data *data){
+        flair::filter::OpticalFlowData *input=(flair::filter::OpticalFlowData *)data;
+        if (!output) { //first pass
+            output=new flair::filter::OpticalFlowData(self,input->MaxFeatures(),input->ObjectName()+"_filtered");
+            previousTime=input->DataTime();
+            return;
+        }
+        //  float kX=320/Euler::ToRadian(70); //TEST: only for default simuCameraGL. fov=70° and image width=320 => k=320*180/(70*pi)
+        //  float kY=240/Euler::ToRadian(70); //TEST: only for default simuCameraGL. fov=70° and image height=240
+        float kX=gyroGain->Value();
+        float kY=gyroGain->Value();
+        float deltaT=(input->DataTime()-previousTime)/(1000*1000*1000.);
+        previousTime=input->DataTime();
+
+        int delayedIndex=previousStepsAngularRatesIndex-gyroDelay->Value(); // Ahhh décalage, esprit canal...
+        if (delayedIndex<0) delayedIndex+=10;
+
+        if (!previousStepsAngularRates[previousStepsAngularRatesIndex]) {
+            previousStepsAngularRates[previousStepsAngularRatesIndex]=new Vector3Df();
+        }
+        *previousStepsAngularRates[previousStepsAngularRatesIndex++]=ahrs->GetDatas()->GetAngularRates();
+
+        if (!previousStepsAngularRates[delayedIndex]) return;
+        float rotationFlowX=previousStepsAngularRates[delayedIndex]->y*deltaT*kY;
+        float rotationFlowY=-previousStepsAngularRates[delayedIndex]->x*deltaT*kX;
+        if (previousStepsAngularRatesIndex==10) previousStepsAngularRatesIndex=0;
+        input->GetMutex();
+        output->GetMutex();
+
+        for (int i=0; i<input->NbFeatures(); i++) {
+            output->PointsA()[i].x=input->PointsA()[i].x;
+            output->PointsA()[i].y=input->PointsA()[i].y;
+            output->PointsB()[i].x=input->PointsB()[i].x-rotationFlowX;
+            output->PointsB()[i].y=input->PointsB()[i].y-rotationFlowY;
+        }
+        output->SetNbFeatures(input->NbFeatures());
+        output->SetFoundFeature(input->FoundFeature());
+        output->SetFeatureError(input->FeatureError());
+
+        output->ReleaseMutex();
+        input->ReleaseMutex();
+
+        output->SetDataTime(input->DataTime());
+           
+    };
+    
+    flair::filter::OpticalFlowData *output;
+
+private:
+    flair::filter::OpticalFlowCompensated *self;
+    Time previousTime;
+    const flair::filter::Ahrs *ahrs;
+    Vector3Df **previousStepsAngularRates;
+    unsigned int previousStepsAngularRatesIndex;
+    SpinBox *gyroDelay;
+    DoubleSpinBox *gyroGain;
+};
+
+
 namespace flair {
 namespace filter {
 
-OpticalFlowCompensated::OpticalFlowCompensated(const OpticalFlow *parent, const Ahrs *ahrs, const LayoutPosition* position, string name) : IODevice(parent, name), ahrs(ahrs), output(NULL) {
-  MatrixDescriptor* desc=new MatrixDescriptor(3,2);
-  desc->SetElementName(0,0,"raw displacement X");
-  desc->SetElementName(0,1,"raw displacement Y");
-  desc->SetElementName(1,0,"compensation X");
-  desc->SetElementName(1,1,"compensation Y");
-  desc->SetElementName(2,0,"displacement with compensation X");
-  desc->SetElementName(2,0,"displacement with compensation Y");
-  firstPointDisplacement=new Matrix(this,desc,floatType,name);
-  delete desc;
-  previousStepsAngularRates=new Vector3Df*[10];
-  for (int i=0; i<10; i++) previousStepsAngularRates[i]=NULL;
-  previousStepsAngularRatesIndex=0;
-
-  GroupBox* reglages_groupbox=new GroupBox(position,name);
-  //TODO: the gyroDelay is set to compensate for the time difference between image snapshot et gyro measurements
-//it is equal to the time between 2 images (because optical flow always lags 1 frame) + the time to compute optical flow
-//here it is approximated by 2 video frames
-  gyroDelay=new SpinBox(reglages_groupbox->NewRow(),"gyro delay (in video frames):",0,10,1,2);
-  gyroGain=new DoubleSpinBox(reglages_groupbox->LastRowLastCol(),"gyro gain:",0.,500.,10.,2,300.);
+OpticalFlowCompensated::OpticalFlowCompensated(const OpticalFlow *parent, const Ahrs *ahrs, const LayoutPosition* position, string name) : IODevice(parent, name) {
+    pimpl_=new OpticalFlowCompensated_impl(this,ahrs,position,name);
 
 }
 
 OpticalFlowCompensated::~OpticalFlowCompensated() {
-  delete output;
+    delete pimpl_;
 }
 
 void OpticalFlowCompensated::UpdateFrom(const io_data *data) {
-  OpticalFlowData *input=(OpticalFlowData *)data;
-  if (!output) { //first pass
-    output=new OpticalFlowData(this,input->MaxFeatures(),input->ObjectName()+"_filtered");
-    previousTime=input->DataTime();
-    return;
-  }
-//  float kX=320/Euler::ToRadian(70); //TEST: only for default simuCameraGL. fov=70° and image width=320 => k=320*180/(70*pi)
-//  float kY=240/Euler::ToRadian(70); //TEST: only for default simuCameraGL. fov=70° and image height=240
-  float kX=gyroGain->Value();
-  float kY=gyroGain->Value();
-  float deltaT=(input->DataTime()-previousTime)/(1000*1000*1000.);
-  previousTime=input->DataTime();
-
-  int delayedIndex=previousStepsAngularRatesIndex-gyroDelay->Value(); // Ahhh décalage, esprit canal...
-  if (delayedIndex<0) delayedIndex+=10;
-
-  if (!previousStepsAngularRates[previousStepsAngularRatesIndex]) {
-    previousStepsAngularRates[previousStepsAngularRatesIndex]=new Vector3Df();
-  }
-  *previousStepsAngularRates[previousStepsAngularRatesIndex++]=ahrs->GetDatas()->GetAngularRates();
-
-  if (!previousStepsAngularRates[delayedIndex]) return;
-  float rotationFlowX=previousStepsAngularRates[delayedIndex]->y*deltaT*kY;
-  float rotationFlowY=-previousStepsAngularRates[delayedIndex]->x*deltaT*kX;
-  if (previousStepsAngularRatesIndex==10) previousStepsAngularRatesIndex=0;
-  input->GetMutex();
-  output->GetMutex();
-
-  for (int i=0; i<input->NbFeatures(); i++) {
-    if (!i) {
-      firstPointDisplacement->SetValue(0,0,input->PointsB()[i].x-input->PointsA()[i].x);
-      firstPointDisplacement->SetValue(0,1,input->PointsB()[i].y-input->PointsA()[i].y);
-      firstPointDisplacement->SetValue(1,0,-rotationFlowX);
-      firstPointDisplacement->SetValue(1,1,-rotationFlowY);
-      firstPointDisplacement->SetValue(2,0,input->PointsB()[i].x-input->PointsA()[i].x-rotationFlowX);
-      firstPointDisplacement->SetValue(2,1,input->PointsB()[i].y-input->PointsA()[i].y-rotationFlowY);
-    }
-    output->PointsA()[i].x=input->PointsA()[i].x;
-    output->PointsA()[i].y=input->PointsA()[i].y;
-    output->PointsB()[i].x=input->PointsB()[i].x-rotationFlowX;
-    output->PointsB()[i].y=input->PointsB()[i].y-rotationFlowY;
-  }
-  output->SetNbFeatures(input->NbFeatures());
-  output->SetFoundFeature(input->FoundFeature());
-  output->SetFeatureError(input->FeatureError());
-
-  output->ReleaseMutex();
-  input->ReleaseMutex();
-
-  output->SetDataTime(input->DataTime());
-  ProcessUpdate(output);
+    pimpl_->UpdateFrom(data);
+    ProcessUpdate(pimpl_->output);
 }
 
-  Matrix *OpticalFlowCompensated::GetFirstPointDisplacement() const {
-    return firstPointDisplacement;
-  }
 
 } // end namespace filter

trunk/lib/FlairVisionFilter/src/OpticalFlowCompensated.h

@@ -16 +16 @@
 #include <IODevice.h>
 #include <Object.h>
-#include <Vector3D.h>
 
 namespace flair {
-  namespace core {
-    class io_data;
-    class Matrix;
-  }
   namespace gui {
     class LayoutPosition;
-    class SpinBox;
-    class DoubleSpinBox;
   }
   namespace filter {
     class Ahrs;
     class OpticalFlow;
-    class OpticalFlowData;
   }
 }
+
+class OpticalFlowCompensated_impl;
 
 namespace flair { namespace filter {
@@ -61 +55 @@
   ~OpticalFlowCompensated();
 
-  void UpdateFrom(const core::io_data *data);
-
-  core::Matrix *GetFirstPointDisplacement() const;
 private:
-  OpticalFlowData *output;
-  core::Time previousTime;
-  const Ahrs *ahrs;
-  core::Matrix *firstPointDisplacement;
-  core::Vector3Df **previousStepsAngularRates;
-  unsigned int previousStepsAngularRatesIndex;
-  gui::SpinBox *gyroDelay;
-  gui::DoubleSpinBox *gyroGain;
+    void UpdateFrom(const core::io_data *data);
+    OpticalFlowCompensated_impl *pimpl_;
+  
 };
 

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();
 }

trunk/lib/FlairVisionFilter/src/OpticalFlowData.h

@@ -10 +10 @@
 #define OPTICALFLOWDATA_H
 
-#include <cxcore.h>
 #include <io_data.h>
+
+//TODO: use flair::core::Vector2D
+typedef struct IntPoint {
+    int x;
+    int y;
+}
+IntPoint;
+
+typedef struct FloatPoint {
+    float x;
+    float y;
+}
+FloatPoint;
+
+class OpticalFlowData_impl;
 
 namespace flair { namespace filter {
@@ -53 +67 @@
         *
     */
-        CvPoint* PointsA(void) const;
+        IntPoint* PointsA(void) const;
 
         /*!
@@ -59 +73 @@
         *
         */
-        CvPoint2D32f* PointsB(void) const;
+        FloatPoint* PointsB(void) const;
 
         /*!
@@ -79 +93 @@
         * \param points points
         */
-        void SetPointsA(const CvPoint *points);
+        void SetPointsA(const IntPoint *points);
 
         /*!
@@ -86 +100 @@
         * \param points points
         */
-        void SetPointsB(const CvPoint2D32f *points);
+        void SetPointsB(const FloatPoint *points);
 
         /*!
@@ -139 +153 @@
         */
         void RawRead(char *dst) const;
-
+        
     private:
-        uint32_t max_features;
-        uint32_t nb_features;
-        CvPoint* pointsA;
-        CvPoint2D32f* pointsB;
-        char *found_features;
-        uint32_t *features_error;
         Type dataType;
+        OpticalFlowData_impl *pimpl_;
     };
 } // end namespace filter

trunk/lib/FlairVisionFilter/src/OpticalFlowSpeed.cpp

@@ -26 +26 @@
 using namespace flair::gui;
 
+class OpticalFlowSpeed_impl {
+public:
+    OpticalFlowSpeed_impl(flair::filter::OpticalFlowSpeed *self,const LayoutPosition* position,string name):output(0) {
+        this->self=self;
+        MatrixDescriptor* desc=new MatrixDescriptor(2,1);
+        desc->SetElementName(0,0,"vx");
+        desc->SetElementName(1,0,"vy");
+        output=new Matrix(self,desc,floatType,name);
+        delete desc;
+
+        self->AddDataToLog(output);
+
+        GroupBox* reglages_groupbox=new GroupBox(position,name);
+        quality=new DoubleSpinBox(reglages_groupbox->LastRowLastCol(),"optical flow quality:",0.,100.,1.,1,5.);
+        weightedAverage=new CheckBox(reglages_groupbox->LastRowLastCol(),"Weighted average", true);
+        timeMultiplication=new CheckBox(reglages_groupbox->LastRowLastCol(),"Time multiplication", true);
+
+       
+    }
+
+    ~OpticalFlowSpeed_impl() {
+       
+    }
+    
+    void UpdateFrom(const io_data *data){
+        flair::filter::OpticalFlowData *input=(flair::filter::OpticalFlowData*)data;
+        float deplx,deply;
+        float nb_depl=0;
+
+        deplx=0;
+        deply=0;
+
+        //error is 0 if perfect match and 7x7x255x255 at worst
+        float qualityThreshold=quality->Value()/100.*7*7*255*255;
+        input->GetMutex();
+        int nbUsedPoints=0;
+        for(int i=0;i<input->NbFeatures();i++) {
+            //if point is found in both images and quality is sufficient
+            if((input->FoundFeature()[i]!=0)&&(input->FeatureError()[i]<qualityThreshold)) {
+              nbUsedPoints++;
+              float qualityFactor=1.0;
+              if (weightedAverage->Value()) {
+                //displacement is weigthed by quality
+                qualityFactor/=(1+input->FeatureError()[i]);
+              } 
+                deplx+=(input->PointsB()[i].x-input->PointsA()[i].x)*qualityFactor;
+                deply+=(input->PointsB()[i].y-input->PointsA()[i].y)*qualityFactor;
+                nb_depl+=qualityFactor;
+            }
+        }
+        input->ReleaseMutex();
+        float deltaT;
+        if (timeMultiplication->Value()) deltaT=(float)(data->DataTime()-output->DataTime())/(1000.*1000.*1000.);
+        else deltaT=1.;
+        output->SetDataTime(data->DataTime());
+
+        if(nb_depl!=0) {
+    //Printf("Nombre de points=%d/%d (nb_depl=%f,pondération=%d), deltaT=%f\n",nbUsedPoints,input->NbFeatures(),nb_depl,weightedAverage->Value(),deltaT);
+            output->SetValue(0,0,deplx/(nb_depl*deltaT));
+            output->SetValue(1,0,deply/(nb_depl*deltaT));
+        }
+    };
+    
+    Matrix *output;
+   
+private:
+    flair::filter::OpticalFlowSpeed *self;    
+    DoubleSpinBox *quality;
+    CheckBox *weightedAverage;
+    CheckBox *timeMultiplication;
+};
+
 namespace flair { namespace filter {
 
 OpticalFlowSpeed::OpticalFlowSpeed(const IODevice* parent, const LayoutPosition* position,string name) : IODevice(parent,name) {
-  MatrixDescriptor* desc=new MatrixDescriptor(2,1);
-  desc->SetElementName(0,0,"vx");
-  desc->SetElementName(1,0,"vy");
-  output=new Matrix(this,desc,floatType,name);
-  delete desc;
-
-  AddDataToLog(output);
-
-  GroupBox* reglages_groupbox=new GroupBox(position,name);
-  quality=new DoubleSpinBox(reglages_groupbox->LastRowLastCol(),"optical flow quality:",0.,100.,1.,1,5.);
-  weightedAverage=new CheckBox(reglages_groupbox->LastRowLastCol(),"Weighted average", true);
-  timeMultiplication=new CheckBox(reglages_groupbox->LastRowLastCol(),"Time multiplication", true);
+    pimpl_=new OpticalFlowSpeed_impl(this,position,name);
 }
 
-OpticalFlowSpeed::~OpticalFlowSpeed(void) { }
+OpticalFlowSpeed::~OpticalFlowSpeed(void) {
+    delete pimpl_;
+}
 
 void OpticalFlowSpeed::UpdateFrom(const io_data *data) {
-    OpticalFlowData *input=(OpticalFlowData*)data;
-    float deplx,deply;
-    float nb_depl=0;
-
-    deplx=0;
-    deply=0;
-
-    //error is 0 if perfect match and 7x7x255x255 at worst
-    float qualityThreshold=quality->Value()/100.*7*7*255*255;
-    input->GetMutex();
-    int nbUsedPoints=0;
-    for(int i=0;i<input->NbFeatures();i++) {
-        //if point is found in both images and quality is sufficient
-        if((input->FoundFeature()[i]!=0)&&(input->FeatureError()[i]<qualityThreshold)) {
-          nbUsedPoints++;
-          float qualityFactor=1.0;
-          if (weightedAverage->Value()) {
-            //displacement is weigthed by quality
-            qualityFactor/=(1+input->FeatureError()[i]);
-          } 
-            deplx+=(input->PointsB()[i].x-input->PointsA()[i].x)*qualityFactor;
-            deply+=(input->PointsB()[i].y-input->PointsA()[i].y)*qualityFactor;
-            nb_depl+=qualityFactor;
-        }
-    }
-    input->ReleaseMutex();
-    float deltaT;
-    if (timeMultiplication->Value()) deltaT=(float)(data->DataTime()-output->DataTime())/(1000.*1000.*1000.);
-    else deltaT=1.;
-    output->SetDataTime(data->DataTime());
-
-    if(nb_depl!=0) {
-//Printf("Nombre de points=%d/%d (nb_depl=%f,pondération=%d), deltaT=%f\n",nbUsedPoints,input->NbFeatures(),nb_depl,weightedAverage->Value(),deltaT);
-        output->SetValue(0,0,deplx/(nb_depl*deltaT));
-        output->SetValue(1,0,deply/(nb_depl*deltaT));
-    }
-//    output->SetDataTime(data->DataTime());
-    ProcessUpdate(output);
+    pimpl_->UpdateFrom(data);
+    ProcessUpdate(pimpl_->output);
 }
 
 float OpticalFlowSpeed::Vx(void) const {
-    return output->Value(0,0);
+    return pimpl_->output->Value(0,0);
 }
 
 float OpticalFlowSpeed::Vy(void) const {
-    return output->Value(1,0);
+    return pimpl_->output->Value(1,0);
 }
 
 core::Matrix *OpticalFlowSpeed::Output() const {
-    return output;
+    return pimpl_->output;
 }
 } // end namespace filter

trunk/lib/FlairVisionFilter/src/OpticalFlowSpeed.h

@@ -21 +21 @@
   namespace gui {
     class LayoutPosition;
-    class SpinBox;
-    class DoubleSpinBox;
-    class CheckBox;
   }
 }
+
+class OpticalFlowSpeed_impl;
 
 namespace flair
@@ -88 +87 @@
             */
             void UpdateFrom(const core::io_data *data);
-
-            core::Matrix *output;
-      gui::DoubleSpinBox *quality;
-      gui::CheckBox *weightedAverage;
-      gui::CheckBox *timeMultiplication;
+            
+            OpticalFlowSpeed_impl *pimpl_;
 };
 

trunk/lib/FlairVisionFilter/src/Sobel.cpp

@@ -13 +13 @@
 
 #include "Sobel.h"
-#include <cvimage.h>
+#include "VisionFilter.h"
+#include <Image.h>
 #include <Layout.h>
 #include <GroupBox.h>
@@ -23 +24 @@
 using namespace flair::gui;
 
+class Sobel_impl {
+public:
+    Sobel_impl(flair::filter::Sobel *self,const LayoutPosition* position,string name):output(0) {
+        this->self=self;
+        
+        GroupBox* reglages_groupbox=new GroupBox(position,name);
+        dx=new SpinBox(reglages_groupbox->NewRow(),"dx:",0,1,1,1);
+        dy=new SpinBox(reglages_groupbox->NewRow(),"dy:",0,1,1,1);
+
+        Printf("TODO: IODevice doit faire un check de GetInputDataType et GetOutputDataType\n");
+        //Image devrait accepter un type dans son constructeur pour construire un type identique
+        try{
+            Image::Type const &imageType=dynamic_cast<Image::Type const &>(((IODevice*)(self->Parent()))->GetOutputDataType());
+            if(imageType.GetFormat()==Image::Type::Format::Gray) {
+                output=new Image(self,imageType.GetWidth(),imageType.GetHeight(),imageType.GetFormat(),"sobel");
+                //inIplImage = (IplImage*)AllocFunction(sizeof(IplImage));
+                //outIplImage = (IplImage*)AllocFunction(sizeof(IplImage));
+            } else {
+                self->Err("input image is not gray\n");
+            }
+
+        } catch(std::bad_cast& bc) {
+            self->Err("io type mismatch\n");
+        }
+    }
+
+    ~Sobel_impl() {
+        //FreeFunction((char*)(inIplImage));
+        //FreeFunction((char*)(outIplImage));
+    }
+    
+    void UpdateFrom(const io_data *data){
+        Image *image=(Image*)data;
+/*
+        data->GetMutex();
+        inIplImage->width=image->GetDataType().GetWidth();
+        inIplImage->height=image->GetDataType().GetHeight();
+        inIplImage->imageData=image->buffer;
+        inIplImage->imageSize=image->GetDataType().GetSize();
+        
+        output->GetMutex();
+        outIplImage->width=output->GetDataType().GetWidth();
+        outIplImage->height=output->GetDataType().GetHeight();
+        outIplImage->imageData=output->buffer;
+        outIplImage->imageSize=output->GetDataType().GetSize();
+                
+        dspSobel(inIplImage,outIplImage,dx->Value(),dy->Value());
+        output->ReleaseMutex();
+        data->ReleaseMutex();
+*/
+        output->SetDataTime(data->DataTime());
+
+    };
+    
+    Image *output;
+
+private:
+    flair::filter::Sobel *self;
+    SpinBox *dx;
+    SpinBox *dy;
+    //IplImage *inIplImage,*outIplImage;
+};
+
 namespace flair { namespace filter {
 
-Sobel::Sobel(const IODevice* parent,const LayoutPosition* position,string name) : IODevice(parent,name),output(0) {
-    GroupBox* reglages_groupbox=new GroupBox(position,name);
-    dx=new SpinBox(reglages_groupbox->NewRow(),"dx:",0,1,1,1);
-    dy=new SpinBox(reglages_groupbox->NewRow(),"dy:",0,1,1,1);
-
-    Printf("TODO: IODevice doit faire un check de GetInputDataType et GetOutputDataType\n");
-    //cvimage devrait accepter un type dans son constructeur pour construire un type identique
-    try{
-        cvimage::Type const &imageType=dynamic_cast<cvimage::Type const &>(parent->GetOutputDataType());
-        if(imageType.GetFormat()==cvimage::Type::Format::Gray) {
-            output=new cvimage(this,imageType.GetWidth(),imageType.GetHeight(),imageType.GetFormat(),"sobel");
-        } else {
-            Err("input image is not gray\n");
-            return;
-        }
-
-    } catch(std::bad_cast& bc) {
-        Err("io type mismatch\n");
-        return;
-    }
-    SetIsReady(true);
+Sobel::Sobel(const IODevice* parent,const LayoutPosition* position,string name) : IODevice(parent,name) {
+   pimpl_=new Sobel_impl(this,position,name);
 }
 
 Sobel::~Sobel(void) {
+    delete pimpl_;
 }
 
-cvimage* Sobel::Output(void) {
-    return output;
+Image* Sobel::Output(void) {
+    return pimpl_->output;
 }
 
-void Sobel::UpdateFrom(const io_data *data) {/*
-    cvimage *cvImage=(cvimage*)data;
-    IplImage *gimg=cvImage->img;
-
-    data->GetMutex();
-    output->GetMutex();
-    dspSobel(gimg,output->img,dx->Value(),dy->Value());
-    output->ReleaseMutex();
-    data->ReleaseMutex();
-*/
-    output->SetDataTime(data->DataTime());
-    ProcessUpdate(output);
+void Sobel::UpdateFrom(const io_data *data) {
+    pimpl_->UpdateFrom(data);
+    ProcessUpdate(pimpl_->output);
 }
 
 DataType const &Sobel::GetOutputDataType() const {
-    if(output!=NULL) {
-        return output->GetDataType();
+    if(pimpl_->output!=NULL) {
+        return pimpl_->output->GetDataType();
     } else {
         return dummyType;

trunk/lib/FlairVisionFilter/src/Sobel.h

@@ -12 +12 @@
 
 #include <IODevice.h>
-#include <cv.h>
+
 
 namespace flair {
     namespace core {
-        class cvimage;
+        class Image;
     }
     namespace gui {
         class LayoutPosition;
-        class SpinBox;
     }
 }
+
+ class Sobel_impl;
 
 namespace flair { namespace filter {
@@ -58 +59 @@
             * \return the output image
             */
-            core::cvimage* Output(void);
+            core::Image* Output(void);
 
             core::DataType const &GetOutputDataType() const;
@@ -64 +65 @@
         private:
             void UpdateFrom(const core::io_data *data);
-            core::cvimage *output;
-            gui::SpinBox *dx;
-            gui::SpinBox *dy;
+            Sobel_impl *pimpl_;
     };
 } // end namespace filter

trunk/lib/FlairVisionFilter/src/VisionFilter.cpp

@@ -1 +1 @@
 #include "VisionFilter.h"
 #include "compile_info.h"
-#include <highgui.h>
 
 static void constructor() __attribute__((constructor));
@@ -9 +8 @@
 }
 
-void saveToJpeg(IplImage* src_img,std::string filename,PictureFormat_t input_format,PictureFormat_t output_format,unsigned char compression_level) {
-        if(!cvSaveImage(filename.c_str(),src_img)) printf("Could not save.\n");
+void saveToJpeg(flair::core::Image* src_img,std::string filename,PictureFormat_t input_format,PictureFormat_t output_format,unsigned char compression_level) {
+        printf("saveToJpeg todo\n");
+    //if(!cvSaveImage(filename.c_str(),src_img)) printf("Could not save.\n");
 }
 
@@ -21 +21 @@
   
 }
+
+char* AllocFunction(ssize_t size) {
+    return (char*)malloc(size);
+}
+
+void FreeFunction(char* buffer) {
+    free(buffer);
+}

trunk/lib/FlairVisionFilter/src/VisionFilter.h

@@ -1 +1 @@
 #include <string>
-#include <cxtypes.h>
+
+namespace flair {
+    namespace core {
+        class Image;
+    }
+}
+
 
 /*!
@@ -19 +25 @@
                 } ;
                                                                 
-void saveToJpeg(IplImage* src_img,std::string filename,PictureFormat_t input_format,PictureFormat_t output_format,unsigned char compression_level=95);
+void saveToJpeg(flair::core::Image* src_img,std::string filename,PictureFormat_t input_format,PictureFormat_t output_format,unsigned char compression_level=95);
+
+//for amrv7a, these functions use CMEM
+char* AllocFunction(ssize_t size);
+void FreeFunction(char* buffer);