src/ftxui/dom/linear_gradient.cpp

Go to the documentation of this file.

// Copyright 2023 Arthur Sonzogni. All rights reserved.
// Use of this source code is governed by the MIT license that can be found in
// the LICENSE file.
// このソースコードの使用は、LICENSEファイルにあるMITライセンスによって管理されています。
#include <algorithm>                      // for max, min, sort, copy
#include <cmath>                          // for fmod, cos, sin
#include <cstddef>                        // for size_t
#include <ftxui/dom/linear_gradient.hpp>  // for LinearGradient::Stop, LinearGradient
#include <memory>    // for allocator_traits<>::value_type, make_shared
#include <optional>  // for optional, operator!=, operator<
#include <utility>   // for move
#include <vector>    // for vector
 
#include "ftxui/dom/elements.hpp"  // for Element, Decorator, bgcolor, color
#include "ftxui/dom/node_decorator.hpp"  // for NodeDecorator
#include "ftxui/screen/box.hpp"          // for Box
#include "ftxui/screen/color.hpp"   // for Color, Color::Default, Color::Blue
#include "ftxui/screen/screen.hpp"  // for Pixel, Screen
 
namespace ftxui {
namespace {
 
struct LinearGradientNormalized {
  float angle = 0.F;
  std::vector<Color> colors;
  std::vector<float> positions;  // Sorted.
};
 
// 線形グラデーションを正規化されたバージョンに変換します。
LinearGradientNormalized Normalize(LinearGradient gradient) {
  // サイズ0のグラデーションを処理します。
  if (gradient.stops.empty()) {
    return LinearGradientNormalized{
        0.F,
        {Color::Default, Color::Default},
        {0.F, 1.F},
    };
  }
 
  // 指定されていない場合、2つの範囲を埋めます。
  if (!gradient.stops.front().position) {
    gradient.stops.front().position = 0.F;
  }
  if (!gradient.stops.back().position) {
    gradient.stops.back().position = 1.F;
  }
 
  // 位置を補間して空白を埋めます。
  size_t last_checkpoint = 0;
  for (size_t i = 1; i < gradient.stops.size(); ++i) {
    if (!gradient.stops[i].position) {
      continue;
    }
 
    if (i - last_checkpoint >= 2) {
      const float min = gradient.stops[i].position.value();  // NOLINT
      const float max =
          gradient.stops[last_checkpoint].position.value();  // NOLINT
      for (size_t j = last_checkpoint + 1; j < i; ++j) {
        gradient.stops[j].position = min + (max - min) *
                                               float(j - last_checkpoint) /
                                               float(i - last_checkpoint);
      }
    }
 
    last_checkpoint = i;
  }
 
  // ストップを位置でソートします。
  std::sort(
      gradient.stops.begin(), gradient.stops.end(),
      [](const auto& a, const auto& b) { return a.position < b.position; });
 
  // ゼロから始まらない場合、ゼロにストップを追加します。
  if (gradient.stops.front().position != 0) {
    gradient.stops.insert(gradient.stops.begin(),
                          {gradient.stops.front().color, 0.F});
  }
  // 1で終わらない場合、1にストップを追加します。
  if (gradient.stops.back().position != 1) {
    gradient.stops.push_back({gradient.stops.back().color, 1.F});
  }
 
  // 角度を正規化します。
  LinearGradientNormalized normalized;
  const float modulo = 360.F;
  normalized.angle =
      std::fmod(std::fmod(gradient.angle, modulo) + modulo, modulo);
  for (auto& stop : gradient.stops) {
    normalized.colors.push_back(stop.color);
    // NOLINTNEXTLINE
    normalized.positions.push_back(stop.position.value());
  }
  return normalized;
}
 
Color Interpolate(const LinearGradientNormalized& gradient, float t) {
  // グラデーションのストップで正しい色を見つけます。
  size_t i = 1;
  while (true) {
    // 浮動小数点精度により `t` が1.0よりわずかに大きい場合があります。
    // このため、`t` が最後のストップの位置より大きい場合を処理する必要があります。
    // https://github.com/ArthurSonzogni/FTXUI/issues/998 を参照してください。
    if (i >= gradient.positions.size()) {
      const float half = 0.5F;
      return Color::Interpolate(half, gradient.colors.back(),
                                gradient.colors.back());
    }
    if (t <= gradient.positions[i]) {
      break;
    }
    ++i;
  }
 
  const float t0 = gradient.positions[i - 1];
  const float t1 = gradient.positions[i - 0];
  const float tt = (t - t0) / (t1 - t0);
 
  const Color& c0 = gradient.colors[i - 1];
  const Color& c1 = gradient.colors[i - 0];
  const Color& cc = Color::Interpolate(tt, c0, c1);
 
  return cc;
}
 
class LinearGradientColor : public NodeDecorator {
 public:
  explicit LinearGradientColor(Element child,
                               const LinearGradient& gradient,
                               bool background_color)
      : NodeDecorator(std::move(child)),
        gradient_(Normalize(gradient)),
        background_color_{background_color} {}
 
