only max+min measure ; tests

Author: schaumb

src/base/math/range.h

@@ -46,7 +46,7 @@ template <std::floating_point T = double> struct Range
 		    && !is_lt(std::weak_order(max, value));
 	}
 
-	[[nodiscard]] T rescale(const T &value, T def = 0.5) const
+	[[nodiscard]] T rescale(const T &value, T def = T{0.5}) const
 	{
 		auto s = size();
 		return is_zero(s) ? def : (value - min) / s;
@@ -64,7 +64,7 @@ template <std::floating_point T = double> struct Range
 
 	[[nodiscard]] T normalize(const T &value) const
 	{
-		return is_zero(max) ? 0 : value / max;
+		return is_zero(max) ? T{} : value / max;
 	}
 
 	bool operator==(const Range &other) const
@@ -97,14 +97,15 @@ template <std::floating_point T = double> struct Range
 		return {min / factor, max / factor};
 	}
 
-	Range operator*(const Transform &transf)
+	[[nodiscard]] Range operator*(const Transform &transf) const
 	{
 		return *this * transf.factor + transf.shift;
 	}
 
-	Transform operator/(const Range range)
+	[[nodiscard]] Transform operator/(const Range range) const
 	{
-		auto factor = range.size() != 0 ? size() / range.size() : 0;
+		auto factor =
+		    is_zero(range.size()) ? T{} : size() / range.size();
 		auto shift = min - range.min * factor;
 		return Transform{factor, shift};
 	}

src/chart/generator/axis.cpp

@@ -380,7 +380,8 @@ interpolate(const SplitAxis &op0, const SplitAxis &op1, double factor)
 
 	using PartPair = SplitAxis::Parts::value_type;
 
-	auto needMerge = op0.seriesName() == op1.seriesName();
+	auto needMerge = op0.seriesName() == op1.seriesName()
+	              && op0.measure.unit == op1.measure.unit;
 
 	auto &&merger = [](double factor)
 	{
@@ -393,27 +394,20 @@ interpolate(const SplitAxis &op0, const SplitAxis &op1, double factor)
 	};
 
 	using MergerType = decltype(merger(0.0));
