vpMomentCInvariant.h

/****************************************************************************
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2017 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 __MOMENTCINVARIANT_H__
#define __MOMENTCINVARIANT_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