colormaps.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 <Eigen/Core>
 
#include "base/reconstruction.h"
#include "util/alignment.h"
#include "util/types.h"
 
namespace colmap {
 
// Base class for 3D point color mapping.
class PointColormapBase {
public:
    PointColormapBase();
    virtual ~PointColormapBase() = default;
 
    virtual void Prepare(std::unordered_map<camera_t, Camera>& cameras,
                         std::unordered_map<image_t, Image>& images,
                         std::unordered_map<point3D_t, Point3D>& points3D,
                         std::vector<image_t>& reg_image_ids) = 0;
 
    virtual Eigen::Vector4f ComputeColor(const point3D_t point3D_id,
                                         const Point3D& point3D) = 0;
 
    void UpdateScale(std::vector<float>* values);
    float AdjustScale(const float gray);
 
    float scale;
    float min;
    float max;
    float range;
    float min_q;
    float max_q;
};
 
// Map color according to RGB value from image.
class PointColormapPhotometric : public PointColormapBase {
public:
    void Prepare(std::unordered_map<camera_t, Camera>& cameras,
                 std::unordered_map<image_t, Image>& images,
                 std::unordered_map<point3D_t, Point3D>& points3D,
                 std::vector<image_t>& reg_image_ids) override;
 
    Eigen::Vector4f ComputeColor(const point3D_t point3D_id,
                                 const Point3D& point3D) override;
};
 
// Map color according to error.
class PointColormapError : public PointColormapBase {
public:
    void Prepare(std::unordered_map<camera_t, Camera>& cameras,
                 std::unordered_map<image_t, Image>& images,
                 std::unordered_map<point3D_t, Point3D>& points3D,
                 std::vector<image_t>& reg_image_ids) override;
 
    Eigen::Vector4f ComputeColor(const point3D_t point3D_id,
                                 const Point3D& point3D) override;
};
 
// Map color according to track length.
class PointColormapTrackLen : public PointColormapBase {
public:
    void Prepare(std::unordered_map<camera_t, Camera>& cameras,
                 std::unordered_map<image_t, Image>& images,
                 std::unordered_map<point3D_t, Point3D>& points3D,
                 std::vector<image_t>& reg_image_ids) override;
 
    Eigen::Vector4f ComputeColor(const point3D_t point3D_id,
                                 const Point3D& point3D) override;
};
 
// Map color according to ground-resolution.
class PointColormapGroundResolution : public PointColormapBase {
public:
    void Prepare(std::unordered_map<camera_t, Camera>& cameras,
                 std::unordered_map<image_t, Image>& images,
                 std::unordered_map<point3D_t, Point3D>& points3D,
                 std::vector<image_t>& reg_image_ids) override;
 
    Eigen::Vector4f ComputeColor(const point3D_t point3D_id,
                                 const Point3D& point3D) override;
 
private:
    std::unordered_map<point3D_t, float> resolutions_;
};
 
// Base class for image color mapping.
class ImageColormapBase {
public:
    ImageColormapBase();
    virtual ~ImageColormapBase() = default;
 
    virtual void Prepare(std::unordered_map<camera_t, Camera>& cameras,
                         std::unordered_map<image_t, Image>& images,
                         std::unordered_map<point3D_t, Point3D>& points3D,
                         std::vector<image_t>& reg_image_ids) = 0;
 
    virtual void ComputeColor(const Image& image,
                              Eigen::Vector4f* plane_color,
                              Eigen::Vector4f* frame_color) = 0;
 
    const static Eigen::Vector4f kDefaultPlaneColor;
    const static Eigen::Vector4f kDefaultFrameColor;
};
 
// Use uniform color for all images.
class ImageColormapUniform : public ImageColormapBase {
public:
    void Prepare(std::unordered_map<camera_t, Camera>& cameras,
                 std::unordered_map<image_t, Image>& images,
                 std::unordered_map<point3D_t, Point3D>& points3D,
                 std::vector<image_t>& reg_image_ids) override;
 
    void ComputeColor(const Image& image,
                      Eigen::Vector4f* plane_color,
                      Eigen::Vector4f* frame_color) override;
 
    Eigen::Vector4f uniform_plane_color = kDefaultPlaneColor;
    Eigen::Vector4f uniform_frame_color = kDefaultFrameColor;
};
 
// Use color for images with specific words in their name.
class ImageColormapNameFilter : public ImageColormapBase {
public:
    void Prepare(std::unordered_map<camera_t, Camera>& cameras,
                 std::unordered_map<image_t, Image>& images,
                 std::unordered_map<point3D_t, Point3D>& points3D,
                 std::vector<image_t>& reg_image_ids) override;
 
    void AddColorForWord(const std::string& word,
                         const Eigen::Vector4f& plane_color,
                         const Eigen::Vector4f& frame_color);
 
    void ComputeColor(const Image& image,
                      Eigen::Vector4f* plane_color,
                      Eigen::Vector4f* frame_color) override;
 
private:
    // The plane and frame colors for different words.
    std::vector<
            std::pair<std::string, std::pair<Eigen::Vector4f, Eigen::Vector4f>>>
            image_name_colors_;
};
 
}  // namespace colmap