-	auto &&one_side =
-	    [needMerge](const MergerType &merger, bool needOther)
+	auto &&one_side = [](const MergerType &merger,
+	                      bool needOther,
+	                      const Math::Range<>::Transform &transform)
 	{
-		return
-		    [needMerge, &merger, needOther, firstSpecial = needOther](
-		        const PartPair &val) mutable -> PartPair
+		return [&merger, &transform, needOther](
+		           const PartPair &val) -> PartPair
 		{
-			if (needMerge) {
-				if (firstSpecial) {
-					firstSpecial = false;
-					return merger(val,
-					    PartPair{std::nullopt, SplitAxis::Part{}});
-				}
-
-				Math::Range<> range{0.0, 1.0};
-				if (!needOther)
-					range = {val.second.range.max,
-					    val.second.range.max};
-
-				return merger(val, {{}, {0.0, range}});
-			}
+			if (needOther)
+				return merger(val,
+				    {{},
+				        {0.0,
+				            (Math::Range<>{0, 1} * transform),
+				            (val.second.measureRange * 1.000001
+				                * transform)}});
 			return merger(val,
 			    {{},
 			        {0.0,
@@ -431,24 +425,45 @@ interpolate(const SplitAxis &op0, const SplitAxis &op1, double factor)
 	        std::identity,
 	        const std::optional<Data::SliceIndex> PartPair::*,
 	        decltype(std::weak_order),
-	        decltype(one_side(merger({}), {})),
-	        decltype(one_side(merger({}), {})),
+	        decltype(one_side(merger({}), {}, {})),
+	        decltype(one_side(merger({}), {}, {})),
 	        Alg::Merge::always,
 	        const MergerType &>
 	    // }
 	    {.projection = &PartPair::first,
-	        .transformer_1 =
-	            one_side(merger(factor), op1.parts.size() <= 1),
-	        .transformer_2 =
-	            one_side(merger(1 - factor), op0.parts.size() <= 1),
+	        .transformer_1 = one_side(merger(factor),
+	            needMerge && op1.parts.empty(),
+	            (op0.measure.range - op0.measure.range.min)
+	                / (op1.measure.range - op1.measure.range.min)),
+	        .transformer_2 = one_side(merger(1 - factor),
+	            needMerge && op0.parts.empty(),
+	            (op1.measure.range - op1.measure.range.min)
+	                / (op0.measure.range - op0.measure.range.min)),
 	        .need_merge = {needMerge},
 	        .merger = merger(factor)});
 
-	if (!needMerge && op0.parts.empty() != op1.parts.empty()
+	if (op0.parts.empty() != op1.parts.empty()
 	    && (op0.dimension.hasMarker || op0.measure.enabled.get())
-	    && (op1.dimension.hasMarker || op1.measure.enabled.get()))
-		res.parts.insert({std::nullopt,
-		    {.weight = op0.parts.empty() ? 1 - factor : factor}});
+	    && (op1.dimension.hasMarker || op1.measure.enabled.get())) {
+		if (needMerge) {
+			const auto &ref =
+			    (op0.parts.empty() ? op1.parts : op0.parts)
+			        .begin()
+			        ->second.range;
+			res.parts
+			    .insert(
+			        merger(op0.parts.empty()
+			                   ? 1 - factor
+			                   : factor)({{}, {0.0, ref}}, {{}, {}}))
+			    ->second.unique = true;
+		}
+		else
+			res.parts
+			    .insert({std::nullopt,
+			        {.weight =
+			                op0.parts.empty() ? 1 - factor : factor}})
+			    ->second.unique = true;
+	}
 
 	return res;
 }

src/chart/generator/axis.h

@@ -204,9 +204,18 @@ struct SplitAxis : Axis
 		double weight{1.0};
 		Math::Range<> range{0, 1};
 		Math::Range<> measureRange{0, 1};
+		bool unique{};
 
 		[[nodiscard]] bool operator==(
 		    const Part &other) const = default;
+
+		[[nodiscard]] consteval static auto members()
+		{
+			return std::tuple{&Part::weight,
+			    &Part::range,
+			    &Part::measureRange,
+			    std::ignore};
+		}
 	};
 
 	using Parts =

src/chart/rendering/drawaxes.cpp

@@ -57,10 +57,12 @@ void DrawAxes::drawGeometries() const
 
 			DrawInterlacing{*this}.drawGeometries(Gen::AxisId::y,
 			    ySplit.measureRange,
+			    xSplit.measureRange,
 			    tr,
 			    weight);
 			DrawInterlacing{*this}.drawGeometries(Gen::AxisId::x,
 			    xSplit.measureRange,
+			    ySplit.measureRange,
 			    tr,
 			    weight);
 
@@ -79,41 +81,47 @@ void DrawAxes::drawGeometries() const
 
 			DrawGuides{*this}.draw(Gen::AxisId::x,
 			    xSplit.measureRange,
+			    ySplit.measureRange,
 			    tr,
 			    weight);
 			DrawGuides{*this}.draw(Gen::AxisId::y,
 			    ySplit.measureRange,
+			    xSplit.measureRange,
 			    tr,
 			    weight);
 		}
 }
 
 void DrawAxes::drawLabels() const
 {
-	for (auto &&ySplit : std::views::values(splits[Gen::AxisId::y])) {
+	auto &&yValues = std::views::values(splits[Gen::AxisId::y]);
+	for (auto &&ySplit : yValues) {
 		const Geom::AffineTransform tr{1,
 		    0.0,
-		    0,
+		    0.0,
 		    0.0,
 		    ySplit.range.size(),
 		    ySplit.range.min};
 		DrawInterlacing{*this}.drawTexts(Gen::AxisId::y,
 		    ySplit.measureRange,
 		    tr,
-		    ySplit.weight);
+		    ySplit.weight,
+		    yValues.size() > 1 && !ySplit.unique);
 	}
 
-	for (auto &&xSplit : std::views::values(splits[Gen::AxisId::x])) {
+	auto &&xValues = std::views::values(splits[Gen::AxisId::x]);
+	for (auto &&xSplit : xValues) {
 		const Geom::AffineTransform tr{xSplit.range.size(),
 		    0.0,
 		    xSplit.range.min,
 		    0.0,
-		    1,
-		    0};
+		    1.0,
+		    0.0};
 		DrawInterlacing{*this}.drawTexts(Gen::AxisId::x,
 		    xSplit.measureRange,
 		    tr,
-		    xSplit.weight);
+		    xSplit.weight,
+		    xValues.size() > 1 && !xSplit.unique);
 	}
 
 	drawDimensionLabels(Gen::AxisId::x);

