search_result.hpp

#pragma once
 
#include "../_cexports/c_minos.h"
 
#include "../global.hpp"
#include "../point_2d.hpp"
#include "../string.hpp"
#include "../utilities/system_info.hpp"
 
#include <sstream>
#include <iomanip>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS

  namespace Minos
  {


    class SearchResult
    {
    public:
      SearchResult(const String &className, double quality, Point2D<double> position, Point2D<double> advanceVector)
          : name_(className)
          , quality_(quality)
          , position_(position)
          , advanceVector_(advanceVector)
      {
      }
 
      SearchResult() noexcept = default;
 
    public:

      String Name() const
      {
        return name_;
      }
      String Name() const {…}


      double Quality() const noexcept
      {
        return quality_;
      }
      double Quality() const noexcept {…}


      Point2D<double> Position() const noexcept
      {
        return position_;
      }
      Point2D<double> Position() const noexcept {…}


      double X() const noexcept
      {
        return position_.X();
      }
      double X() const noexcept {…}


      double Y() const noexcept
      {
        return position_.Y();
      }
      double Y() const noexcept {…}


      Point2D<double> AdvanceVector() const noexcept
      {
        return advanceVector_;
      }
      Point2D<double> AdvanceVector() const noexcept {…}


      bool IsNothing() const noexcept
      {
        if (std::isnan(quality_))
          return true;
        return false;
      }
      bool IsNothing() const noexcept {…}


      explicit operator bool() const noexcept
      {
        return !IsNothing();
      }
      explicit operator bool() const noexcept {…}
 
    private:
      String name_;
      double quality_ = std::numeric_limits<double>::quiet_NaN();
      Point2D<double> position_;
      Point2D<double> advanceVector_;
    };
    class SearchResult {…};


    inline bool operator!=(const SearchResult &lhs, const SearchResult &rhs) noexcept
    {
      return (lhs.Name() != rhs.Name()) || (lhs.Position() != rhs.Position()) || (lhs.Quality() != rhs.Quality())
             || (lhs.AdvanceVector() != rhs.AdvanceVector());
    }
    inline bool operator!=(const SearchResult &lhs, const SearchResult &rhs) noexcept {…}


    inline bool operator==(const SearchResult &lhs, const SearchResult &rhs) noexcept
    {
      return (!(lhs != rhs));
    }
    inline bool operator==(const SearchResult &lhs, const SearchResult &rhs) noexcept {…}
 
    namespace Private
    {
      /* Convert a Minos Result list into a list of SearchResult struts. */
      inline std::vector<SearchResult> SearchResultsToArray(CExports::RESULTS hResults)
      {
        std::vector<SearchResult> results;
 
        auto resultCount = CVB_CALL_CAPI(SearchResultsCount(hResults));
        for (CExports::cvbdim_t i = 0; i < resultCount; ++i)
        {
          double quality = std::numeric_limits<double>::quiet_NaN(), xpos = std::numeric_limits<double>::quiet_NaN();
          double ypos = std::numeric_limits<double>::quiet_NaN(), dx = std::numeric_limits<double>::quiet_NaN(),
                 dy                   = std::numeric_limits<double>::quiet_NaN();
          Cvb::Char *strName          = nullptr;
          CExports::cvbval_t searchID = 0;
          CVB_CALL_CAPI_CHECKED(SearchResultTyped(hResults, i, quality, xpos, ypos, dx, dy, strName, searchID));
          results.push_back(SearchResult((strName != nullptr) ? Cvb::String(strName) : Cvb::String(), quality,
                                         Point2D<double>(xpos, ypos), Point2D<double>(dx, dy)));
        }
 
        return results;
      }
    } /* namespace Private */
 
  } /* namespace Minos */
  CVB_END_INLINE_NS
} /* namespace Cvb */