vpMeSite.h

/*
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2024 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 https://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:
 * Moving edges.
 */
 
#ifndef VP_ME_SITE_H
#define VP_ME_SITE_H
 
#include <visp3/core/vpConfig.h>
#include <visp3/core/vpDisplay.h>
#include <visp3/core/vpImage.h>
#include <visp3/core/vpMatrix.h>
#include <visp3/me/vpMe.h>
 
BEGIN_VISP_NAMESPACE
 
class VISP_EXPORT vpMeSite
{
public:
  typedef enum
  {
    NONE, 
    RANGE, 
    RESULT, 
    RANGE_RESULT 
  } vpMeSiteDisplayType;
 
  typedef enum
  {
    NO_SUPPRESSION = 0,   
    CONTRAST = 1,         
#ifdef VISP_BUILD_DEPRECATED_FUNCTIONS
    CONSTRAST = CONTRAST, 
#endif
    THRESHOLD = 2,        
    M_ESTIMATOR = 3,      
    TOO_NEAR = 4,         
    UNKNOW = 5,           
    OUTSIDE_ROI_MASK = 6  
  } vpMeSiteState;
 
  int m_i;
  int m_j;
  double m_ifloat;
  double m_jfloat;
  int m_mask_sign;
  double m_alpha;
  double m_convlt;
  double m_normGradient;
  double m_weight;
  double m_contrastThreshold;
 
public:
  vpMeSite();
 
  vpMeSite(const double &ip, const double &jp);
 
  vpMeSite(const vpMeSite &mesite);
 
  virtual ~vpMeSite() { };
 
  double convolution(const vpImage<unsigned char> &ima, const vpMe *me);
 
  void display(const vpImage<unsigned char> &I) const;
 
  void display(const vpImage<vpRGBa> &I) const;
 
  inline double getAlpha() const { return m_alpha; }
 
  inline double getWeight() const { return m_weight; }
 
  vpMeSite *getQueryList(const vpImage<unsigned char> &I, const int &range) const;
 
  inline int get_i() const { return m_i; }
 
  inline int get_j() const { return m_j; }
 
  inline double get_ifloat() const { return m_ifloat; }
 
  inline double get_jfloat() const { return m_jfloat; }
 
  void init();
 
  void init(const double &ip, const double &jp, const double &alphap);
 
  void init(const double &ip, const double &jp, const double &alphap, const double &convltp);
 
  void init(const double &ip, const double &jp, const double &alphap, const double &convltp, const int &sign);
 
  void init(const double &ip, const double &jp, const double &alphap, const double &convltp, const int &sign, const double &contrastThreshold);
 
  void track(const vpImage<unsigned char> &I, const vpMe *me, const bool &test_contrast = true);
 
  void trackMultipleHypotheses(const vpImage<unsigned char> &I, const vpMe &me, const bool &test_contrast,
                              std::vector<vpMeSite> &outputHypotheses, const unsigned numCandidates);
 
  void setAlpha(const double &a) { m_alpha = a; }
 
  void setDisplay(vpMeSiteDisplayType select) { m_selectDisplay = select; }
 
  void setState(const vpMeSiteState &flag)
  {
    m_state = flag;
  }
 
  inline vpMeSiteState getState() const { return m_state; }
 
  void setWeight(const double &weight) { m_weight = weight; }
 
  void setContrastThreshold(const double &thresh, const vpMe &me)
  {
    double threshold;
    if (me.getUseAutomaticThreshold()) {
      threshold = std::max(thresh, me.getMinThreshold());
    }
    else {
      threshold = me.getThreshold();
    }
 
    m_contrastThreshold = threshold;
  }
 
  inline double getContrastThreshold() const { return m_contrastThreshold; }
 
 
  inline double computeFinalThreshold(const vpMe &me) const
  {
    const double threshold = getContrastThreshold();
    if (me.getLikelihoodThresholdType() == vpMe::NORMALIZED_THRESHOLD) {
      return 2.0 * threshold;
    }
    else {
      const double n_d = me.getMaskSize();
      return threshold / (100.0 * n_d * trunc(n_d / 2.0));
    }
  }
 
  vpMeSite &operator=(const vpMeSite &m);
 
  int operator!=(const vpMeSite &m);
 
  friend VISP_EXPORT std::ostream &operator<<(std::ostream &os, vpMeSite &vpMeS);
 
  // Static functions
  static double distance(const vpMeSite &S1, const vpMeSite &S2)
  {
    return (sqrt(sqrDistance(S1, S2)));
  }
 
  static double sqrDistance(const vpMeSite &S1, const vpMeSite &S2)
  {
    return (vpMath::sqr(S1.m_ifloat - S2.m_ifloat) + vpMath::sqr(S1.m_jfloat - S2.m_jfloat));
  }
 
  static void display(const vpImage<unsigned char> &I, const double &i, const double &j,
                      const vpMeSiteState &state = NO_SUPPRESSION);
 
  static void display(const vpImage<vpRGBa> &I, const double &i, const double &j,
                      const vpMeSiteState &state = NO_SUPPRESSION);
 
private:
  vpMeSiteDisplayType m_selectDisplay; 
  vpMeSiteState m_state; 
};
 
END_VISP_NAMESPACE
 
#endif