 private:
  void Render(Screen& screen) override {
    const float degtorad = 0.01745329251F;
    const float dx = std::cos(gradient_.angle * degtorad);
    const float dy = std::sin(gradient_.angle * degtorad);
 
    // グラデーションの範囲を取得するために、すべての角を投影します。
    const float p1 = float(box_.x_min) * dx + float(box_.y_min) * dy;
    const float p2 = float(box_.x_min) * dx + float(box_.y_max) * dy;
    const float p3 = float(box_.x_max) * dx + float(box_.y_min) * dy;
    const float p4 = float(box_.x_max) * dx + float(box_.y_max) * dy;
    const float min = std::min({p1, p2, p3, p4});
    const float max = std::max({p1, p2, p3, p4});
 
    // 範囲と射影幾何学を使用して、投影を [0, 1] に再正規化します。
    const float dX = dx / (max - min);
    const float dY = dy / (max - min);
    const float dZ = -min / (max - min);
 
    // 色を取得するために、すべてのピクセルを投影します。
    if (background_color_) {
      for (int y = box_.y_min; y <= box_.y_max; ++y) {
        for (int x = box_.x_min; x <= box_.x_max; ++x) {
          const float t = float(x) * dX + float(y) * dY + dZ;
          screen.PixelAt(x, y).background_color = Interpolate(gradient_, t);
        }
      }
    } else {
      for (int y = box_.y_min; y <= box_.y_max; ++y) {
        for (int x = box_.x_min; x <= box_.x_max; ++x) {
          const float t = float(x) * dX + float(y) * dY + dZ;
          screen.PixelAt(x, y).foreground_color = Interpolate(gradient_, t);
        }
      }
    }
 
    NodeDecorator::Render(screen);
  }
 
  LinearGradientNormalized gradient_;
  bool background_color_;
};
 
}  // namespace
 
/// @brief 「空の」グラデーションを構築します。これはしばしば
/// LinearGradient::Angle() および LinearGradient::Stop() の呼び出しが続きます。
/// 例:
/// ```cpp
///  auto gradient =
///   LinearGradient()
///    .Angle(45)
///    .Stop(Color::Red, 0.0)
///    .Stop(Color::Green, 0.5)
///    .Stop(Color::Blue, 1.0);;
/// ```
LinearGradient::LinearGradient() = default;
 
/// @brief 2色でグラデーションを構築します。
/// @param begin グラデーションの開始色。
/// @param end グラデーションの終了色。
LinearGradient::LinearGradient(Color begin, Color end)
    : LinearGradient(0, begin, end) {}
 
/// @brief 2色と角度でグラデーションを構築します。
/// @param a グラデーションの角度。
/// @param begin グラデーションの開始色。
/// @param end グラデーションの終了色。
LinearGradient::LinearGradient(float a, Color begin, Color end) : angle(a) {
  stops.push_back({begin, {}});
  stops.push_back({end, {}});
}
 
/// @brief グラデーションの角度を設定します。
/// @param a グラデーションの角度。
/// @return グラデーション。
LinearGradient& LinearGradient::Angle(float a) {
  angle = a;
  return *this;
}
 
/// @brief グラデーションにカラーストップを追加します。
/// @param c ストップの色。
/// @param p ストップの位置。
LinearGradient& LinearGradient::Stop(Color c, float p) {
  stops.push_back({c, p});
  return *this;
}
 
/// @brief グラデーションにカラーストップを追加します。
/// @param c ストップの色。
/// @return グラデーション。
/// @note ストップの位置は近くのストップから補間されます。
LinearGradient& LinearGradient::Stop(Color c) {
  stops.push_back({c, {}});
  return *this;
}
 
/// @brief 線形グラデーション効果を持つ要素のフォアグラウンドカラーを設定します。
/// @param gradient 出力要素に適用されるグラデーション効果。
/// @param child 入力要素。
/// @return 色付けされた出力要素。
/// @ingroup dom
///
/// ### 例
///
/// ```cpp
/// color(LinearGradient{0, {Color::Red, Color::Blue}}, text("Hello"))
/// ```
Element color(const LinearGradient& gradient, Element child) {
  return std::make_shared<LinearGradientColor>(std::move(child), gradient,
                                               /*background_color*/ false);
}
 
/// @brief 線形グラデーション効果を持つ要素の背景色を設定します。
/// @param gradient 出力要素に適用されるグラデーション効果。
/// @param child 入力要素。
/// @return 色付けされた出力要素。
/// @ingroup dom
///
/// ### 例
///
/// ```cpp
/// bgcolor(LinearGradient{0, {Color::Red, Color::Blue}}, text("Hello"))
/// ```
Element bgcolor(const LinearGradient& gradient, Element child) {
  return std::make_shared<LinearGradientColor>(std::move(child), gradient,
                                               /*background_color*/ true);
}
 
/// @brief フォアグラウンドカラーに線形グラデーション効果を使用して装飾します。
/// @param gradient 出力要素に適用されるグラデーション効果。
/// @return 色を適用するデコレーター。
/// @ingroup dom
///
/// ### 例
///
/// ```cpp
/// text("Hello") | color(LinearGradient{0, {Color::Red, Color::Blue}})
/// ```
Decorator color(const LinearGradient& gradient) {
  return
      [gradient](Element child) { return color(gradient, std::move(child)); };
}
 
/// @brief 背景色に線形グラデーション効果を使用して装飾します。
/// @param gradient 出力要素に適用されるグラデーション効果。
/// @return 色を適用するデコレーター。
/// @ingroup dom
///
/// ### 例
///
/// ```cpp
/// text("Hello") | color(LinearGradient{0, {Color::Red, Color::Blue}})
/// ```
Decorator bgcolor(const LinearGradient& gradient) {
  return
      [gradient](Element child) { return bgcolor(gradient, std::move(child)); };
}
 
}  // namespace ftxui