Merge pull request #555 from vizzuhq/review

#549 review changes

Author: schaumb

CHANGELOG.md

@@ -4,12 +4,26 @@
 
 ### Fixed
 
-- First marker alpha was different to other marker's alpha
-- Make some transactions clearer. (rectangle-line first marker)
+- Make some static charts clearer:
+  - Area/line charts different markers are not connected.
+  - Not existing or disabled markers have no effect.
+- Make some transactions clearer:
+  - Rectangle - Line/Area first marker not fades, but shrinks.
+  - The first marker's alpha was different to the other marker's alpha.
+  - Marker connection rework: Introduce invalid, polar and self connection.
+  - Marker connection animation step necessity and timing fixes.
+  - Slipped animation steps (coordinateSystem - connection/orientation) fixes.
+  - Filtered markers (and their connections):
+    - Disappearing on hide animation phase.
+    - Appearing on show animation phase.
 
 ### Added
 
-- New data handling implemented: Not generating big cube
+- New data handling implemented:
+  - Only existing data generates the chart.
+  - Reduced memory usage.
+  - Bigger data capacity.
+- Canvas line drawing detail can be set (on C++ side).
 
 ## [0.11.4] - 2024-07-09
 

src/apps/weblib/cinterface.cpp

@@ -193,10 +193,12 @@ void vizzu_render(APIHandles::Chart chart,
 }
 
 void vizzu_setLineResolution(APIHandles::Canvas canvas,
-    double dMax,
-    double hMax)
+    double distanceMax,
+    double curveHeightMax)
 {
-	Interface::getInstance().setLineResolution(canvas, dMax, hMax);
+	Interface::getInstance().setLineResolution(canvas,
+	    distanceMax,
+	    curveHeightMax);
 }
 
 const char *style_getList() { return Interface::getStyleList(); }

src/apps/weblib/cinterface.h

@@ -69,8 +69,8 @@ extern void vizzu_render(APIHandles::Chart chart,
     double width,
     double height);
 extern void vizzu_setLineResolution(APIHandles::Canvas canvas,
-    double dMax,
-    double hMax);
+    double distanceMax,
+    double curveHeightMax);
 
 extern const char *vizzu_errorMessage(
     APIHandles::Exception exceptionPtr,

src/apps/weblib/interface.cpp

@@ -404,12 +404,12 @@ void Interface::render(ObjectRegistryHandle chart,
 }
 
 void Interface::setLineResolution(ObjectRegistryHandle canvas,
-    double dMax,
-    double hMax)
+    double distanceMax,
+    double curveHeightMax)
 {
 	static_cast<Draw::Painter *>(
 	    objects.get<Gfx::ICanvas>(canvas)->getPainter())
-	    ->setPathSamplerOptions({dMax, hMax});
+	    ->setPathSamplerOptions({distanceMax, curveHeightMax});
 }
 
 void Interface::pointerDown(ObjectRegistryHandle chart,

src/apps/weblib/interface.h

@@ -56,8 +56,8 @@ class Interface
 	    double width,
 	    double height);
 	void setLineResolution(ObjectRegistryHandle canvas,
-	    double dMax,
-	    double hMax);
+	    double distanceMax,
+	    double curveHeightMax);
 
 	ObjectRegistryHandle storeAnim(ObjectRegistryHandle chart);
 	void restoreAnim(ObjectRegistryHandle chart,

src/apps/weblib/ts-api/cvizzu.types.d.ts

@@ -91,8 +91,8 @@ export interface CVizzu {
 	_vizzu_pointerLeave(chart: CChartPtr, canvas: CCanvasPtr, pointerId: number): void
 	_vizzu_wheel(chart: CChartPtr, canvas: CCanvasPtr, delta: number): void
 	_vizzu_setLogging(enable: boolean): void
-	_vizzu_update(chart: CChartPtr, time: number): CString
-	_vizzu_setLineResolution(canvas: CCanvasPtr, dMax: number, hMax: number): void
+	_vizzu_update(chart: CChartPtr, time: number): void
+	_vizzu_setLineResolution(canvas: CCanvasPtr, distanceMax: number, curveHeightMax: number): void
 	_vizzu_render(chart: CChartPtr, canvas: CCanvasPtr, width: number, height: number): void
 
 	_vizzu_errorMessage(exceptionPtr: CException, typeinfo: CTypeInfo): CString

src/base/anim/interpolated.h

@@ -34,13 +34,12 @@ template <typename Type> class Weighted
 		return value == other.value && weight == other.weight;
 	}
 
-	template <typename Comparator =
-	              std::conditional_t<std::floating_point<Type>,
-	                  decltype(Math::Floating::less),
-	                  std::less<Type>>>
 	bool operator<(const Weighted<Type> &other) const
 	{
-		return Comparator{}(value, other.value);
+		using Less = std::conditional_t<std::floating_point<Type>,
+		    decltype(Math::Floating::less),
+		    std::less<Type>>;
+		return Less{}(value, other.value);
 	}
 
 	[[nodiscard]] bool hasValue() const { return weight > 0.0; }
@@ -224,28 +223,26 @@ template <typename Type> class Interpolated
 		return res;
 	}
 
