filter_expression.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2025 Povl Filip Sonne-Frederiksen
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
#include <memory>
#include <reusex/types.hpp>
#include <string>
#include <unordered_set>
#include <vector>
 
namespace reusex {
// Forward declaration
class ProjectDB;
} // namespace reusex
 
namespace reusex::core {

class CloudReferenceNode {
  std::string cloud_name_;
  CloudLConstPtr label_cloud_;
 
    public:
  CloudReferenceNode(std::string name, CloudLConstPtr labels)
      : cloud_name_(std::move(name)), label_cloud_(std::move(labels)) {}
 
  auto labels() const -> const CloudLConstPtr & { return label_cloud_; }
  auto name() const -> const std::string & { return cloud_name_; }
  auto size() const -> size_t { return label_cloud_->size(); }
};

class FilterNode {
    public:
  virtual ~FilterNode() = default;

  virtual auto evaluate(const std::vector<CloudReferenceNode> &clouds,
                        size_t point_idx) const -> bool = 0;
};

inline int32_t cloud_label_at(const std::vector<CloudReferenceNode> &clouds,
                              size_t cloud_idx, size_t point_idx) {
  if (cloud_idx >= clouds.size()) {
    return -1;
  }
  const auto &cloud = clouds[cloud_idx];
  if (point_idx >= cloud.size()) {
    return -1;
  }
  return cloud.labels()->points[point_idx].label;
}

class EqualNode : public FilterNode {
  size_t cloud_idx_;
  int32_t value_;
 
    public:
  EqualNode(size_t cloud_idx, int32_t value)
      : cloud_idx_(cloud_idx), value_(value) {}
  auto evaluate(const std::vector<CloudReferenceNode> &clouds,
                size_t point_idx) const -> bool override {
    return cloud_label_at(clouds, cloud_idx_, point_idx) == value_;
  }
};

class NotEqualNode : public FilterNode {
  size_t cloud_idx_;
  int32_t value_;
 
    public:
  NotEqualNode(size_t cloud_idx, int32_t value)
      : cloud_idx_(cloud_idx), value_(value) {}
  auto evaluate(const std::vector<CloudReferenceNode> &clouds,
                size_t point_idx) const -> bool override {
    return cloud_label_at(clouds, cloud_idx_, point_idx) != value_;
  }
};

class InNode : public FilterNode {
  size_t cloud_idx_;
  std::unordered_set<int32_t> values_;
 
    public:
  InNode(size_t cloud_idx, std::vector<int32_t> values)
      : cloud_idx_(cloud_idx), values_(values.begin(), values.end()) {}
  auto evaluate(const std::vector<CloudReferenceNode> &clouds,
                size_t point_idx) const -> bool override {
    return values_.count(cloud_label_at(clouds, cloud_idx_, point_idx)) > 0;
  }
};

class CompareNode : public FilterNode {
    public:
  enum class Op { GT, GE, LT, LE };
 
    private:
  size_t cloud_idx_;
  Op op_;
  int32_t value_;
 
    public:
  CompareNode(size_t cloud_idx, Op op, int32_t value)
      : cloud_idx_(cloud_idx), op_(op), value_(value) {}
  auto evaluate(const std::vector<CloudReferenceNode> &clouds,
                size_t point_idx) const -> bool override {
    const int32_t label = cloud_label_at(clouds, cloud_idx_, point_idx);
    switch (op_) {
    case Op::GT:
      return label > value_;
    case Op::GE:
      return label >= value_;
    case Op::LT:
      return label < value_;
    case Op::LE:
      return label <= value_;
    }
    return false;
  }
};

class AndNode : public FilterNode {
  std::unique_ptr<FilterNode> left_;
  std::unique_ptr<FilterNode> right_;
 
    public:
  AndNode(std::unique_ptr<FilterNode> left, std::unique_ptr<FilterNode> right)
      : left_(std::move(left)), right_(std::move(right)) {}
  auto evaluate(const std::vector<CloudReferenceNode> &clouds,
                size_t point_idx) const -> bool override {
    return left_->evaluate(clouds, point_idx) &&
           right_->evaluate(clouds, point_idx);
  }
};

class OrNode : public FilterNode {
  std::unique_ptr<FilterNode> left_;
  std::unique_ptr<FilterNode> right_;
 
    public:
  OrNode(std::unique_ptr<FilterNode> left, std::unique_ptr<FilterNode> right)
      : left_(std::move(left)), right_(std::move(right)) {}
  auto evaluate(const std::vector<CloudReferenceNode> &clouds,
                size_t point_idx) const -> bool override {
    return left_->evaluate(clouds, point_idx) ||
           right_->evaluate(clouds, point_idx);
  }
};

struct FilterExpression {
  std::unique_ptr<FilterNode> root;       
  std::vector<CloudReferenceNode> clouds; 

  auto evaluate_point(size_t idx) const -> bool;
};

auto parse_filter_expression(const std::string &expression, ProjectDB &db)
    -> std::unique_ptr<FilterExpression>;

auto evaluate_filter(const FilterExpression &expr, size_t cloud_size)
    -> IndicesPtr;
 
} // namespace reusex::core