VoxelGrid.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
#include <Helper.h>
#include <Logging.h>
 
#include <Eigen/Core>
#include <memory>
#include <unordered_map>
#include <vector>
 
#include "ecvHObject.h"
 
class ccPointCloud;
class ccMesh;
class ccBBox;
class ecvOrientedBBox;
 
namespace cloudViewer {
namespace camera {
class PinholeCameraParameters;
}
 
namespace geometry {
 
class Octree;
class Image;
 
class CV_DB_LIB_API Voxel {
public:
    Voxel() {}
    Voxel(const Eigen::Vector3i &grid_index) : grid_index_(grid_index) {}
    Voxel(const Eigen::Vector3i &grid_index, const Eigen::Vector3d &color)
        : grid_index_(grid_index), color_(color) {}
    ~Voxel() {}
 
public:
    Eigen::Vector3i grid_index_ = Eigen::Vector3i(0, 0, 0);
    Eigen::Vector3d color_ = Eigen::Vector3d(0, 0, 0);
};
 
class CV_DB_LIB_API VoxelGrid : public ccHObject {
public:
    VoxelGrid(const char *name = "VoxelGrid") : ccHObject(name) {}
    VoxelGrid(const VoxelGrid &src_voxel_grid, const char *name = "VoxelGrid");
    ~VoxelGrid() override {}
 
    // inherited methods (ccHObject)
    virtual bool isSerializable() const override { return true; }
 
    virtual CV_CLASS_ENUM getClassID() const override {
        return CV_TYPES::VOXEL_GRID;
    }
    virtual ccBBox getOwnBB(bool withGLFeatures = false) override;
 
    VoxelGrid &Clear();
    inline virtual bool IsEmpty() const override { return !HasVoxels(); }
    virtual Eigen::Vector3d GetMinBound() const override;
    virtual Eigen::Vector3d GetMaxBound() const override;
    virtual Eigen::Vector3d GetCenter() const override;
    std::vector<Eigen::Vector3d> GetAllVoxelCorners() const;
    virtual ccBBox GetAxisAlignedBoundingBox() const override;
    virtual ecvOrientedBBox GetOrientedBoundingBox() const override;
    virtual VoxelGrid &Transform(
            const Eigen::Matrix4d &transformation) override;
    virtual VoxelGrid &Translate(const Eigen::Vector3d &translation,
                                 bool relative = true) override;
    virtual VoxelGrid &Scale(const double s,
                             const Eigen::Vector3d &center) override;
    virtual VoxelGrid &Rotate(const Eigen::Matrix3d &R,
                              const Eigen::Vector3d &center) override;
 
    VoxelGrid &operator+=(const VoxelGrid &voxelgrid);
    VoxelGrid operator+(const VoxelGrid &voxelgrid) const;
 
    bool HasVoxels() const { return voxels_.size() > 0; }
    bool HasColors() const {
        return true;  // By default, the colors are (0, 0, 0)
    }
    Eigen::Vector3i GetVoxel(const Eigen::Vector3d &point) const;
 
    Eigen::Vector3d GetVoxelCenterCoordinate(const Eigen::Vector3i &idx) const {
        auto it = voxels_.find(idx);
        if (it != voxels_.end()) {
            auto voxel = it->second;
            Eigen::Vector3d local = (voxel.grid_index_.cast<double>() +
                                     Eigen::Vector3d(0.5, 0.5, 0.5)) *
                                    voxel_size_;
            return origin_ + rotation_ * local;
        } else {
            return Eigen::Vector3d::Zero();
        }
    }
 
    void AddVoxel(const Voxel &voxel);
 
    void RemoveVoxel(const Eigen::Vector3i &idx);
 
    std::vector<Eigen::Vector3d> GetVoxelBoundingPoints(
            const Eigen::Vector3i &index) const;
 
    std::vector<bool> CheckIfIncluded(
            const std::vector<Eigen::Vector3d> &queries);
 
