vpMeSite.h

/*
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2025 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);

  double convolution(const vpImage<unsigned char> &ima, const vpMe &me, const unsigned int mask_index);

  unsigned int computeMaskIndex(const double alpha, 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; }

  inline unsigned int getIndex() const { return m_index_prev; }

  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; 
  unsigned int m_index_prev; 
};
 
END_VISP_NAMESPACE
 
#endif