Add Hybrid RGB Smoothing Interpolator (#1379)

awawa-dev · web-flow · commit aeefc1186eb4 · 2025-12-27T17:17:36.000+01:00
* Add Hybrid RGB Smoothing Interpolator

* Add Hybrid RGB Smoothing Interpolator (2)

* Add Hybrid RGB Smoothing Interpolator (3)

* Add Hybrid RGB Smoothing Interpolator (4)
diff --git a/include/infinite-color-engine/InfiniteHybridRgbInterpolator.h b/include/infinite-color-engine/InfiniteHybridRgbInterpolator.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#ifndef PCH_ENABLED
+	#include <QJsonDocument>
+	#include <QMutex>
+	#include <QVector>
+
+	#include <vector>
+#endif
+
+#include <infinite-color-engine/InfiniteInterpolator.h>
+
+class InfiniteHybridRgbInterpolator : public InfiniteInterpolator
+{
+public:
+	InfiniteHybridRgbInterpolator();
+
+	void setTargetColors(std::vector<linalg::aliases::float3>&& new_rgb_targets, float startTimeMs, bool debug = false) override;
+	void updateCurrentColors(float currentTimeMs) override;
+	SharedOutputColors getCurrentColors() override;
+
+	void setTransitionDuration(float durationMs) override;
+	void setSpringiness(float stiffness, float damping) override;
+	void setSmoothingFactor(float factor) override;
+
+	void resetToColors(std::vector<linalg::aliases::float3> colors, float startTimeMs);
+	static void test();
+
+private:
+	std::vector<linalg::aliases::float3> _targetColorsRGB;
+	std::vector<linalg::aliases::float3> _currentColorsRGB;
+	std::vector<linalg::aliases::float3> _velocitiesRGB;
+
+	float _initialDuration = 150.0f;
+	float _startAnimationTimeMs = 0.0f;
+	float _targetTime = 0.0f;
+	float _lastUpdate = 0.0f;
+	float _stiffness = 150.0f;
+	float _damping = 26.0f;
+	float _smoothingFactor = 0.0f;
+};
diff --git a/include/infinite-color-engine/InfiniteSmoothing.h b/include/infinite-color-engine/InfiniteSmoothing.h
@@ -66,7 +66,7 @@ private slots:
 
 	bool _continuousOutput;
 
-	enum class SmoothingType { Stepper = 0, RgbInterpolator = 1, YuvInterpolator = 2, HybridInterpolator = 3, ExponentialInterpolator = 4};
+	enum class SmoothingType { Stepper = 0, RgbInterpolator = 1, YuvInterpolator = 2, HybridInterpolator = 3, ExponentialInterpolator = 4, HybridRgbInterpolator = 5};
 	static QString EnumSmoothingTypeToString(SmoothingType type);
 	static SmoothingType StringToEnumSmoothingType(QString name);
 
diff --git a/sources/base/schema/schema-smoothing.json b/sources/base/schema/schema-smoothing.json
@@ -16,10 +16,10 @@
 		{
 			"type" : "string",
 			"title" : "edt_conf_smooth_type_title",
-			"enum" : ["Stepper", "YuvInterpolator", "RgbInterpolator", "HybridInterpolator", "ExponentialInterpolator"],
-			"default" : "Stepper",
+			"enum" : ["Stepper", "YuvInterpolator", "RgbInterpolator", "HybridInterpolator", "HybridRgbInterpolator", "ExponentialInterpolator"],
+			"default" : "HybridRgbInterpolator",
 			"options" : {
-				"enum_titles" : ["edt_conf_enum_interpolator_Stepper_title", "edt_conf_enum_interpolator_YuvInterpolator_title", "edt_conf_enum_interpolator_RgbInterpolator_title", "edt_conf_enum_interpolator_HybridInterpolator_title", "edt_conf_enum_interpolator_ExponentialInterpolator_title"]
+				"enum_titles" : ["edt_conf_enum_interpolator_Stepper_title", "edt_conf_enum_interpolator_YuvInterpolator_title", "edt_conf_enum_interpolator_RgbInterpolator_title", "edt_conf_enum_interpolator_HybridInterpolator_title", "edt_conf_enum_interpolator_HybridRgbInterpolator_title", "edt_conf_enum_interpolator_ExponentialInterpolator_title"]
 			},
 			"required" : true,
 			"propertyOrder" : 2
@@ -62,7 +62,7 @@
 			"required" : true,
 			"options": {
 				"dependencies": {
-					"type": ["YuvInterpolator", "RgbInterpolator"]
+					"type": ["YuvInterpolator", "RgbInterpolator", "HybridRgbInterpolator"]
 				}
 			},
 			"propertyOrder" : 5
@@ -79,7 +79,7 @@
 			"required" : true,
 			"options": {
 				"dependencies": {
-					"type": "HybridInterpolator"
+					"type": ["HybridInterpolator", "HybridRgbInterpolator"]
 				}
 			},
 			"propertyOrder" : 6
@@ -96,7 +96,7 @@
 			"required" : true,
 			"options": {
 				"dependencies": {
-					"type": "HybridInterpolator"
+					"type": ["HybridInterpolator", "HybridRgbInterpolator"]
 				}
 			},
 			"propertyOrder" : 7
diff --git a/sources/infinite-color-engine/InfiniteHybridRgbInterpolator.cpp b/sources/infinite-color-engine/InfiniteHybridRgbInterpolator.cpp
@@ -0,0 +1,254 @@
+/* InfiniteHybridRgbInterpolator.cpp
+*
+*  MIT License
+*
+*  Copyright (c) 2020-2025 awawa-dev
+*
+*  Project homesite: https://github.com/awawa-dev/HyperHDR
+*
+*  Permission is hereby granted, free of charge, to any person obtaining a copy
+*  of this software and associated documentation files (the "Software"), to deal
+*  in the Software without restriction, including without limitation the rights
+*  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+*  copies of the Software, and to permit persons to whom the Software is
+*  furnished to do so, subject to the following conditions:
+*
+*  The above copyright notice and this permission notice shall be included in all
+*  copies or substantial portions of the Software.
+
+*  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+*  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+*  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+*  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+*  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+*  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+*  SOFTWARE.
+ */
+
+#ifndef PCH_ENABLED
+	#include <QTimer>
+	#include <QThread>	
+
+	#include <cmath>
+	#include <algorithm>
+	#include <chrono>
+	#include <iomanip>
+	#include <iostream>
+	#include <limits>
+	#include <tuple>
+	#include <vector>
+	#include <cassert>
+	#include <cstdint>
+#endif
+
+#include <infinite-color-engine/InfiniteHybridRgbInterpolator.h>
+#include <infinite-color-engine/ColorSpace.h>
+
+using namespace linalg::aliases;
+
+InfiniteHybridRgbInterpolator::InfiniteHybridRgbInterpolator() = default;
+
+void InfiniteHybridRgbInterpolator::setTransitionDuration(float durationMs)
+{
+	_initialDuration = std::max(1.0f, durationMs);
+}
+
+void InfiniteHybridRgbInterpolator::setSpringiness(float stiffness, float damping)
+{
+	_stiffness = std::max(0.1f, stiffness);
+	_damping = std::max(0.1f, damping);
+}
+
+void InfiniteHybridRgbInterpolator::setSmoothingFactor(float factor)
+{
+	_smoothingFactor = std::max(0.0f, std::min(factor, 1.0f));
+}
+
+void InfiniteHybridRgbInterpolator::resetToColors(std::vector<float3> colors, float startTimeMs)
+{
+	_currentColorsRGB.clear();
+	setTargetColors(std::move(colors), startTimeMs);
+}
+
+void InfiniteHybridRgbInterpolator::setTargetColors(std::vector<float3>&& new_rgb_targets, float startTimeMs, bool debug) {
+	if (new_rgb_targets.empty())
+		return;
+
+	const float delta = (!_isAnimationComplete) ? std::max(startTimeMs - _lastUpdate, 0.f) : 0.f;
+
+	if (debug)
+	{
+		printf(" | Δ%.0f | time: %.0f | smoothFactor: %.3f| stiffness: %.3f| damping: %.3f\n", delta, _initialDuration, _smoothingFactor, _stiffness, _damping);
+	}
+
+	startTimeMs -= delta;
+
+	if (_currentColorsRGB.size() != new_rgb_targets.size())
+	{
+		_lastUpdate = startTimeMs;
+		_currentColorsRGB = new_rgb_targets;
+		_targetColorsRGB = std::move(new_rgb_targets);
+		_velocitiesRGB.assign(_currentColorsRGB.size(), float3{ 0,0,0 }); // NOWE
+		_isAnimationComplete = true;
+	}
+	else
+	{
+		if (_smoothingFactor > 0.f)
+		{
+			const float inv = 1.f - _smoothingFactor;
+			for (auto it_oldTargetColorsRGB = _targetColorsRGB.begin(),
+				it_newTargetColorsRGB = new_rgb_targets.begin();
+				it_oldTargetColorsRGB != _targetColorsRGB.end();
+				++it_oldTargetColorsRGB, ++it_newTargetColorsRGB)
+			{
+				*it_oldTargetColorsRGB = *it_oldTargetColorsRGB * _smoothingFactor
+					+ *it_newTargetColorsRGB * inv;
+			}
+		}
+		else
+		{
+			_targetColorsRGB = std::move(new_rgb_targets);
+		}
+		_isAnimationComplete = false;
+	}
+
+	_startAnimationTimeMs = startTimeMs;
+	_targetTime = startTimeMs + _initialDuration;
+}
+
+void InfiniteHybridRgbInterpolator::updateCurrentColors(float currentTimeMs) {
+	if (_isAnimationComplete)
+		return;
+
+	float dt = std::max(currentTimeMs - _lastUpdate, 0.001f);
+	_lastUpdate = currentTimeMs;
+
+	auto computeChannelVec = [&](float3& cur, const float3& tgt, const float3& diff, float3& vel) -> bool {
+		const float FINISH_COMPONENT_THRESHOLD = 0.0013732906f / 10.f;
+		const float VELOCITY_THRESHOLD = 0.0005f;
+
+		if (linalg::maxelem(linalg::abs(diff)) < FINISH_COMPONENT_THRESHOLD && // color match
+			linalg::maxelem(linalg::abs(vel)) < VELOCITY_THRESHOLD) // speed should be almost zero
+		{
+			cur = tgt;
+			vel = float3{ 0,0,0 };
+			return false;
+		}
+		else
+		{
+			float3 acc = _stiffness * diff - _damping * vel;
+
+			// integracja (Euler semi-implicit)
+			vel += acc * (dt * 0.001f);
+			cur += vel * (dt * 0.001f);
+
+			return true;
+		}
+	};
+
+	_isAnimationComplete = true;
+
+	for (auto cur = _currentColorsRGB.begin(), tgt = _targetColorsRGB.begin(), vel = _velocitiesRGB.begin();
+		cur != _currentColorsRGB.end() && tgt != _targetColorsRGB.end() && vel != _velocitiesRGB.end();
+		++cur, ++tgt, ++vel)
+	{
+		if (computeChannelVec(*cur, *tgt, *tgt - *cur, *vel))
+		{
+			_isAnimationComplete = false;
+		}
+	}
+}
+
+SharedOutputColors InfiniteHybridRgbInterpolator::getCurrentColors()
+{
+	auto result = std::make_shared<std::vector<linalg::vec<float, 3>>>();
+	result->reserve(_currentColorsRGB.size());
+
+	for (const auto& rgb : _currentColorsRGB)
+		result->push_back(linalg::clamp(rgb, 0.f, 1.f));
+
+	return result;
+}
+
+void InfiniteHybridRgbInterpolator::test() {
+	using TestTuple = std::tuple<std::string, float3, float3, float3, float3>;
+
+	auto run_test_lambda = [](InfiniteHybridRgbInterpolator& interpolator, const TestTuple& test) {
+		const auto& name = std::get<0>(test);
+		const auto& start_A = std::get<1>(test);
+		const auto& interrupt_C = std::get<2>(test);
+		const auto& interrupt_D = std::get<3>(test);
+		const auto& final_B = std::get<4>(test);
+
+		std::cout << "\n--- TEST: " << name << " ---\n";
+		std::cout << "--------------------------------------------------\n";
+
+		interpolator.resetToColors({ start_A }, 0.f);
+		interpolator.setTransitionDuration(150.0f);
+
+		bool retargeted_to_D = false;
+		bool retargeted_to_B = false;
+
+		for (float time_ms = 0; time_ms <= 1000; time_ms += 25) {
+			if (time_ms == 0) {
+				interpolator.setTargetColors({ interrupt_C }, time_ms);
+			}
+			if (time_ms >= 200 && !retargeted_to_D) {
+				std::cout << "--- ZMIANA CELU 1 @ " << time_ms << "ms (-> D) ---\n";
+				interpolator.setTargetColors({ interrupt_D }, time_ms);
+				retargeted_to_D = true;
+			}
+			if (time_ms >= 350 && !retargeted_to_B) {
+				std::cout << "--- ZMIANA CELU 2 @ " << time_ms << "ms (-> B) ---\n";
+				interpolator.setTargetColors({ final_B }, time_ms);
+				retargeted_to_B = true;
+			}
+
+			interpolator.updateCurrentColors(time_ms);
+
+			auto temp_color = interpolator.getCurrentColors();
+			const auto& current_color = *(temp_color);
+			if (current_color.empty()) continue;
+			
+			std::cout << std::setw(4) << static_cast<int>(time_ms) << "ms: { R: "
+				<< std::fixed << std::setprecision(3) << current_color[0].x
+				<< ", G: " << current_color[0].y
+				<< ", B: " << current_color[0].z
+				<< " }\n";
+		}
+		std::cout << "--------------------------------------------------\n";
+		};
+
+	InfiniteHybridRgbInterpolator interpolator;
+	interpolator.setSpringiness(200.0f, 26.0f);
+
+	std::cout << "\n###########################\n";
+	std::cout << "### URUCHAMIANIE TESTÓW ###\n";
+	std::cout << "#############################\n";
+	interpolator.setMaxLuminanceChangePerFrame(0);
+
+	std::vector<TestTuple> test_cases_unlimited = {
+			{"Test: Czarny -> Ciemny Nieb. -> Jasny Żółty -> Biały", {0,0,0}, {0.1f, 0.1f, 0.4f}, {0.9f, 0.9f, 0.2f}, {1,1,1} },
+			{"Test: Czerwony -> Żółty -> Cyjan -> Niebieski", {1,0,0}, {1,1,0}, {0,1,1}, {0,0,1}},
+			{"Test: Niebieski -> Zielony -> Czerwony -> Złoty", {0,0,1}, {0,1,0}, {1,0,0}, {1,1,0}},
+			{"Test: Magenta -> Cyjan -> Żółty -> Zielony", {1,0,1}, {0,1,1}, {1,1,0}, {0,1,0}},
+			{"Test: Cyjan -> Żółty -> Magenta -> Czerwony", {0,1,1}, {1,1,0}, {1,0,1}, {1,0,0}},
+			{"Test: Niebieski (50%) -> Czerwony -> Zielony -> Złoty (50%)", {0.25f, 0.25f, 0.75f}, {1,0,0}, {0,1,0}, {0.75f, 0.75f, 0.25f}},
+			{"Test: Magenta (50%) -> Niebieski -> Czerwony -> Zielony (50%)", {0.75f, 0.25f, 0.75f}, {0,0,1}, {1,0,0}, {0.25f, 0.75f, 0.25f}},
+			{"Test: Niebieski (25%) -> Szary -> Jasny Szary -> Złoty (25%)", {0.0f, 0.0f, 0.25f}, {0.2f,0.2f,0.2f}, {0.8f,0.8f,0.8f}, {0.25f, 0.25f, 0.0f}},
+			{"Test: Magenta (25%) -> Ciemny Cyjan -> Jasny Żółty -> Zielony (25%)", {0.25f, 0.0f, 0.25f}, {0.0f,0.2f,0.2f}, {0.8f,0.8f,0.0f}, {0.0f, 0.25f, 0.0f}},
+			{"Test: Cyjan (25%) -> Fiolet -> Pomarańcz -> Czerwony (25%)", {0.0f, 0.25f, 0.25f}, {0.5f,0.0f,0.5f}, {1.0f,0.5f,0.0f}, {0.25f, 0.0f, 0.0f}},
+			{"Test: Ciemny Nieb. -> Biały -> Czarny -> Jasny Żółty", {0,0,0.5f}, {1,1,1}, {0,0,0}, {1,1,0.8f}},
+			{"Test: Jasny Czerw. -> Ciemny Nieb. -> Jasny Zielony -> Ciemny Cyjan", {1,0,0}, {0,0,0.2f}, {0.5f,1.0f,0.5f}, {0.1f, 0.4f, 0.4f}},
+			{"Test: Zielony -> Fiolet -> Cyjan -> Czerwony", {0,1,0}, {0.5f,0,1.0f}, {0,1,1}, {1,0,0}},
+			{"Test: Zielony -> Żółty -> Niebieski -> Magenta", {0,1,0}, {1,1,0}, {0,0,1}, {1,0,1}},
+			{"Test: Biały -> Czerwony -> Zielony -> Niebieski", {1,1,1}, {1,0,0}, {0,1,0}, {0,0,1}},
+			{"Test: Zielony -> Cyjan -> Czerwony -> Niebieski", {0,1,0}, {0,1,1}, {1,0,0}, {0,0,1}},
+			{"Test: Test Odwrócenia (Biały -> Czarny -> Biały -> Czarny)", {1,1,1}, {0,0,0}, {1,1,1}, {0,0,0}},
+			{"Test: Test Oscylacji (Żółty -> Niebieski -> Żółty -> Niebieski)", {1,1,0}, {0,0,1}, {1,1,0}, {0,0,1}},
+			{"Test: Test Oscylacji (Magenta -> Zielony -> Magenta -> Zielony)", {1,0,1}, {0,1,0}, {1,0,1}, {0,1,0}}
+	};
+	for (const auto& test : test_cases_unlimited) {
+		run_test_lambda(interpolator, test);
+	}
+}
diff --git a/sources/infinite-color-engine/InfiniteSmoothing.cpp b/sources/infinite-color-engine/InfiniteSmoothing.cpp
@@ -48,6 +48,7 @@
 #include <infinite-color-engine/InfiniteYuvInterpolator.h>
 #include <infinite-color-engine/InfiniteRgbInterpolator.h>
 #include <infinite-color-engine/InfiniteHybridInterpolator.h>
+#include <infinite-color-engine/InfiniteHybridRgbInterpolator.h>
 #include <infinite-color-engine/InfiniteExponentialInterpolator.h>
 #include <base/HyperHdrInstance.h>
 
@@ -113,6 +114,10 @@ void InfiniteSmoothing::clearQueuedColors(bool deviceEnabled, bool restarting)
 			{
 				_interpolator = std::make_unique<InfiniteHybridInterpolator>();
 			}
+			else if (cfg->type == SmoothingType::HybridRgbInterpolator)
+			{
+				_interpolator = std::make_unique<InfiniteHybridRgbInterpolator>();
+			}
 			else if (cfg->type == SmoothingType::YuvInterpolator)
 			{
 				_interpolator = std::make_unique<InfiniteYuvInterpolator>();
@@ -375,6 +380,8 @@ QString InfiniteSmoothing::EnumSmoothingTypeToString(SmoothingType type)
 		return QString("HybridInterpolator");
 	else if (type == SmoothingType::ExponentialInterpolator)
 		return QString("ExponentialInterpolator");
+	else if (type == SmoothingType::HybridRgbInterpolator)
+		return QString("HybridRgbInterpolator");
 
 	return QString("Stepper");
 }
@@ -389,6 +396,8 @@ InfiniteSmoothing::SmoothingType InfiniteSmoothing::StringToEnumSmoothingType(QS
 		return SmoothingType::HybridInterpolator;
 	else if (name == QString("ExponentialInterpolator"))
 		return SmoothingType::ExponentialInterpolator;
+	else if (name == QString("HybridRgbInterpolator"))
+		return SmoothingType::HybridRgbInterpolator;
 
 	return SmoothingType::Stepper;
 }
diff --git a/www/i18n/en.json b/www/i18n/en.json
@@ -1278,8 +1278,10 @@
   "edt_conf_enum_interpolator_RgbInterpolator_expl": "This algorithm smoothly animates RGB colors over a set duration, offering two distinct modes for the transition. The first is a direct linear interpolation for a straight path between colors, while the second is a smoothed mode where the current color gracefully 'chases' the target to create an ease-in/ease-out effect. A key feature is its ability to intelligently rescale an animation's duration when interrupted, ensuring a perceptually constant speed of change.",
   "edt_conf_enum_interpolator_YuvInterpolator_title": "YUV Infinite Interpolator",
   "edt_conf_enum_interpolator_YuvInterpolator_expl": "This algorithm smoothly interpolates colors by operating in the YUV color space for more perceptually uniform transitions. Its main feature is limiting the rate of luminance change in each step, preventing sudden, jarring flashes of brightness. This ensures a visually pleasing effect, even if it extends the animation beyond its initially set duration to maintain that smoothness.",
-  "edt_conf_enum_interpolator_HybridInterpolator_title": "Hybrid Physics Infinite Interpolator",
+  "edt_conf_enum_interpolator_HybridInterpolator_title": "Hybrid Physics Infinite Interpolator (YUV)",
   "edt_conf_enum_interpolator_HybridInterpolator_expl": "This algorithm smoothly transitions between colors using a hybrid physical model. A linear 'pacer' defines the direct path and timing to the target color, while the actual output color follows this pacer like an object attached to a damped spring. This two-part approach creates fluid, natural-looking animations with customizable inertia and overshoot, all while operating in the perceptually-uniform YUV color space.",
+  "edt_conf_enum_interpolator_HybridRgbInterpolator_title": "Hybrid Physics Infinite Interpolator (RGB)",
+  "edt_conf_enum_interpolator_HybridRgbInterpolator_expl": "This algorithm smoothly transitions between colors using a hybrid physical model. A linear 'pacer' defines the direct path and timing to the target color, while the actual output color follows this pacer like an object attached to a damped spring. This two-part approach creates fluid, natural-looking animations with customizable inertia and overshoot, all while operating in the RGB color space.",
   "edt_conf_enum_interpolator_smoothingFactor_title": "Smoothing factor",
   "edt_conf_enum_interpolator_smoothingFactor_expl": "The parameter dictates the animation's feel, controlling how it transitions between colors. It accepts a value from 0.0 to 1.0, where 0.0 results in a direct, linear change. Higher values introduce more smoothing, creating a fluid 'chasing' motion as the current color lags slightly behind the ideal position.",
   "edt_conf_enum_interpolator_stiffness_title": "Stiffness",
diff --git a/www/js/processing.js b/www/js/processing.js
