DebugDrawing.hpp

Go to the documentation of this file.

// ----------------- BEGIN LICENSE BLOCK ---------------------------------
//
// Copyright (C) 2020-2022 Intel Corporation
//
// SPDX-License-Identifier: LGPL-2.1-only
//
// ----------------- END LICENSE BLOCK -----------------------------------
#pragma once
 
#include "ad/rss/unstructured/Geometry.hpp"
 
#include <string>
#include <utility>
#include <vector>
 
#define DEBUG_DRAWING_POLYGON(polygon, color, ns) (DebugDrawing::getInstance()->drawPolygon(polygon, color, ns))
#define DEBUG_DRAWING_LINE(line, color, ns) (DebugDrawing::getInstance()->drawLine(line, color, ns))
#define DEBUG_DRAWING_IS_ENABLED() (DebugDrawing::getInstance()->isEnabled())
 
namespace ad {
namespace rss {
namespace unstructured {
 
class DebugDrawing
{
public:
  struct NullDeleter
  {
    void operator()(const void *)
    {
    }
  };
  struct DebugPoint
  {
    DebugPoint(double inX, double inY)
      : x(inX)
      , y(inY){};
    double x;
    double y;
  };
 
  struct DebugLine
  {
    DebugLine(Line const &iLine, std::string const &iColor, std::string const &iNs)
      : line(iLine)
      , color(iColor)
      , ns(iNs)
    {
    }
    Line line;
    std::string color{"white"};
    std::string ns;
 
    std::vector<DebugPoint> getVector()
    {
      std::vector<DebugPoint> vectorLine;
      for (auto const &pt : line)
      {
        vectorLine.push_back(DebugPoint(pt.x(), pt.y()));
      }
      return vectorLine;
    }
  };
 
  struct DebugPolygon
  {
    DebugPolygon(Polygon const &iPolygon, std::string const &iColor, std::string const &iNs)
      : polygon(iPolygon)
      , color(iColor)
      , ns(iNs)
    {
    }
    Polygon polygon;
    std::string color{"white"};
    std::string ns;
 
    std::vector<DebugPoint> getVector()
    {
      std::vector<DebugPoint> vectorPolygon;
      for (auto const &pt : polygon.outer())
      {
        vectorPolygon.push_back(DebugPoint(pt.x(), pt.y()));
      }
      return vectorPolygon;
    }
  };
 
  explicit DebugDrawing() = default;
 
  static std::shared_ptr<DebugDrawing> getInstance()
  {
    static DebugDrawing *mSingleton = new DebugDrawing();
    return std::shared_ptr<DebugDrawing>(mSingleton, NullDeleter());
  }
 
  void reset()
  {
    if (!mEnabled)
    {
      return;
    }
    mLines.clear();
    mPolygons.clear();
  }
 
  void enable(bool value)
  {
    mEnabled = value;
  }
 
  bool isEnabled()
  {
    return mEnabled;
  }
 
  void drawLine(Line const &line, std::string const &color = "white", std::string const &ns = "")
  {
    if (!mEnabled)
    {
      return;
    }
    mLines.push_back(DebugLine(line, color, ns));
 
    spdlog::trace("DRAW;{};{};{};LINE", ns, color, std::to_string(line));
  }
 
  void drawPolygon(Polygon const &polygon, std::string const &color = "white", std::string const &ns = "")
  {
    if (!mEnabled)
    {
      return;
    }
    mPolygons.push_back(DebugPolygon(polygon, color, ns));
  }
 
  std::vector<DebugLine> mLines;
  std::vector<DebugPolygon> mPolygons;
  bool mEnabled{false};
};
 
} // namespace unstructured
} // namespace rss
} // namespace ad