-	template <typename T = Type,
-	    typename Cmp = std::conditional_t<std::floating_point<T>,
-	        decltype(Math::Floating::less),
-	        std::less<T>>>
-	[[nodiscard]] T min() const
+	template <typename T = Type> [[nodiscard]] T min() const
 	{
+		using Less = std::conditional_t<std::floating_point<T>,
+		    decltype(Math::Floating::less),
+		    std::less<T>>;
 		return !has_second ? this->values[0].value
 		                   : std::min(this->values[0].value,
 		                       this->values[1].value,
-		                       Cmp{});
+		                       Less{});
 	}
 
-	template <typename T = Type,
-	    typename Cmp = std::conditional_t<std::floating_point<T>,
-	        decltype(Math::Floating::less),
-	        std::less<T>>>
-	[[nodiscard]] T max() const
+	template <typename T = Type> [[nodiscard]] T max() const
 	{
+		using Less = std::conditional_t<std::floating_point<T>,
+		    decltype(Math::Floating::less),
+		    std::less<T>>;
 		return !has_second ? this->values[0].value
 		                   : std::max(this->values[0].value,
 		                       this->values[1].value,
-		                       Cmp{});
+		                       Less{});
 	}
 };
 

src/base/gfx/pathsampler.cpp

@@ -32,19 +32,19 @@ void PathSampler::path(const Geom::Point &pConv0,
 	auto height = 2 * area / (pConv1 - pConv0).abs();
 
 	auto needMore =
-	    height > options.hMax
+	    height > options.curveHeightMax
 	    || ((pConv1 - pConv0).sqrAbs() < (pConv - pConv0).sqrAbs())
 	    || ((pConv1 - pConv0).sqrAbs() < (pConv - pConv1).sqrAbs());
 
 	if (needMore) {
-		if ((pConv - pConv0).sqrAbs() > options.dMax)
+		if ((pConv - pConv0).sqrAbs() > options.distanceMax)
 			path(pConv0, pConv, i0, i, recurseCnt + 1);
 	}
 
 	addPoint(pConv);
 
 	if (needMore) {
-		if ((pConv - pConv1).sqrAbs() > options.dMax)
+		if ((pConv - pConv1).sqrAbs() > options.distanceMax)
 			path(pConv, pConv1, i, i1, recurseCnt + 1);
 	}
 }

src/base/gfx/pathsampler.h

@@ -13,8 +13,8 @@ class PathSampler
 public:
 	struct Options
 	{
-		double dMax;
-		double hMax;
+		double distanceMax;
+		double curveHeightMax;
 	};
 	explicit PathSampler(const Options &options) : options(options) {}
 

src/base/math/floating.h

@@ -1,10 +1,8 @@
 #ifndef MATH_FLOATING
 #define MATH_FLOATING
 
-#include <bit>
 #include <compare>
 #include <concepts>
-#include <cstdint>
 #include <limits>
 
 namespace Math::Floating
@@ -18,43 +16,11 @@ constexpr auto inline less = [](auto a, auto b)
 	return std::is_lt(std::strong_order(a, b));
 };
 
-template <std::floating_point F,
-    std::size_t v =
-        std::numeric_limits<F>::is_iec559
-                        &&std::numeric_limits<F>::radix
-                    == 2
-                && std::numeric_limits<unsigned char>::digits == 8
-            ? sizeof(F)
-            : std::size_t{}>
-constexpr auto inline can_be_used_as_short_check =
-    std::bool_constant<false>{};
-
-template <std::floating_point F>
-constexpr auto inline can_be_used_as_short_check<F, 4> =
-    std::integral_constant<std::uint32_t,
-        std::bit_cast<std::uint32_t>(F{0.0}) == std::uint32_t{}
-            && std::bit_cast<std::uint32_t>(F{-0.0})
-                       + std::bit_cast<std::uint32_t>(F{-0.0})
-                   == std::uint32_t{}>{};
-
-template <std::floating_point F>
-constexpr auto inline can_be_used_as_short_check<F, 8> =
-    std::integral_constant<std::uint64_t,
-        std::bit_cast<std::uint64_t>(F{0.0}) == std::uint64_t{}
-            && std::bit_cast<std::uint64_t>(F{-0.0})
-                       + std::bit_cast<std::uint64_t>(F{-0.0})
-                   == std::uint64_t{}>{};
-
 constexpr auto inline is_zero = [](auto value)
 {
 	using F = decltype(value);
 	static_assert(std::floating_point<F>);
-	if constexpr (auto v = can_be_used_as_short_check<F>; v()) {
-		const auto val =
-		    std::bit_cast<typename decltype(v)::value_type>(value);
-		return val + val == 0;
-	}
-	else if constexpr (std::numeric_limits<F>::is_iec559) {
+	if constexpr (std::numeric_limits<F>::is_iec559) {
 		return value == F{};
 	}
 	else {