Changeset 214 in flair-src for trunk/lib/FlairFilter


Ignore:
Timestamp:
Feb 7, 2018, 5:49:27 PM (4 years ago)
Author:
Sanahuja Guillaume
Message:

matrix

Location:
trunk/lib/FlairFilter/src
Files:
38 edited

Legend:

Unmodified
Added
Removed
  • trunk/lib/FlairFilter/src/ButterworthLowPass.cpp

    r162 r214  
    1818#include "ButterworthLowPass.h"
    1919#include "ButterworthLowPass_impl.h"
    20 #include <cvmatrix.h>
     20#include <Matrix.h>
    2121#include <Layout.h>
    2222#include <LayoutPosition.h>
     
    4848ButterworthLowPass::~ButterworthLowPass() { delete pimpl_; }
    4949
    50 cvmatrix *ButterworthLowPass::Matrix(void) const { return pimpl_->output; }
     50Matrix *ButterworthLowPass::GetMatrix(void) const { return pimpl_->output; }
    5151
    5252float ButterworthLowPass::Output(void) const {
  • trunk/lib/FlairFilter/src/ButterworthLowPass.h

    r162 r214  
    1818namespace flair {
    1919namespace core {
    20 class cvmatrix;
     20class Matrix;
    2121}
    2222namespace gui {
     
    9191  * \return filtered output
    9292  */
    93   core::cvmatrix *Matrix(void) const;
     93  core::Matrix *GetMatrix(void) const;
    9494
    9595  /*!
  • trunk/lib/FlairFilter/src/ButterworthLowPass_impl.cpp

    r165 r214  
    1818#include "ButterworthLowPass_impl.h"
    1919#include "ButterworthLowPass.h"
    20 #include <cvmatrix.h>
     20#include <Matrix.h>
    2121#include <Layout.h>
    2222#include <GroupBox.h>
     
    2929using namespace flair::filter;
    3030
    31 ButterworthLowPass_impl::ButterworthLowPass_impl(ButterworthLowPass *self,
     31ButterworthLowPass_impl::ButterworthLowPass_impl(const ButterworthLowPass *self,
    3232                                                 const LayoutPosition *position,
    3333                                                 string name, uint32_t order,uint32_t nbRow,uint32_t nbCol) {
     
    4141  cvmatrix_descriptor *desc = new cvmatrix_descriptor(nbRow, nbCol);
    4242  //desc->SetElementName(0, 0, "output");
    43   output = new cvmatrix(self, desc, floatType, name);
     43  output = new Matrix(self, desc, floatType, name);
    4444  delete desc;
    4545
     
    6060  this->nbRow=nbRow;
    6161  this->nbCol=nbCol;
     62  this->self=self;
    6263}
    6364
     
    7273
    7374void ButterworthLowPass_impl::UpdateFrom(const io_data *data) {
    74   cvmatrix *input = (cvmatrix *)data;
    7575  float delta_t;
     76  const Matrix* input = dynamic_cast<const Matrix*>(data);
     77 
     78  if (!input) {
     79      self->Warn("casting %s to Matrix failed\n",data->ObjectName().c_str());
     80      return;
     81  }
    7682 
    7783  if (T->ValueChanged() && T->Value() != 0) {
  • trunk/lib/FlairFilter/src/ControlLaw.cpp

    r148 r214  
    1717
    1818#include "ControlLaw.h"
    19 #include <cvmatrix.h>
     19#include <Matrix.h>
    2020#include <cvmatrix_descriptor.h>
    2121#include <DataPlot1D.h>
     
    3232    : IODevice(parent, name) {
    3333  if (nb_out == 1) {
    34     output = new cvmatrix(this, nb_out, 1, floatType, name);
     34    output = new Matrix(this, nb_out, 1, floatType, name);
    3535  } else {
    3636    cvmatrix_descriptor *desc = new cvmatrix_descriptor(nb_out, 1);
     
    4040      desc->SetElementName(i, 0, ss.str());
    4141    }
    42     output = new cvmatrix(this, desc, floatType, name);
     42    output = new Matrix(this, desc, floatType, name);
    4343    delete desc;
    4444  }
  • trunk/lib/FlairFilter/src/ControlLaw.h

    r15 r214  
    2121}
    2222namespace core {
    23 class cvmatrix;
     23class Matrix;
    2424}
    2525}
     
    100100  *
    101101  */
    102   core::cvmatrix *input;
     102  core::Matrix *input;
    103103
    104104  /*!
     
    109109  *
    110110  */
    111   core::cvmatrix *output;
     111  core::Matrix *output;
    112112
    113113private:
  • trunk/lib/FlairFilter/src/EulerDerivative.cpp

    r157 r214  
    1818#include "EulerDerivative.h"
    1919#include "EulerDerivative_impl.h"
    20 #include <cvmatrix.h>
     20#include <Matrix.h>
    2121#include <LayoutPosition.h>
    2222
     
    3030EulerDerivative::EulerDerivative(const IODevice *parent,
    3131                                 const LayoutPosition *position, string name,
    32                                  const cvmatrix *init_value)
     32                                 const Matrix *init_value)
    3333    : IODevice(parent, name) {
    3434  pimpl_ = new EulerDerivative_impl(this, position, name, init_value);
     
    4040EulerDerivative::~EulerDerivative() { delete pimpl_; }
    4141
    42 cvmatrix *EulerDerivative::Matrix(void) const { return pimpl_->output; }
     42Matrix *EulerDerivative::GetMatrix(void) const { return pimpl_->output; }
    4343
    4444float EulerDerivative::Output(int row, int col) const {
  • trunk/lib/FlairFilter/src/EulerDerivative.h

    r147 r214  
    1818namespace flair {
    1919namespace core {
    20 class cvmatrix;
     20class Matrix;
    2121}
    2222namespace gui {
     
    5656  EulerDerivative(const core::IODevice *parent,
    5757                  const gui::LayoutPosition *position, std::string name,
    58                   const core::cvmatrix *init_value = NULL);
     58                  const core::Matrix *init_value = NULL);
    5959
    6060  /*!
     
    7979  * \return filtered output
    8080  */
    81   core::cvmatrix *Matrix(void) const;
     81  core::Matrix *GetMatrix(void) const;
    8282
    8383private:
  • trunk/lib/FlairFilter/src/EulerDerivative_impl.cpp

    r148 r214  
    1818#include "EulerDerivative.h"
    1919#include "EulerDerivative_impl.h"
    20 #include <cvmatrix.h>
     20#include <Matrix.h>
    2121#include <Layout.h>
    2222#include <GroupBox.h>
     
    3131                                           const LayoutPosition *position,
    3232                                           string name,
    33                                            const cvmatrix *init_value) {
     33                                           const Matrix *init_value) {
    3434  first_update = true;
     35  this->self = self;
    3536 
    3637  if (init_value != NULL) {
     
    4344      }
    4445    }
    45     output = new cvmatrix(self, desc,init_value->GetDataType().GetElementDataType(), name);
     46    output = new Matrix(self, desc,init_value->GetDataType().GetElementDataType(), name);
    4647    delete desc;
    4748    for (int i = 0; i < init_value->Rows(); i++) {
     
    5455    cvmatrix_descriptor *desc = new cvmatrix_descriptor(1, 1);
    5556    desc->SetElementName(0, 0, "output");
    56     output = new cvmatrix(self, desc, floatType, name);
     57    output = new Matrix(self, desc, floatType, name);
    5758    delete desc;
    5859  }
     
    6061 
    6162  cvmatrix_descriptor *desc = new cvmatrix_descriptor(output->Rows(), output->Cols());
    62   prev_value = new cvmatrix(self, desc, output->GetDataType().GetElementDataType(), name);
     63  prev_value = new Matrix(self, desc, output->GetDataType().GetElementDataType(), name);
    6364
    6465
     
    7374void EulerDerivative_impl::UpdateFrom(const io_data *data) {
    7475  float delta_t;
    75   cvmatrix *input = (cvmatrix *)data;
     76  const Matrix* input = dynamic_cast<const Matrix*>(data);
     77 
     78  if (!input) {
     79      self->Warn("casting %s to Matrix failed\n",data->ObjectName().c_str());
     80      return;
     81  }
    7682
    7783  // on prend une fois pour toute les mutex et on fait des accès directs
  • trunk/lib/FlairFilter/src/JoyReference.cpp

    r157 r214  
    2020#include <Layout.h>
    2121#include <LayoutPosition.h>
    22 #include <cvmatrix.h>
     22#include <Matrix.h>
    2323#include <AhrsData.h>
    2424#include <Euler.h>
  • trunk/lib/FlairFilter/src/JoyReference_impl.cpp

    r167 r214  
    2020#include <AhrsData.h>
    2121#include <Euler.h>
    22 #include <cvmatrix.h>
     22#include <Matrix.h>
    2323#include <Layout.h>
    2424#include <GroupBox.h>
     
    4040
    4141  ahrsData = new AhrsData(self);
    42   input = new cvmatrix(self, 4, 1, floatType, name);
     42  input = new Matrix(self, 4, 1, floatType, name);
    4343
    4444  cvmatrix_descriptor *desc = new cvmatrix_descriptor(4, 1);
     
    4848  desc->SetElementName(2, 0, "trim_roll");
    4949  desc->SetElementName(3, 0, "trim_pitch");
    50   output = new cvmatrix(self, desc, floatType, name);
     50  output = new Matrix(self, desc, floatType, name);
    5151  delete desc;
    5252
     
    147147
    148148void JoyReference_impl::UpdateFrom(const io_data *data) {
    149   cvmatrix *input = (cvmatrix *)data;
     149  const Matrix* input = dynamic_cast<const Matrix*>(data);
     150 
     151  if (!input) {
     152      self->Warn("casting %s to Matrix failed\n",data->ObjectName().c_str());
     153      return;
     154  }
    150155
    151156  if (previous_time == 0)
  • trunk/lib/FlairFilter/src/LowPassFilter.cpp

    r157 r214  
    1818#include "LowPassFilter.h"
    1919#include "LowPassFilter_impl.h"
    20 #include <cvmatrix.h>
     20#include <Matrix.h>
    2121#include <LayoutPosition.h>
    2222
     
    3030LowPassFilter::LowPassFilter(const IODevice *parent,
    3131                             const LayoutPosition *position, string name,
    32                              const cvmatrix *init_value)
     32                             const Matrix *init_value)
    3333    : IODevice(parent, name) {
    3434  pimpl_ = new LowPassFilter_impl(this, position, name, init_value);
     
    4040LowPassFilter::~LowPassFilter() { delete pimpl_; }
    4141
    42 cvmatrix *LowPassFilter::Matrix(void) const { return pimpl_->output; }
     42Matrix *LowPassFilter::GetMatrix(void) const { return pimpl_->output; }
    4343
    4444float LowPassFilter::Output(int row, int col) const {
  • trunk/lib/FlairFilter/src/LowPassFilter.h

    r147 r214  
    1818namespace flair {
    1919namespace core {
    20 class cvmatrix;
     20class Matrix;
    2121}
    2222namespace gui {
     
    5656  LowPassFilter(const core::IODevice *parent,
    5757                const gui::LayoutPosition *position, std::string name,
    58                 const core::cvmatrix *init_value = NULL);
     58                const core::Matrix *init_value = NULL);
    5959
    6060  /*!
     
    7979  * \return filtered output
    8080  */
    81   core::cvmatrix *Matrix(void) const;
     81  core::Matrix *GetMatrix(void) const;
    8282
    8383private:
  • trunk/lib/FlairFilter/src/LowPassFilter_impl.cpp

    r148 r214  
    1818#include "LowPassFilter_impl.h"
    1919#include "LowPassFilter.h"
    20 #include <cvmatrix.h>
     20#include <Matrix.h>
    2121#include <Layout.h>
    2222#include <GroupBox.h>
    2323#include <SpinBox.h>
    2424#include <DoubleSpinBox.h>
    25 
     25#include <typeinfo>
    2626#define PI ((float)3.14159265358979323846)
    2727
     
    3434                                       const LayoutPosition *position,
    3535                                       string name,
    36                                        const cvmatrix *init_value) {
     36                                       const Matrix *init_value) {
    3737
    3838  if (init_value != NULL) {
     
    4545      }
    4646    }
    47     output = new cvmatrix(self, desc,init_value->GetDataType().GetElementDataType(), name);
     47    output = new Matrix(self, desc,init_value->GetDataType().GetElementDataType(), name);
    4848    for (int i = 0; i < init_value->Rows(); i++) {
    4949      for (int j = 0; j < init_value->Cols(); j++) {
     
    5656    cvmatrix_descriptor *desc = new cvmatrix_descriptor(1, 1);
    5757    desc->SetElementName(0, 0, "output");
    58     output = new cvmatrix(self, desc, floatType, name);
     58    output = new Matrix(self, desc, floatType, name);
    5959    delete desc;
    6060  }
     
    6868                           
    6969  previous_time=GetTime();
     70  this->self = self;
    7071}
    7172
     
    7475void LowPassFilter_impl::UpdateFrom(const io_data *data) {
    7576  float delta_t;
    76   cvmatrix *input = (cvmatrix *)data;
     77  const Matrix* input = dynamic_cast<const Matrix*>(data);
     78 
     79  if (!input) {
     80      self->Warn("casting %s to Matrix failed\n",data->ObjectName().c_str());
     81      return;
     82  }
    7783
    7884  // on prend une fois pour toute les mutex et on fait des accès directs
  • trunk/lib/FlairFilter/src/NestedSat.cpp

    r157 r214  
    1818#include "NestedSat.h"
    1919#include "NestedSat_impl.h"
    20 #include <cvmatrix.h>
     20#include <Matrix.h>
    2121#include <Layout.h>
    2222#include <LayoutPosition.h>
  • trunk/lib/FlairFilter/src/NestedSat_impl.cpp

    r15 r214  
    1818#include "NestedSat_impl.h"
    1919#include "NestedSat.h"
    20 #include <cvmatrix.h>
     20#include <Matrix.h>
    2121#include <Layout.h>
    2222#include <GroupBox.h>
     
    3434
    3535  // init matrix
    36   self->input = new cvmatrix(self, 3, 1, floatType, name);
     36  self->input = new Matrix(self, 3, 1, floatType, name);
    3737
    3838  GroupBox *reglages_groupbox = new GroupBox(position, name);
     
    5050void NestedSat_impl::UpdateFrom(const io_data *data) {
    5151  float cons, dcons, law;
    52   cvmatrix *input = (cvmatrix *)data;
     52  const Matrix* input = dynamic_cast<const Matrix*>(data);
     53 
     54  if (!input) {
     55      self->Warn("casting %s to Matrix failed\n",data->ObjectName().c_str());
     56      return;
     57  }
    5358
    5459  input->GetMutex();
  • trunk/lib/FlairFilter/src/Pid.cpp

    r157 r214  
    1818#include "Pid.h"
    1919#include "Pid_impl.h"
    20 #include <cvmatrix.h>
     20#include <Matrix.h>
    2121#include <Layout.h>
    2222#include <LayoutPosition.h>
  • trunk/lib/FlairFilter/src/PidThrust.cpp

    r206 r214  
    1818#include "PidThrust.h"
    1919#include "PidThrust_impl.h"
    20 #include <cvmatrix.h>
     20#include <Matrix.h>
    2121#include <Layout.h>
    2222#include <LayoutPosition.h>
  • trunk/lib/FlairFilter/src/PidThrust_impl.cpp

    r148 r214  
    1717#include "PidThrust_impl.h"
    1818#include "PidThrust.h"
    19 #include <cvmatrix.h>
     19#include <Matrix.h>
    2020#include <Layout.h>
    2121#include <GroupBox.h>
     
    3636
    3737  // init matrix
    38   self->input = new cvmatrix(self, 2, 1, floatType, name);
     38  self->input = new Matrix(self, 2, 1, floatType, name);
    3939
    4040  cvmatrix_descriptor *desc = new cvmatrix_descriptor(5, 1);
     
    4444  desc->SetElementName(3, 0, "p+i+d");
    4545  desc->SetElementName(4, 0, "p+i+d+offset");
    46   state = new cvmatrix(self, desc, floatType, name);
     46  state = new Matrix(self, desc, floatType, name);
    4747  delete desc;
    4848
     
    7676  float p, d, total;
    7777  float delta_t;
    78   cvmatrix *input = (cvmatrix *)data;
     78  const Matrix* input = dynamic_cast<const Matrix*>(data);
     79 
     80  if (!input) {
     81      self->Warn("casting %s to Matrix failed\n",data->ObjectName().c_str());
     82      return;
     83  }
    7984
    8085  if (T->Value() == 0) {
  • trunk/lib/FlairFilter/src/Pid_impl.cpp

    r148 r214  
    1717#include "Pid_impl.h"
    1818#include "Pid.h"
    19 #include <cvmatrix.h>
     19#include <Matrix.h>
    2020#include <Layout.h>
    2121#include <GroupBox.h>
     
    3434
    3535  // init matrix
    36   self->input = new cvmatrix(self, 2, 1, floatType, name);
     36  self->input = new Matrix(self, 2, 1, floatType, name);
    3737
    3838  cvmatrix_descriptor *desc = new cvmatrix_descriptor(4, 1);
     
    4141  desc->SetElementName(2, 0, "d");
    4242  desc->SetElementName(3, 0, "p+i+d");
    43   state = new cvmatrix(self, desc, floatType, name);
     43  state = new Matrix(self, desc, floatType, name);
    4444  delete desc;
    4545
     
    7171  float p, d, total;
    7272  float delta_t;
    73   cvmatrix *input = (cvmatrix *)data;
     73  const Matrix* input = dynamic_cast<const Matrix*>(data);
     74 
     75  if (!input) {
     76      self->Warn("casting %s to Matrix failed\n",data->ObjectName().c_str());
     77      return;
     78  }
    7479
    7580  if (T->Value() == 0) {
  • trunk/lib/FlairFilter/src/TrajectoryGenerator1D.cpp

    r205 r214  
    1818#include "TrajectoryGenerator1D.h"
    1919#include "TrajectoryGenerator1D_impl.h"
    20 #include <cvmatrix.h>
     20#include <Matrix.h>
    2121#include <Layout.h>
    2222#include <LayoutPosition.h>
     
    3939TrajectoryGenerator1D::~TrajectoryGenerator1D() { delete pimpl_; }
    4040
    41 cvmatrix *TrajectoryGenerator1D::Matrix(void) const { return pimpl_->output; }
     41Matrix *TrajectoryGenerator1D::GetMatrix(void) const { return pimpl_->output; }
    4242
    4343void TrajectoryGenerator1D::StartTraj(float startPosition, float endPosition,float startVelocity) {
  • trunk/lib/FlairFilter/src/TrajectoryGenerator1D.h

    r205 r214  
    1818namespace flair {
    1919namespace core {
    20 class cvmatrix;
     20class Matrix;
    2121}
    2222namespace gui {
     
    152152  * \return matrix
    153153  */
    154   core::cvmatrix *Matrix(void) const;
     154  core::Matrix *GetMatrix(void) const;
    155155
    156156private:
  • trunk/lib/FlairFilter/src/TrajectoryGenerator1D_impl.cpp

    r205 r214  
    1818#include "TrajectoryGenerator1D.h"
    1919#include "TrajectoryGenerator1D_impl.h"
    20 #include <cvmatrix.h>
     20#include <Matrix.h>
    2121#include <Layout.h>
    2222#include <GroupBox.h>
     
    6363  desc->SetElementName(0, 0, "pos");
    6464  desc->SetElementName(1, 0, "vel");
    65   output = new cvmatrix(self, desc, floatType, name);
     65  output = new Matrix(self, desc, floatType, name);
    6666  delete desc;
    6767
  • trunk/lib/FlairFilter/src/TrajectoryGenerator2DCircle.cpp

    r167 r214  
    1818#include "TrajectoryGenerator2DCircle.h"
    1919#include "TrajectoryGenerator2DCircle_impl.h"
    20 #include <cvmatrix.h>
     20#include <Matrix.h>
    2121#include <Layout.h>
    2222#include <LayoutPosition.h>
     
    4444}
    4545
    46 cvmatrix *TrajectoryGenerator2DCircle::Matrix(void) const {
     46Matrix *TrajectoryGenerator2DCircle::GetMatrix(void) const {
    4747  return pimpl_->output;
    4848}
  • trunk/lib/FlairFilter/src/TrajectoryGenerator2DCircle.h

    r167 r214  
    1919namespace flair {
    2020namespace core {
    21 class cvmatrix;
     21class Matrix;
    2222}
    2323namespace gui {
     
    131131  * \return matrix
    132132  */
    133   core::cvmatrix *Matrix(void) const;
     133  core::Matrix *GetMatrix(void) const;
    134134
    135135  /*!
  • trunk/lib/FlairFilter/src/TrajectoryGenerator2DCircle_impl.cpp

    r167 r214  
    1818#include "TrajectoryGenerator2DCircle_impl.h"
    1919#include "TrajectoryGenerator2DCircle.h"
    20 #include <cvmatrix.h>
     20#include <Matrix.h>
    2121#include <Layout.h>
    2222#include <GroupBox.h>
     
    5656  desc->SetElementName(1, 0, "vel.x");
    5757  desc->SetElementName(1, 1, "vel.y");
    58   output = new cvmatrix(self, desc, floatType, name);
     58  output = new Matrix(self, desc, floatType, name);
    5959  delete desc;
    6060}
  • trunk/lib/FlairFilter/src/UavMultiplex.cpp

    r137 r214  
    1818#include "UavMultiplex.h"
    1919#include "UavMultiplex_impl.h"
    20 #include <cvmatrix.h>
     20#include <Matrix.h>
    2121#include <FrameworkManager.h>
    2222#include <Tab.h>
  • trunk/lib/FlairFilter/src/UavMultiplex_impl.cpp

    r137 r214  
    1818#include "UavMultiplex_impl.h"
    1919#include "UavMultiplex.h"
    20 #include <cvmatrix.h>
     20#include <Matrix.h>
    2121#include <FrameworkManager.h>
    2222#include <TabWidget.h>
     
    3434
    3535UavMultiplex_impl::UavMultiplex_impl(UavMultiplex *self, std::string name) {
    36   input = new cvmatrix(self, 7, 1, floatType);
     36  input = new Matrix(self, 7, 1, floatType);
    3737  multiplexcombobox = NULL;
    3838  this->self = self;
  • trunk/lib/FlairFilter/src/X4X8Multiplex_impl.cpp

    r148 r214  
    1818#include "X4X8Multiplex_impl.h"
    1919#include "X4X8Multiplex.h"
    20 #include <cvmatrix.h>
     20#include <Matrix.h>
    2121#include <Tab.h>
    2222#include <GridLayout.h>
     
    5555  }
    5656
    57   output = new cvmatrix(self, desc, floatType);
     57  output = new Matrix(self, desc, floatType);
    5858  delete desc;
    5959  self->AddDataToLog(output);
     
    8383  float value[MAX_MOTORS];
    8484
    85   cvmatrix *input = (cvmatrix *)data;
     85  const Matrix* input = dynamic_cast<const Matrix*>(data);
     86 
     87  if (!input) {
     88      self->Warn("casting %s to Matrix failed\n",data->ObjectName().c_str());
     89      return;
     90  }
    8691
    8792  // on prend une fois pour toute le mutex et on fait des accès directs
  • trunk/lib/FlairFilter/src/unexported/ButterworthLowPass_impl.h

    r162 r214  
    1919namespace flair {
    2020namespace core {
    21 class cvmatrix;
     21class Matrix;
    2222}
    2323namespace gui {
     
    120120class ButterworthLowPass_impl {
    121121public:
    122   ButterworthLowPass_impl(flair::filter::ButterworthLowPass *self,
     122  ButterworthLowPass_impl(const flair::filter::ButterworthLowPass *self,
    123123                          const flair::gui::LayoutPosition *position,
    124124                          std::string name, uint32_t order,uint32_t nbRow,uint32_t nbCol);
    125125  ~ButterworthLowPass_impl();
    126126  void UpdateFrom(const flair::core::io_data *data);
    127   flair::core::cvmatrix *output;
     127  flair::core::Matrix *output;
    128128
    129129private:
     
    135135  uint32_t order;
    136136  uint32_t nbRow, nbCol;
     137  const flair::filter::ButterworthLowPass *self;
    137138};
    138139
  • trunk/lib/FlairFilter/src/unexported/EulerDerivative_impl.h

    r15 r214  
    1818namespace flair {
    1919namespace core {
    20 class cvmatrix;
     20class Matrix;
    2121}
    2222namespace gui {
     
    3838                       const flair::gui::LayoutPosition *position,
    3939                       std::string name,
    40                        const flair::core::cvmatrix *init_value = NULL);
     40                       const flair::core::Matrix *init_value = NULL);
    4141  ~EulerDerivative_impl();
    4242  void UpdateFrom(const flair::core::io_data *data);
    43   flair::core::cvmatrix *output;
     43  flair::core::Matrix *output;
    4444
    4545private:
     
    4747  flair::core::Time previous_time;
    4848  bool first_update;
    49   flair::core::cvmatrix *prev_value;
     49  flair::core::Matrix *prev_value;
     50  flair::filter::EulerDerivative *self;
    5051};
    5152
  • trunk/lib/FlairFilter/src/unexported/JoyReference_impl.h

    r15 r214  
    2525namespace flair {
    2626namespace core {
    27 class cvmatrix;
     27class Matrix;
    2828class io_data;
    2929class AhrsData;
     
    6565  void Update(flair::core::Time time);
    6666  void UpdateFrom(const flair::core::io_data *data);
    67   flair::core::cvmatrix *output;
     67  flair::core::Matrix *output;
    6868  flair::core::AhrsData *ahrsData;
    6969
    7070private:
    71   flair::core::cvmatrix *input;
     71  flair::core::Matrix *input;
    7272
    7373  flair::gui::GroupBox *reglages_groupbox;
  • trunk/lib/FlairFilter/src/unexported/LowPassFilter_impl.h

    r147 r214  
    1818namespace flair {
    1919namespace core {
    20 class cvmatrix;
     20class Matrix;
    2121}
    2222namespace gui {
     
    3636                     const flair::gui::LayoutPosition *position,
    3737                     std::string name,
    38                      const flair::core::cvmatrix *init_value = NULL);
     38                     const flair::core::Matrix *init_value = NULL);
    3939  ~LowPassFilter_impl();
    4040  void UpdateFrom(const flair::core::io_data *data);
    41   flair::core::cvmatrix *output;
     41  flair::core::Matrix *output;
    4242
    4343private:
    4444  flair::core::Time previous_time;
    4545  flair::gui::DoubleSpinBox *freq, *T;
     46  const flair::filter::LowPassFilter *self;
    4647};
    4748
  • trunk/lib/FlairFilter/src/unexported/PidThrust_impl.h

    r15 r214  
    1818namespace flair {
    1919namespace core {
    20 class cvmatrix;
     20class Matrix;
    2121class io_data;
    2222}
     
    5050
    5151  // matrix
    52   flair::core::cvmatrix *state;
     52  flair::core::Matrix *state;
    5353
    5454  flair::gui::DoubleSpinBox *T, *kp, *ki, *kd, *sat, *sati;
  • trunk/lib/FlairFilter/src/unexported/Pid_impl.h

    r15 r214  
    1818namespace flair {
    1919namespace core {
    20 class cvmatrix;
     20class Matrix;
    2121class io_data;
    2222}
     
    4949
    5050  // matrix
    51   flair::core::cvmatrix *state;
     51  flair::core::Matrix *state;
    5252
    5353  flair::gui::DoubleSpinBox *T, *kp, *ki, *kd, *sat, *sati;
  • trunk/lib/FlairFilter/src/unexported/TrajectoryGenerator1D_impl.h

    r205 r214  
    1616namespace flair {
    1717namespace core {
    18 class cvmatrix;
     18class Matrix;
    1919}
    2020namespace gui {
     
    3939  void Reset(void);
    4040  float GetPercentageOfCompletion(void) const;
    41   flair::core::cvmatrix *output;
     41  flair::core::Matrix *output;
    4242  float pos_off, vel_off;
    4343  bool is_finished, is_started;
  • trunk/lib/FlairFilter/src/unexported/TrajectoryGenerator2DCircle_impl.h

    r167 r214  
    1919namespace flair {
    2020namespace core {
    21 class cvmatrix;
     21class Matrix;
    2222class io_data;
    2323}
     
    4646  void FinishTraj(void);
    4747  bool is_running;
    48   flair::core::cvmatrix *output;
     48  flair::core::Matrix *output;
    4949  flair::core::Vector2Df pos_off, vel_off;
    5050
  • trunk/lib/FlairFilter/src/unexported/UavMultiplex_impl.h

    r137 r214  
    2020namespace core {
    2121class FrameworkManager;
    22 class cvmatrix;
     22class Matrix;
    2323class io_data;
    2424}
     
    5656  ~UavMultiplex_impl();
    5757
    58   flair::core::cvmatrix *input;
     58  flair::core::Matrix *input;
    5959  void SetMultiplexComboBox(std::string name, int index);
    6060  int MultiplexValue(int index) const;
  • trunk/lib/FlairFilter/src/unexported/X4X8Multiplex_impl.h

    r15 r214  
    1818namespace flair {
    1919namespace core {
    20 class cvmatrix;
     20class Matrix;
    2121class io_data;
    2222}
     
    4444
    4545private:
    46   flair::core::cvmatrix *output;
     46  flair::core::Matrix *output;
    4747  flair::gui::ComboBox *pas;
    4848  flair::gui::DataPlot1D *plots[4];
Note: See TracChangeset for help on using the changeset viewer.