IQueryDescriptor.hpp

#pragma once
 
#include "config.hpp"
#include "Handle.hpp"
#include "ObjectBase.hpp"
#include "IQueryKnn.hpp"
#include "IQueryBox.hpp"
#include "IQueryCylinder.hpp"
#include "IQuerySphere.hpp"
#include "IQueryIncremental.hpp"
#include "IQueryCombined.hpp"
#include "ISamplingStrategy.hpp"
#include "IQuerySort.hpp"
#include "IParameterSet.hpp"
#include "AutoLink.hpp" //enable autolink
 
DM_NAMESPACE_BEGIN
 
class DM_API IQueryDescriptor;
typedef Handle< IQueryDescriptor > QueryDescriptorHandle;
 
/// \brief Defines a generic spatial search
/// \date 2021-01
/// \author wk
class DM_API IQueryDescriptor : public ObjectBase
{
public:
  //supported parameter set names
  static constexpr const char *ParamMinPtCount        = "minPtCount";
  static constexpr const char *ParamMaxSearchDistance = "maxSearchDistance";
 
  /// creates an empty query descriptor object
  static IQueryDescriptor* New();
 
  /// \brief create a new query descriptor object
  static IQueryDescriptor* New(QueryBaseHandle query, 
                               const SamplingStrategyHandle &sampling = SamplingStrategyHandle(), 
                               const QuerySortHandle &sorting = QuerySortHandle(),
                               const ParameterSetHandle &params = ParameterSetHandle());
 
  enum struct Vocabulary
  {
    minimal,
    subdivision,                       // Support subdivision in addition to cellSize. Point-based modules only support cellSize.
    neighborhood3d = subdivision << 1, // Support 3d- in addition to 2d-neighborhoods. Raster-based modules only support 2d neighborhood definitions.
    full = (neighborhood3d << 1) - 1,
    queryOptional = neighborhood3d << 1 // Support descriptors without query.
  };
 
  struct DM_API IDefaults : ObjectBase
  {
    static IDefaults* New();
 
    virtual IQueryKnn& knn() = 0;
    virtual IQueryWindow& window() = 0;
    virtual IQueryCircle& circle() = 0;
    virtual IQueryCylinder& cylinder() = 0;
    virtual IQuerySphere& sphere() = 0;
    virtual IQueryBox& box() = 0;
    virtual IQueryIncremental& incremental() = 0;
    virtual IQueryCombined& combined() = 0;
    virtual ISamplingStrategy& sampling() = 0;
    virtual IQuerySort& sort() = 0;
    virtual IQueryDescriptor& queryDescriptor() = 0;
  };
 
  static IQueryDescriptor* New(const char *description, Vocabulary vocabulary = Vocabulary::minimal, const IDefaults *defaults = nullptr);
  virtual IQueryDescriptor* clone() const = 0;
  virtual const char *description() const = 0;
 
  virtual QueryType queryType() const = 0;
  virtual bool hasQuery() const = 0;
  virtual bool hasSampling() const = 0;
  virtual bool hasSorting() const = 0;
  virtual bool hasMinPtCount() const = 0;
  virtual bool hasMaxSearchDistance() const = 0;
 
  virtual const IQueryBase &query() const = 0;
  virtual void query(const IQueryBase &q) = 0;
  virtual const ISamplingStrategy &sampling() const = 0;
  virtual void sampling(const ISamplingStrategy &s) = 0;
  virtual const IQuerySort &sorting() const = 0;
  virtual void sorting(const IQuerySort &s) = 0;
 
  virtual unsigned minPtCount() const = 0;
  virtual void minPtCount(unsigned) = 0;
  virtual double maxSearchDistance() const = 0; ///< get the optional maxSearchDistance parameter. DBL_MAX for "max"
  virtual void maxSearchDistance(double d) = 0; ///< set the optional maxSearchDistance parameter
 
  /// \brief  query the maximum search 2d distance based on descriptors content (considers the query object and the optional maxSearchDistance parameter)
  /// \returns double max if no search is unlimited
  virtual double maxSearchDistance2D() const = 0;  
  /// \brief  query the maximum search 3d distance based on descriptors content (considers the query object and the optional maxSearchDistance parameter)
  /// \returns double max if no search is unlimited
  virtual double maxSearchDistance3D() const = 0;
 
  virtual const char *text() const = 0;
};
 
constexpr IQueryDescriptor::Vocabulary operator|(IQueryDescriptor::Vocabulary left, IQueryDescriptor::Vocabulary right)
{
  return IQueryDescriptor::Vocabulary(static_cast<int>(left) | static_cast<int>(right));
}
 
DM_NAMESPACE_END