Axis refactor v11e - Cross interlacing, NaN handling, off dimLabel out

CHANGELOG.md

@@ -27,6 +27,9 @@
 - Enable dimension axis ticks and interlacing.
 - Enable measure axis guides.
 - Fix dimension axis guides on sorted chart.
+- Fix NaN handling on axes and size measures other aggregators than sum.
+- Add meaning to crossing interlacing.
+- Do not draw dimension axis labels when the middle of the text is off the plot.
 
 ## [0.15.0] - 2024-10-28
 

src/base/type/uniquelist.h

@@ -237,7 +237,7 @@ template <class T> class UniqueList
 	struct CommonIterateVal
 	{
 		const T &value;
-		const std::size_t *othIx;
+		const std::size_t *otherIx;
 	};
 
 	struct common_iterator

src/chart/generator/axis.cpp

@@ -287,7 +287,9 @@ bool DimensionAxis::setLabels(double step)
 	auto currStep = 0.0;
 
 	for (auto curr = int{}; auto &&item : sortedItems()) {
-		if (++curr <= currStep) continue;
+		if (auto mid = item.get().range.middle();
+		    std::signbit(mid) || mid > 1.0 || ++curr <= currStep)
+			continue;
 		currStep += step;
 		item.get().label = true;
 		hasLabel = true;

src/chart/generator/axis.h

@@ -40,7 +40,8 @@ struct ChannelStats
 
 	void track(ChannelId at, const double &value)
 	{
-		std::get<0>(tracked[at]).include(value);
+		if (std::isfinite(value))
+			std::get<0>(tracked[at]).include(value);
 	}
 
 	template <ChannelIdLike Id>

src/chart/generator/buckets.h

@@ -44,9 +44,10 @@ struct Buckets
 			    });
 		}
 
-		[[nodiscard]] bool operator!=(const const_iterator &oth) const
+		[[nodiscard]] bool operator!=(
+		    const const_iterator &other) const
 		{
-			return data.data() != oth.data.data();
+			return data.data() != other.data.data();
 		}
 
 		const_iterator &operator++();

src/chart/generator/marker.cpp

@@ -140,6 +140,9 @@ Marker::Marker(const Options &options,
 		        data.joinDimensionValues(labelChannel.dimensions(),
 		            index)};
 	}
+
+	if (!std::isfinite(position.x) || !std::isfinite(position.y))
+		enabled = false;
 }
 
 bool Marker::connectMarkers(bool first,

src/chart/generator/plotbuilder.cpp

@@ -48,13 +48,16 @@ PlotBuilder::PlotBuilder(const Data::DataTable &dataTable,
 	std::size_t mainBucketSize{};
 	auto &&subBuckets = generateMarkers(mainBucketSize);
 
-	if (!plot->getOptions()->getChannels().anyAxisSet())
+	if (!plot->getOptions()->getChannels().anyAxisSet()) {
 		addSpecLayout(subBuckets);
-	else
+		normalizeSizes();
+	}
+	else {
+		normalizeSizes();
 		addAxisLayout(subBuckets, mainBucketSize, dataTable);
+	}
 
 	normalizeColors();
-	normalizeSizes();
 	calcLegendAndLabel(dataTable);
 }
 
@@ -551,8 +554,11 @@ void PlotBuilder::normalizeSizes()
 	    || plot->getOptions()->geometry == ShapeType::line) {
 		Math::Range<> size;
 
-		for (auto &marker : plot->markers)
-			if (marker.enabled) size.include(marker.sizeFactor);
+		for (auto &marker : plot->markers) {
+			if (std::isnan(marker.sizeFactor)) marker.enabled = false;
+			if (!marker.enabled) continue;
+			size.include(marker.sizeFactor);
+		}
 
 		size = plot->getOptions()
 		           ->getChannels()

src/chart/rendering/drawaxes.cpp

@@ -101,7 +101,8 @@ const DrawAxes &&DrawAxes::init() &&
 			        !item.startPos.isAuto() && *item.startPos,
 			        !item.endPos.isAuto() && *item.endPos,
 			        axis.dimension.factor);
-			    needSeparators && sepWeight > 0)
+			    needSeparators && sepWeight > 0
+			    && item.range.getMin() > 0)
 				separators.emplace_back(item.range.getMin(),
 				    sepWeight);
 		}

src/chart/rendering/drawinterlacing.cpp

@@ -34,7 +34,9 @@ void DrawInterlacing::drawGeometries(Gen::AxisId axisIndex) const
 	    || guides.interlacings == false)
 		return;
 
-	auto orientation = !+axisIndex;
+	auto otherWeights = getInterlacingWeights(!axisIndex);
+	auto &&otherInterlacingColor =
+	    *parent.rootStyle.plot.getAxis(!axisIndex).interlacing.color;
 
 	parent.painter.setPolygonToCircleFactor(0);
 	parent.painter.setPolygonStraightFactor(0);
