Refactor SegmentedFunction

Author: schaumb

src/base/anim/easinggradient.h

@@ -12,13 +12,14 @@ namespace Anim
 class EasingGradient : protected Math::SegmentedFunction<double>
 {
 public:
-	using Math::SegmentedFunction<double>::SegmentedFunction;
+	friend struct SegmentedFunction;
+	using SegmentedFunction::SegmentedFunction;
 
-	static EasingGradient Bezier(const Geom::Point &p1,
+	[[nodiscard]] static EasingGradient Bezier(const Geom::Point &p1,
 	    const Geom::Point &p2,
 	    size_t stepCount = 10);
 
-	double operator()(double t) const { return at(t); }
+	using SegmentedFunction::operator();
 };
 
 }

src/base/gfx/colorgradient.cpp

@@ -11,6 +11,14 @@
 #include "color.h"
 
 template struct Math::SegmentedFunction<Gfx::Color>;
+template Gfx::ColorGradient
+Math::SegmentedFunction<Gfx::Color>::operator*<Gfx::ColorGradient>(
+    this const Gfx::ColorGradient &,
+    double value);
+template Gfx::ColorGradient
+Math::SegmentedFunction<Gfx::Color>::operator+<Gfx::ColorGradient>(
+    this const Gfx::ColorGradient &,
+    const Gfx::ColorGradient &);
 
 namespace Gfx
 {

src/base/gfx/colorgradient.h

@@ -17,16 +17,10 @@ struct ColorGradient : Math::SegmentedFunction<Color>
 
 	using SegmentedFunction::SegmentedFunction;
 
-	explicit ColorGradient(SegmentedFunction gradient) :
-	    SegmentedFunction(std::move(gradient))
-	{}
-
 	explicit ColorGradient(
 	    const std::string &stoplist = std::string());
 
 	explicit operator std::string() const;
-
-	using SegmentedFunction::at;
 };
 
 }

src/base/math/segmentedfunc.h

@@ -26,11 +26,16 @@ template <typename T> struct SegmentedFunction
 	    stops(std::move(stops))
 	{}
 
-	SegmentedFunction operator*(double value) const;
-	SegmentedFunction operator+(const SegmentedFunction &other) const;
-	bool operator==(const SegmentedFunction &other) const;
+	template <class Self>
+	[[nodiscard]] Self operator*(this const Self &, double);
 
-	[[nodiscard]] T at(double pos) const;
+	template <class Self>
+	[[nodiscard]] Self operator+(this const Self &, const Self &);
+
+	[[nodiscard]] bool operator==(
+	    const SegmentedFunction &other) const = default;
+
+	[[nodiscard]] T operator()(double pos) const;
 };
 
 }

src/base/math/segmentedfunc.tpp

@@ -1,64 +1,61 @@
 #ifndef MATH_SEGMENTEDFUNC_TPP
 #define MATH_SEGMENTEDFUNC_TPP
 
+#include <ranges>
+
 #include "base/math/interpolation.h"
 #include "base/math/range.h"
 
 #include "segmentedfunc.h"
 
 template <typename T>
-T Math::SegmentedFunction<T>::at(double pos) const
+T Math::SegmentedFunction<T>::operator()(double pos) const
 {
 	if (stops.empty()) return T();
-	if (stops.size() == 1) return stops.at(0).value;
-
-	if (pos < stops.front().pos) return stops.front().value;
-	if (pos > stops.back().pos) return stops.back().value;
+	if (stops.size() == 1 || pos < stops.front().pos)
+		return stops.front().value;
 
-	for (auto i = 1U; i < stops.size(); ++i) {
-		auto &[ppos, pval] = stops[i - 1];
-		auto &[cpos, cval] = stops[i];
-		if (ppos <= pos && pos <= cpos)
-			return interpolate(pval,
-			    cval,
-			    Range{ppos, cpos}.rescale(pos));
-	}
+	if (auto it = std::ranges::adjacent_find(stops,
+	        [pos](auto &&cur, auto &&next)
+	        {
+		        return cur.pos <= pos && pos <= next.pos;
+	        });
+	    it != stops.end())
+		return interpolate(it->value,
+		    std::next(it)->value,
+		    Range{it->pos, std::next(it)->pos}.rescale(pos));
 
 	return stops.back().value;
 }
 
 template <typename T>
-bool Math::SegmentedFunction<T>::operator==(
-    const SegmentedFunction &other) const
-{
-	return stops == other.stops;
-}
-
-template <typename T>
-Math::SegmentedFunction<T> Math::SegmentedFunction<T>::operator*(
-    double value) const
+template <class Self>
+Self Math::SegmentedFunction<T>::operator*(this const Self &self,
+    double value)
 {
-	auto res = *this;
+	auto res = self;
 	for (auto &stop : res.stops) stop.value = stop.value * value;
 	return res;
 }
 
 template <typename T>
