vpMomentCInvariant.h

/****************************************************************************
 *
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2019 by Inria. All rights reserved.
 *
 * This software is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact Inria about acquiring a ViSP Professional
 * Edition License.
 *
 * See http://visp.inria.fr for more information.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * If you have questions regarding the use of this file, please contact
 * Inria at visp@inria.fr
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Description:
 * Descriptor for various invariants used to drive space roations around X and
 *Y axis.
 *
 * Authors:
 * Filip Novotny
 *
 *****************************************************************************/
#ifndef _vpMomentCInvariant_h_
#define _vpMomentCInvariant_h_
 
#include <visp3/core/vpMoment.h>
#include <visp3/core/vpMomentDatabase.h>
 
class vpMomentCentered;
class vpMomentBasic;
 
class VISP_EXPORT vpMomentCInvariant : public vpMoment
{
private:
  std::vector<double> I;
  std::vector<double> II;
  std::vector<double> c;
  std::vector<double> s;
  double K;
  void computeI(const vpMomentCentered &momentCentered, std::vector<double> &I);
 
  /* To calculate Sx and Sy from normalized moments */
  void calcSxSy(double &sx, double &sy) const;
  void calcSxSyNormalized(double &sx, double &sy) const;
  std::vector<double> cn; // same as s above but calculated from normalized moments
  std::vector<double> sn; // same as c above but calculated from normalized moments
  double In1;             // same as I1 in Sx,Sy formulae but calculated from normalized
                          // moments
  bool flg_sxsynormalization_;
 
public:
  explicit vpMomentCInvariant(bool flg_sxsynormalization = false);
  virtual ~vpMomentCInvariant(){};
 
  double C1() const { return values[0]; }
  double C2() const { return values[1]; }
  double C3() const { return values[2]; }
  double C4() const { return values[3]; }
  double C5() const { return values[4]; }
  double C6() const { return values[5]; }
  double C7() const { return values[6]; }
  double C8() const { return values[7]; }
  double C9() const { return values[8]; }
  double C10() const { return values[9]; }
 
  void compute();
 
  double get(unsigned int i) const { return values[i]; }
 
  double getC(unsigned int i) const { return c[i]; }
  double getI(unsigned int index) const { return I[index]; }
 
  void printInvariants(std::ostream &os) const;
 
  double getII(unsigned int i) const { return II[i]; }
  double getK() const { return K; }
 
  double getS(unsigned int i) const { return s[i]; }
 
  const char *name() const { return "vpMomentCInvariant"; }
 
  void printI(unsigned int index);
 
  double Px() { return values[12]; }
  double Py() { return values[13]; }
 
  double Sx() const { return values[10]; }
  double Sy() const { return values[11]; }
 
  double getIn1() const { return In1; }
 
  double getCN(unsigned int i) const { return cn[i]; }
 
  double getSN(unsigned int i) const { return sn[i]; }
 
  bool isSxSyfromNormalizedMoments() const { return flg_sxsynormalization_; };
 
  inline const std::vector<double> &getMomentVector() const { return values; }
 
  friend VISP_EXPORT std::ostream &operator<<(std::ostream &os, const vpMomentCInvariant &v);
};
#endif