@@ -48,30 +50,42 @@ void DrawInterlacing::drawGeometries(Gen::AxisId axisIndex) const
 		                       1.0,
 		                       Math::Floating::less)
 		                 - clippedBottom;
-		auto rect = Geom::Rect{
-		    Geom::Point::Coord(orientation, 0.0, clippedBottom),
-		    {Geom::Size::Coord(orientation, 1.0, clippedSize)}};
-
-		auto interlacingColor =
-		    *axisStyle.interlacing.color
-		    * Math::FuzzyBool::And<double>(interval.weight,
-		        interval.isSecond,
-		        guides.interlacings);
-
-		auto &canvas = parent.canvas;
-		canvas.save();
-		canvas.setLineColor(Gfx::Color::Transparent());
-		canvas.setBrushColor(interlacingColor);
-		if (auto &&eventTarget =
-		        Events::Targets::axisInterlacing(axisIndex);
-		    parent.rootEvents.draw.plot.axis.interlacing->invoke(
-		        Events::OnRectDrawEvent(*eventTarget,
-		            {rect, true}))) {
-			parent.painter.drawPolygon(rect.points());
-			parent.renderedChart.emplace(Rect{rect, true},
-			    std::move(eventTarget));
+
+		auto rect = [&, orientation = +axisIndex](const double &from,
+		                const double &to)
+		{
+			return Geom::Rect{
+			    Geom::Point::Coord(orientation, clippedBottom, from),
+			    {Geom::Size::Coord(orientation,
+			        clippedSize,
+			        to - from)}};
+		};
+
+		auto weight = Math::FuzzyBool::And<double>(interval.weight,
+		    interval.isSecond,
+		    guides.interlacings);
+		auto interlacingColor = *axisStyle.interlacing.color * weight;
+
+		for (auto first = otherWeights.begin(),
+		          next = std::next(first),
+		          last = otherWeights.end();
+		     next != last;
+		     ++next, ++first) {
+			if (Math::Floating::is_zero(first->second))
+				drawInterlacing(axisIndex,
+				    interlacingColor,
+				    rect(first->first, next->first));
+			else if (axisIndex == Gen::AxisId::y) {
+				drawInterlacing(first->second > weight ? !axisIndex
+				                                       : axisIndex,
+				    getCrossingInterlacingColor(
+				        *axisStyle.interlacing.color,
+				        weight,
+				        otherInterlacingColor,
+				        first->second),
+				    rect(first->first, next->first));
+			}
 		}
-		canvas.restore();
 	}
 }
 
@@ -119,6 +133,26 @@ void DrawInterlacing::drawTexts(Gen::AxisId axisIndex) const
 	}
 }
 
+void DrawInterlacing::drawInterlacing(Gen::AxisId axisIndex,
+    const Gfx::Color &interlacingColor,
+    const Geom::Rect &rect) const
+{
+	auto &canvas = parent.canvas;
+	canvas.save();
+	canvas.setLineColor(Gfx::Color::Transparent());
+	canvas.setLineWidth(0);
+	canvas.setBrushColor(interlacingColor);
+	if (auto &&eventTarget =
+	        Events::Targets::axisInterlacing(axisIndex);
+	    parent.rootEvents.draw.plot.axis.interlacing->invoke(
+	        Events::OnRectDrawEvent(*eventTarget, {rect, true}))) {
+		parent.painter.drawPolygon(rect.points());
+		parent.renderedChart.emplace(Rect{rect, true},
+		    std::move(eventTarget));
+	}
+	canvas.restore();
+}
+
 void DrawInterlacing::drawDataLabel(
     const ::Anim::Interpolated<bool> &axisEnabled,
     Gen::AxisId axisIndex,
@@ -226,4 +260,61 @@ void DrawInterlacing::drawSticks(double tickLength,
 	canvas.restore();
 }
 
+std::map<double, double> DrawInterlacing::getInterlacingWeights(
+    Gen::AxisId axisIndex) const
+{
+	std::map<double, double> weights{{0.0, 0.0}, {1.0, 0.0}};
+
+	auto &&guides = parent.plot->guides.at(axisIndex);
+	auto &&axisStyle = parent.rootStyle.plot.getAxis(axisIndex);
+	if (axisStyle.interlacing.color->isTransparent()
+	    || guides.interlacings == false)
+		return weights;
+
+	for (auto &&interval : parent.getIntervals(axisIndex)) {
+		if (Math::Floating::is_zero(interval.isSecond)) continue;
+		auto min = std::max(interval.range.getMin(), 0.0);
+		auto max = std::min(interval.range.getMax(), 1.0);
+		auto mprev = std::prev(weights.upper_bound(min));
+		auto mnext = weights.lower_bound(max);
+
+		if (mprev->first < min)
+			mprev = weights.try_emplace(mprev, min, mprev->second);
+		if (mnext->first > max)
+			mnext = weights.try_emplace(mnext,
+			    max,
+			    std::prev(mnext)->second);
+
+		while (mprev != mnext)
+			mprev++->second +=
+			    Math::FuzzyBool::And<double>(interval.weight,
+			        interval.isSecond,
+			        guides.interlacings);
+	}
+	return weights;
+}
+
+Gfx::Color DrawInterlacing::getCrossingInterlacingColor(
+    const Gfx::Color &mainColor,
+    double mainWeight,
+    const Gfx::Color &otherColor,
+    double otherWeight)
+{
+	auto color = mainColor * mainWeight + otherColor * otherWeight;
+
+	color.alpha = 1
+	            - (1 - mainColor.alpha * mainWeight)
+	                  * (1 - otherColor.alpha * otherWeight);
+
+	if (mainWeight + otherWeight > 1.0)
+		color = Math::Niebloid::interpolate(color,
+		    color
+		        * std::max({std::abs(mainColor.red - otherColor.red),
+		            std::abs(mainColor.green - otherColor.green),
+		            std::abs(mainColor.blue - otherColor.blue)}),
+		    mainWeight + otherWeight - 1.0);
+
+	return color;
+}
+
 }