    VoxelGrid &CarveDepthMap(
            const Image &depth_map,
            const camera::PinholeCameraParameters &camera_parameter,
            bool keep_voxels_outside_image);
 
    VoxelGrid &CarveSilhouette(
            const Image &silhouette_mask,
            const camera::PinholeCameraParameters &camera_parameter,
            bool keep_voxels_outside_image);
 
    void CreateFromOctree(const Octree &octree);
 
    std::shared_ptr<geometry::Octree> ToOctree(const size_t &max_depth) const;
 
    static std::shared_ptr<VoxelGrid> CreateDense(const Eigen::Vector3d &origin,
                                                  const Eigen::Vector3d &color,
                                                  double voxel_size,
                                                  double width,
                                                  double height,
                                                  double depth);
 
    enum class VoxelPoolingMode { AVG, MIN, MAX, SUM };
 
    static std::shared_ptr<VoxelGrid> CreateFromPointCloud(
            const ccPointCloud &input,
            double voxel_size,
            VoxelPoolingMode color_mode = VoxelPoolingMode::AVG);
 
    static std::shared_ptr<VoxelGrid> CreateFromPointCloudWithinBounds(
            const ccPointCloud &input,
            double voxel_size,
            const Eigen::Vector3d &min_bound,
            const Eigen::Vector3d &max_bound,
            VoxelPoolingMode color_mode = VoxelPoolingMode::AVG);
 
    static std::shared_ptr<VoxelGrid> CreateFromTriangleMesh(
            const ccMesh &input, double voxel_size);
 
    static std::shared_ptr<VoxelGrid> CreateFromTriangleMeshWithinBounds(
            const ccMesh &input,
            double voxel_size,
            const Eigen::Vector3d &min_bound,
            const Eigen::Vector3d &max_bound);
 
    std::vector<Voxel> GetVoxels() const;
 
public:
    double voxel_size_ = 0.0;
    Eigen::Vector3d origin_ = Eigen::Vector3d::Zero();
    Eigen::Matrix3d rotation_ = Eigen::Matrix3d::Identity();
    std::unordered_map<Eigen::Vector3i,
                       Voxel,
                       cloudViewer::utility::hash_eigen<Eigen::Vector3i>>
            voxels_;
};
 
class CV_DB_LIB_API AvgColorVoxel {
public:
    AvgColorVoxel()
        : num_of_points_(0),
          color_(0.0, 0.0, 0.0),
          min_color_(Eigen::Vector3d::Constant(
                  std::numeric_limits<double>::max())),
          max_color_(Eigen::Vector3d::Constant(
                  std::numeric_limits<double>::lowest())) {}
 
public:
    void Add(const Eigen::Vector3i &voxel_index) {
        if (num_of_points_ > 0 && voxel_index != voxel_index_) {
            cloudViewer::utility::LogWarning(
                    "Tried to aggregate ColorVoxel with different "
                    "voxel_index");
        }
        voxel_index_ = voxel_index;
    }
 
    void Add(const Eigen::Vector3i &voxel_index, const Eigen::Vector3d &color) {
        Add(voxel_index);
        color_ += color;
        num_of_points_++;
    }
 
    Eigen::Vector3i GetVoxelIndex() const { return voxel_index_; }
 
    Eigen::Vector3d GetAverageColor() const {
        if (num_of_points_ > 0) {
            return color_ / double(num_of_points_);
        } else {
            return color_;
        }
    }
 
    Eigen::Vector3d GetMinColor() const { return min_color_; }
 
    Eigen::Vector3d GetMaxColor() const { return max_color_; }
 
    Eigen::Vector3d GetSumColor() const { return color_; }
 
public:
    int num_of_points_;
    Eigen::Vector3i voxel_index_;
    Eigen::Vector3d color_;
 
private:
    Eigen::Vector3d min_color_;
    Eigen::Vector3d max_color_;
};
 
}  // namespace geometry
}  // namespace cloudViewer