src/chart/rendering/drawguides.cpp

@@ -16,6 +16,7 @@ namespace Vizzu::Draw
 {
 void DrawGuides::draw(Gen::AxisId axisId,
     const Math::Range<> &filter,
+    const Math::Range<> &otherFilter,
     const Geom::AffineTransform &tr,
     double w)
 {
@@ -31,6 +32,7 @@ void DrawGuides::draw(Gen::AxisId axisId,
 		for (const auto &sep : parent.getSeparators(axisId, filter))
 			drawGuide(axisId,
 			    sep.position,
+			    otherFilter,
 			    tr,
 			    baseColor
 			        * Math::FuzzyBool::And<double>(w,
@@ -43,15 +45,15 @@ void DrawGuides::draw(Gen::AxisId axisId,
 
 void DrawGuides::drawGuide(Gen::AxisId axisId,
     double val,
+    const Math::Range<> &otherFilter,
     const Geom::AffineTransform &tr,
     const Gfx::Color &color)
 {
-	auto ident = Geom::Point::Ident(orientation(axisId));
-	auto normal = Geom::Point::Ident(!orientation(axisId));
-	auto relMax = ident * val;
-
+	auto o = orientation(axisId);
 	parent.canvas.setLineColor(color);
-	auto line = tr(Geom::Line{relMax, relMax + normal});
+	auto line =
+	    tr(Geom::Line{Geom::Point::Coord(o, val, otherFilter.min),
+	        Geom::Point::Coord(o, val, otherFilter.max)});
 	if (auto &&eventTarget = Events::Targets::axisGuide(axisId);
 	    parent.rootEvents.draw.plot.axis.guide->invoke(
 	        Events::OnLineDrawEvent(*eventTarget, {line, true}))) {

src/chart/rendering/drawguides.h

@@ -12,6 +12,7 @@ class DrawGuides
 public:
 	void draw(Gen::AxisId axisId,
 	    const Math::Range<> &filter,
+	    const Math::Range<> &otherFilter,
 	    const Geom::AffineTransform &tr,
 	    double w);
 
@@ -20,6 +21,7 @@ class DrawGuides
 private:
 	void drawGuide(Gen::AxisId axisId,
 	    double val,
+	    const Math::Range<> &otherFilter,
 	    const Geom::AffineTransform &tr,
 	    const Gfx::Color &color);
 };

src/chart/rendering/drawinterlacing.cpp

@@ -30,16 +30,19 @@ namespace Vizzu::Draw
 
 void DrawInterlacing::drawGeometries(Gen::AxisId axisIndex,
     const Math::Range<> &filter,
+    const Math::Range<> &otherFilter,
     const Geom::AffineTransform &tr,
     double w) const
 {
 	const auto &guides = parent.plot->guides.at(axisIndex);
 	const auto &axisStyle = parent.rootStyle.plot.getAxis(axisIndex);
 	if (axisStyle.interlacing.color->isTransparent()
-	    || guides.interlacings == false)
+	    || guides.interlacings == false
+	    || Math::Floating::is_zero(otherFilter.size()))
 		return;
 
-	auto otherWeights = getInterlacingWeights(!axisIndex);
+	auto otherWeights =
+	    getInterlacingWeights(!axisIndex, otherFilter);
 	auto &&otherInterlacingColor =
 	    *parent.rootStyle.plot.getAxis(!axisIndex).interlacing.color;
 
@@ -101,7 +104,8 @@ void DrawInterlacing::drawGeometries(Gen::AxisId axisIndex,
 void DrawInterlacing::drawTexts(Gen::AxisId axisIndex,
     const Math::Range<> &filter,
     const Geom::AffineTransform &tr,
-    double w) const
+    double w,
+    bool onlyOne) const
 {
 	const auto &axis = parent.getAxis(axisIndex).measure;
 	auto orientation = !Gen::orientation(axisIndex);
@@ -123,10 +127,45 @@ void DrawInterlacing::drawTexts(Gen::AxisId axisIndex,
 
 	if (!needText && !needTick) return;
 
+	std::array<std::array<const DrawAxes::Separator *, 2>, 2>
+	    latests{};
+
+	if (needText && onlyOne)
+		for (const auto &sep :
+		    parent.getSeparators(axisIndex, filter)) {
+			if (!sep.label) continue;
+			if (auto &&cmp = std::weak_order(*sep.label, 0.0);
+			    !is_eq(cmp)
+			    && (!latests[is_lt(cmp)][0]
+			        || std::abs(*latests[is_lt(cmp)][0]->label)
+			               < std::abs(*sep.label))) {
+				auto &[f, s] = latests[is_lt(cmp)];
+				if (!s)
+					s = std::addressof(sep);
+				else if (std::abs(*s->label) < std::abs(*sep.label)) {
+					if (Math::AddTolerance(s->weight + sep.weight)
+					    == 1.0)
+						f = s;
+					else if (f
+					         && Math::AddTolerance(
+					                f->weight + sep.weight)
+					                > 1.0)
+						f = nullptr;
+					s = std::addressof(sep);
+				}
+				else if (Math::AddTolerance(s->weight + sep.weight)
+				         == 1.0)
+					f = std::addressof(sep);
+			}
+		}
+
 	for (const auto &sep : parent.getSeparators(axisIndex, filter)) {
 		auto tickPos =
 		    Geom::Point::Coord(orientation, origo, sep.position);
-		if (needText && sep.label)
+		if (needText && sep.label
+		    && (!onlyOne || &sep == latests[0][0]
+		        || &sep == latests[0][1] || &sep == latests[1][0]
+		        || &sep == latests[1][1]))
 			drawDataLabel(axis.enabled,
 			    axisIndex,
 			    tickPos,
@@ -280,9 +319,11 @@ void DrawInterlacing::drawSticks(double tickLength,
 }
 
 std::map<double, double> DrawInterlacing::getInterlacingWeights(
-    Gen::AxisId axisIndex) const
+    Gen::AxisId axisIndex,
+    const Math::Range<> &filter) const
 {
-	std::map<double, double> weights{{0.0, 0.0}, {1.0, 0.0}};
+	std::map<double, double> weights{{filter.min, 0.0},
+	    {filter.max, 0.0}};
 
 	auto &&guides = parent.plot->guides.at(axisIndex);
 	auto &&axisStyle = parent.rootStyle.plot.getAxis(axisIndex);
@@ -291,9 +332,12 @@ std::map<double, double> DrawInterlacing::getInterlacingWeights(
 		return weights;
 
 	for (auto &&interval : parent.getIntervals(axisIndex)) {
-		if (Math::Floating::is_zero(interval.isSecond)) continue;
-		auto min = std::max(interval.range.min, 0.0);
-		auto max = std::min(interval.range.max, 1.0);
+		if (Math::Floating::is_zero(interval.isSecond)
+		    || !interval.range.intersects(filter))
+			continue;
+		auto min = std::max(interval.range.min, filter.min);
+		auto max = std::min(interval.range.max, filter.max);
+
 		auto mprev = std::prev(weights.upper_bound(min));
 		auto mnext = weights.lower_bound(max);