src/chart/rendering/drawinterlacing.h

@@ -16,6 +16,10 @@ class DrawInterlacing
 	const DrawAxes &parent;
 
 private:
+	void drawInterlacing(Gen::AxisId axisIndex,
+	    const Gfx::Color &interlacingColor,
+	    const Geom::Rect &rect) const;
+
 	void drawDataLabel(const ::Anim::Interpolated<bool> &enabled,
 	    Gen::AxisId axisIndex,
 	    const Geom::Point &tickPos,
@@ -27,6 +31,15 @@ class DrawInterlacing
 	    const Gfx::Color &tickColor,
 	    Gen::AxisId axisIndex,
 	    const Geom::Point &tickPos) const;
+
+	[[nodiscard]] std::map<double, double> getInterlacingWeights(
+	    Gen::AxisId axisIndex) const;
+
+	[[nodiscard]] static Gfx::Color getCrossingInterlacingColor(
+	    const Gfx::Color &mainColor,
+	    double mainWeight,
+	    const Gfx::Color &otherColor,
+	    double otherWeight);
 };
 
 }

src/dataframe/impl/aggregators.cpp

@@ -38,14 +38,19 @@ get_aggregators() noexcept
 
 	auto &&aggrs = Refl::enum_names<aggregator_type>;
 	return {{{{aggrs[static_cast<std::size_t>(aggregator_type::sum)],
-	              empty_double,
+	              init_nan,
 	              [](custom_aggregator::id_type &id,
 	                  cell_reference const &cell) -> double
 	              {
 		              auto &ref = *std::get_if<double>(&id);
 		              const double &value =
 		                  *std::get_if<double>(&cell);
-		              if (std::isfinite(value)) ref += value;
+		              if (std::isfinite(value)) {
+			              if (std::isnan(ref))
+				              ref = value;
+			              else
+				              ref += value;
+		              }
 
 		              return ref;
 	              }},

src/dataframe/impl/dataframe.cpp

@@ -347,7 +347,7 @@ void dataframe::add_series_by_other(std::string_view,
     const std::function<cell_value(record_type, cell_reference)> &,
     std::span<const std::pair<const char *, const char *>>) &
 {
-	if (as_if()) error(error_type::unimplemented, "by oth");
+	if (as_if()) error(error_type::unimplemented, "by other");
 }
 
 void dataframe::remove_series(

src/dataframe/interface.h

@@ -58,14 +58,14 @@ struct custom_aggregator
 	id_type (*create)();
 	double (*add)(id_type &, cell_reference const &);
 
-	auto operator<=>(const custom_aggregator &oth) const
+	auto operator<=>(const custom_aggregator &other) const
 	{
-		return name <=> oth.name;
+		return name <=> other.name;
 	}
 
-	auto operator==(const custom_aggregator &oth) const
+	auto operator==(const custom_aggregator &other) const
 	{
-		return name == oth.name;
+		return name == other.name;
 	}
 };
 

src/dataframe/old/datatable.cpp

@@ -55,9 +55,9 @@ void DataTable::pushRow(const std::span<const char *const> &cells)
 
 std::string DataTable::getInfos() const { return df.as_string(); }
 
-bool DataCube::iterator_t::operator!=(const iterator_t &oth) const
+bool DataCube::iterator_t::operator!=(const iterator_t &other) const
 {
-	return parent != oth.parent;
+	return parent != other.parent;
 }
 
 void DataCube::iterator_t::operator++() { parent->incr(*this); }

src/dataframe/old/datatable.h

@@ -125,7 +125,7 @@ class DataCube
 		const DataCube *parent{};
 		MultiIndex index;
 
-		[[nodiscard]] bool operator!=(const iterator_t &oth) const;
+		[[nodiscard]] bool operator!=(const iterator_t &other) const;
 
 		void operator++();