IntegralTexture.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
 
#include "vc/core/neighborhood/NeighborhoodGenerator.hpp"
#include "vc/texturing/TexturingAlgorithm.hpp"
 
namespace volcart::texturing
{
class IntegralTexture : public TexturingAlgorithm
{
public:
    enum class WeightMethod { None = 0, Linear, ExpoDiff };
 
    enum class LinearWeightDirection { Positive = 0, Negative };
 
    enum class ExpoDiffBaseMethod { Mean = 0, Mode, Manual };
 
    using Pointer = std::shared_ptr<IntegralTexture>;
 
    static auto New() -> Pointer;
 
    IntegralTexture() = default;
    ~IntegralTexture() override = default;
    IntegralTexture(IntegralTexture&) = default;
    IntegralTexture(IntegralTexture&&) = default;
    auto operator=(const IntegralTexture&) -> IntegralTexture& = default;
    auto operator=(IntegralTexture&&) -> IntegralTexture& = default;
    void setGenerator(NeighborhoodGenerator::Pointer g);
 
    void setClampValuesToMax(bool b);
 
    [[nodiscard]] auto clampValuesToMax() const -> bool;
 
    void setClampMax(std::uint16_t m);
 
    [[nodiscard]] auto clampMax() const -> std::uint16_t;
 
    void setWeightMethod(WeightMethod w);
 
    [[nodiscard]] auto weightMethod() const -> WeightMethod;
 
    void setLinearWeightDirection(LinearWeightDirection w);
 
    [[nodiscard]] auto linearWeightDirection() const -> LinearWeightDirection;
 
    void setExponentialDiffExponent(int e);
 
    [[nodiscard]] auto exponentialDiffExponent() const -> int;
 
    void setExponentialDiffBaseMethod(ExpoDiffBaseMethod m);
 
    [[nodiscard]] auto exponentialDiffBaseMethod() const -> ExpoDiffBaseMethod;
 
    void setExponentialDiffBaseValue(double b);
 
    [[nodiscard]] auto exponentialDiffBaseValue() const -> double;
 
    void setExponentialDiffSuppressBelowBase(bool b);
 
    [[nodiscard]] auto exponentialDiffSuppressBelowBase() const -> bool;
    auto compute() -> Texture override;
private:
    NeighborhoodGenerator::Pointer gen_;
 
    bool clampToMax_{false};
 
    std::uint16_t clampMax_{std::numeric_limits<uint16_t>::max()};
 
    WeightMethod weight_{WeightMethod::None};
 
    void setup_weights_();
 
    auto apply_weights_(NDArray<double>& n) -> NDArray<double>;
 
    LinearWeightDirection linearWeight_{LinearWeightDirection::Positive};
 
    NDArray<double> linearWeights_{1};
 
    void setup_linear_weights_();
 
    auto apply_linear_weights_(NDArray<double>& n) -> NDArray<double>;
 
    int expoDiffExponent_{2};
 
    ExpoDiffBaseMethod expoDiffBaseMethod_{ExpoDiffBaseMethod::Mean};
 
    double expoDiffManualBase_{0};
 
    double expoDiffBase_{0};
 
    bool suppressBelowBase_{true};
 
    void setup_expodiff_weights_();
 
    auto expodiff_intersection_pts_() -> std::vector<std::uint16_t>;
 
    auto expodiff_mean_base_() -> double;
 
    auto expodiff_mode_base_() -> double;
 
    auto apply_expodiff_weights_(NDArray<double>& n) const -> NDArray<double>;
};
 
}  // namespace volcart::texturing