vpContours.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:
 * Basic contours extraction based on the orignal work of
 * Sina Samangooei (ss@ecs.soton.ac.uk).
 */

 
#ifndef VP_CONTOURS_H
#define VP_CONTOURS_H
 
#include <visp3/core/vpColor.h>
#include <visp3/core/vpImage.h>
#include <visp3/core/vpPolygon.h>
 
namespace VISP_NAMESPACE_NAME
{

typedef enum
{
  NORTH, 
  NORTH_EAST, 
  EAST, 
  SOUTH_EAST, 
  SOUTH, 
  SOUTH_WEST, 
  WEST, 
  NORTH_WEST, 
  LAST_DIRECTION 
} vpDirectionType;

class vpDirection
{
public:
  vpDirectionType m_direction;

  int m_dirx[8];

  int m_diry[8];

  vpDirection()
  {
    const unsigned int dir0 = 0, dir1 = 1, dir2 = 2, dir3 = 3;
    const unsigned int dir4 = 4, dir5 = 5, dir6 = 6, dir7 = 7;
    m_direction = NORTH;
 
    m_dirx[dir0] = 0;
    m_dirx[dir1] = 1;
    m_dirx[dir2] = 1;
    m_dirx[dir3] = 1;
    m_dirx[dir4] = 0;
    m_dirx[dir5] = -1;
    m_dirx[dir6] = -1;
    m_dirx[dir7] = -1;
 
    m_diry[dir0] = -1;
    m_diry[dir1] = -1;
    m_diry[dir2] = 0;
    m_diry[dir3] = 1;
    m_diry[dir4] = 1;
    m_diry[dir5] = 1;
    m_diry[dir6] = 0;
    m_diry[dir7] = -1;
  }

  vpDirection clockwise()
  {
    vpDirection direction;
    int directionSize = LAST_DIRECTION;
    direction.m_direction = static_cast<vpDirectionType>((static_cast<int>(m_direction) + 1) % directionSize);
 
    return direction;
  }

  vpDirection counterClockwise()
  {
    vpDirection direction;
    int directionSize = static_cast<int>(LAST_DIRECTION);
    int idx = VISP_NAMESPACE_ADDRESSING vpMath::modulo(static_cast<int>(m_direction) - 1, directionSize);
    direction.m_direction = static_cast<vpDirectionType>(idx);
 
    return direction;
  }

  VISP_NAMESPACE_ADDRESSING vpImagePoint active(const VISP_NAMESPACE_ADDRESSING vpImage<int> &I, const VISP_NAMESPACE_ADDRESSING vpImagePoint &point)
  {
    int yy = static_cast<int>(point.get_i() + m_diry[static_cast<int>(m_direction)]);
    int xx = static_cast<int>(point.get_j() + m_dirx[static_cast<int>(m_direction)]);
 
    if ((xx < 0) || (xx >= static_cast<int>(I.getWidth())) || (yy < 0) || (yy >= static_cast<int>(I.getHeight()))) {
      return VISP_NAMESPACE_ADDRESSING vpImagePoint(-1, -1);
    }
 
    int pixel = I[yy][xx];
    return pixel != 0 ? VISP_NAMESPACE_ADDRESSING vpImagePoint(yy, xx) : VISP_NAMESPACE_ADDRESSING vpImagePoint(-1, -1);
  }
};

typedef enum
{
  CONTOUR_OUTER, 
  CONTOUR_HOLE   
} vpContourType;

typedef enum
{
  CONTOUR_RETR_TREE,    
  CONTOUR_RETR_LIST,    
  CONTOUR_RETR_EXTERNAL 
} vpContourRetrievalType;

struct vpContour
{
  std::vector<vpContour *> m_children;
  vpContourType m_contourType;
  vpContour *m_parent;
  std::vector<VISP_NAMESPACE_ADDRESSING vpImagePoint> m_points;

  vpContour() : m_children(), m_contourType(CONTOUR_HOLE), m_parent(nullptr), m_points() { }

  VP_EXPLICIT vpContour(const vpContourType &type) : m_children(), m_contourType(type), m_parent(nullptr), m_points() { }

  vpContour(const vpContour &contour)
    : m_children(), m_contourType(contour.m_contourType), m_parent(nullptr), m_points(contour.m_points)
  {
 
    // Copy the underlying contours
    std::vector<vpContour *>::const_iterator contour_m_children_end = contour.m_children.end();
    for (std::vector<vpContour *>::const_iterator it = contour.m_children.begin(); it != contour_m_children_end;
         ++it) {
      vpContour *copy = new vpContour(**it);
      copy->m_parent = this;
      m_children.push_back(copy);
    }
  }

  virtual ~vpContour()
  {
    std::vector<vpContour *>::iterator m_children_end = m_children.end();
    for (std::vector<vpContour *>::iterator it = m_children.begin(); it != m_children_end; ++it) {
      (*it)->m_parent = nullptr;
      if (*it != nullptr) {
        delete *it;
        *it = nullptr;
      }
    }
  }

  vpContour &operator=(const vpContour &other)
  {
    m_contourType = other.m_contourType;
 
    if (m_parent == nullptr) {
      // We are a root or an uninitialized contour so delete everything
      std::vector<vpContour *>::iterator m_children_end = m_children.end();
      for (std::vector<vpContour *>::iterator it = m_children.begin(); it != m_children_end; ++it) {
        (*it)->m_parent = nullptr;
        if (*it != nullptr) {
          delete *it;
          *it = nullptr;
        }
      }
    }
    else {
      // Make the current contour the root contour
      // to avoid problem when deleting
      m_parent = nullptr;
    }
 
    m_children.clear();
    std::vector<vpContour *>::const_iterator other_m_children_end = other.m_children.end();
    for (std::vector<vpContour *>::const_iterator it = other.m_children.begin(); it != other_m_children_end; ++it) {
      vpContour *copy = new vpContour(**it);
      copy->m_parent = this;
      m_children.push_back(copy);
    }
 
    return *this;
  }

  void setParent(vpContour *parent)
  {
    m_parent = parent;
 
    if (parent != nullptr) {
      parent->m_children.push_back(this);
    }
  }
};

VISP_EXPORT void drawContours(VISP_NAMESPACE_ADDRESSING vpImage<unsigned char> &I, const std::vector<std::vector<VISP_NAMESPACE_ADDRESSING vpImagePoint> > &contours,
                              unsigned char grayValue = 255);

VISP_EXPORT void drawContours(VISP_NAMESPACE_ADDRESSING vpImage<VISP_NAMESPACE_ADDRESSING vpRGBa> &I, const std::vector<std::vector<VISP_NAMESPACE_ADDRESSING vpImagePoint> > &contours,
                              const VISP_NAMESPACE_ADDRESSING vpColor &color);

VISP_EXPORT void findContours(const VISP_NAMESPACE_ADDRESSING vpImage<unsigned char> &I_original, vpContour &contours,
                              std::vector<std::vector<VISP_NAMESPACE_ADDRESSING vpImagePoint> > &contourPts,
                              const vpContourRetrievalType &retrievalMode = CONTOUR_RETR_TREE);
 
} // namespace
 
#endif