-Math::SegmentedFunction<T> Math::SegmentedFunction<T>::operator+(
-    const SegmentedFunction &other) const
+template <class Self>
+Self Math::SegmentedFunction<T>::operator+(this const Self &self,
+    const Self &other)
 {
-	SegmentedFunction<T> res;
+	Self res;
+	auto &stops = self.stops;
 
 	for (auto it0 = stops.begin(), it1 = other.stops.begin();
 	     it0 != stops.end() || it1 != other.stops.end();) {
 		if (it1 == other.stops.end() || it0->pos < it1->pos) {
 			res.stops.emplace_back(it0->pos,
-			    it0->value + other.at(it0->pos));
+			    it0->value + other(it0->pos));
 			++it0;
 		}
 		else if (it0 == stops.end() || it1->pos < it0->pos) {
 			res.stops.emplace_back(it1->pos,
-			    it1->value + at(it1->pos));
+			    it1->value + self(it1->pos));
 			++it1;
 		}
 		else {

src/chart/rendering/colorbuilder.cpp

@@ -13,10 +13,10 @@
 namespace Vizzu::Draw
 {
 
-ColorBuilder::ColorBuilder(const LighnessRange &lighnessRange,
+ColorBuilder::ColorBuilder(const LightnessRange &lightnessRange,
     const Anim::Interpolated<Gfx::ColorPalette> &palette,
     const Gfx::ColorGradient &gradient) :
-    lighnessRange(lighnessRange),
+    lightnessRange(lightnessRange),
     gradient(gradient),
     palette(palette)
 {}
@@ -37,7 +37,7 @@ Gfx::Color ColorBuilder::render(
 		    {
 			    return base.getLightness();
 		    });
-		return lightnessAdjusted(gradient.get().at(pos), lightness);
+		return lightnessAdjusted(gradient(pos), lightness);
 	}
 	return colorBase.combine(
 	    [this](const Gen::ColorBase &base)
@@ -56,16 +56,15 @@ Gfx::Color ColorBuilder::render(const Gen::ColorBase &colorBase) const
 Gfx::Color ColorBuilder::lightnessAdjusted(const Gfx::Color &color,
     double lightness) const
 {
-	auto factor = lighnessRange.scale(lightness);
+	auto factor = lightnessRange.scale(lightness);
 	return color.lightnessScaled(factor);
 }
 
 Gfx::Color ColorBuilder::baseColor(
     const Gen::ColorBase &colorBase) const
 {
-	return colorBase.isDiscrete()
-	         ? indexedColor(colorBase.getIndex())
-	         : gradient.get().at(colorBase.getPos());
+	return colorBase.isDiscrete() ? indexedColor(colorBase.getIndex())
+	                              : gradient(colorBase.getPos());
 }
 
 [[nodiscard]] Gfx::Color ColorBuilder::indexedColor(

src/chart/rendering/colorbuilder.h

@@ -13,9 +13,9 @@ namespace Vizzu::Draw
 
 struct ColorBuilder
 {
-	using LighnessRange = Math::Range<double>;
+	using LightnessRange = Math::Range<double>;
 
-	ColorBuilder(const LighnessRange &lighnessRange,
+	ColorBuilder(const LightnessRange &lightnessRange,
 	    const ::Anim::Interpolated<Gfx::ColorPalette> &palette,
 	    const Gfx::ColorGradient &gradient);
 
@@ -26,7 +26,7 @@ struct ColorBuilder
 	    const Gen::ColorBase &colorBase) const;
 
 private:
-	LighnessRange lighnessRange;
+	LightnessRange lightnessRange;
 
 	std::reference_wrapper<const Gfx::ColorGradient> gradient;
 	std::reference_wrapper<

src/chart/rendering/drawlegend.cpp

@@ -341,8 +341,7 @@ void DrawLegend::colorBar(const Info &info,
 	info.canvas.save();
 
 	info.canvas.setBrushGradient({rect.leftSide(),
-	    Gfx::ColorGradient{*rootStyle.plot.marker.colorGradient
-	                       * info.measureWeight}});
+	    *rootStyle.plot.marker.colorGradient * info.measureWeight});
 	info.canvas.setLineColor(Gfx::Color::Transparent());
 	info.canvas.setLineWidth(0);
 
@@ -372,8 +371,8 @@ void DrawLegend::lightnessBar(const Info &info,
 
 	info.canvas.save();
 
-	info.canvas.setBrushGradient({rect.leftSide(),
-	    Gfx::ColorGradient{gradient * info.measureWeight}});
+	info.canvas.setBrushGradient(
+	    {rect.leftSide(), gradient * info.measureWeight});
 	info.canvas.setLineColor(Gfx::Color::Transparent());
 	info.canvas.setLineWidth(0);