fix(advanced outline): fix rendering of width point in non-homogeneous position (synfig#3555)

fix(advanced outline): fix rendering of width point in non-homogeneous position

Author: ice0

synfig-core/src/modules/mod_geometry/advanced_outline.cpp

@@ -94,7 +94,7 @@ namespace {
 	Real calc_position(Real p, const rendering::Bend &bend, bool homogeneous) {
 		return homogeneous
 			 ? p*bend.length1()
-			 : bend.length_by_l( p*bend.l1() );
+			 : bend.length_by_index( p*bend.l1() );
 	}
 
 	class AdvancedPoint {

synfig-core/src/synfig/rendering/primitive/bend.cpp

@@ -173,6 +173,7 @@ Bend::add(const Vector &p, const Vector &t0, const Vector &t1, Mode mode, bool c
 		  && t0.is_equal_to(Vector()) )
 		{
 			// skip zero length segment
+			last.last_index += 1;
 			last.t1 = t1;
 			last.tn1 = t1.norm();
 			last.mode = mode;
@@ -185,18 +186,21 @@ Bend::add(const Vector &p, const Vector &t0, const Vector &t1, Mode mode, bool c
 
 		point.p = last.p;
 		point.length = last.length;
-		Real l0 = last.l, l = step;
+		const Real l0 = last.last_index;
+		Real l = step;
 		for(int i = 1; i < segments; ++i, l += step) {
 			Vector pp = h.p(l);
-			point.l = l0 + l;
-			point.length = calc_length ? point.length + (pp - point.p).mag() : point.l;
+			point.index = l0 + l;
+			point.last_index = l0 + l;
+			point.length = calc_length ? point.length + (pp - point.p).mag() : point.index;
 			point.p = pp;
 			point.t0 = point.t1 = h.t(l);
 			point.tn0 = point.tn1 = h.d(l);
 			points.push_back(point);
 		}
-		point.l = l0 + 1;
-		point.length = calc_length ? point.length + (p - point.p).mag() : point.l;
+		point.index = l0 + 1;
+		point.last_index = l0 + 1;
+		point.length = calc_length ? point.length + (p - point.p).mag() : point.index;
 		point.tn0 = h.d(1);
 	} else {
 		point.tn0 = t0.norm();
@@ -235,15 +239,15 @@ Bend::tails()
 
 	{
 		PointList::iterator i1 = points.begin(), i0 = i1++;
-		Real dl = i1->l - i0->l;
+		Real dl = i1->index - i0->last_index;
 		Hermite h(i0->p, i1->p, i0->t1*dl, i1->t0*dl);
 		i0->t0 = i0->tn0 = h.d(0);
 		i0->mode = NONE;
 	}
 
 	{
 		PointList::iterator i0 = points.end(), i1 = (--i0)--;
-		Real dl = i1->l - i0->l;
+		Real dl = i1->index - i0->last_index;
 		Hermite h(i0->p, i1->p, i0->t1*dl, i1->t0*dl);
 		i1->t1 = i1->tn1 = h.d(1);
 		i1->mode = NONE;
@@ -252,16 +256,21 @@ Bend::tails()
 
 
 Bend::PointList::const_iterator
-Bend::find_by_l(Real l) const
+Bend::find_by_index(Real index) const
 {
 	if (points.empty())
 		return points.end();
 	PointList::const_iterator a = points.begin(), b = points.end() - 1, c;
-	if (!approximate_less(a->l, l)) return a;
-	if (!approximate_less(l, b->l)) return b;
+
+	if (approximate_greater_or_equal(a->last_index, index))
+		return a;
+	if (approximate_greater_or_equal(index, b->index))
+		return b;
+
 	while( (c = a + (b - a)/2) != a ) {
-		if (approximate_equal(l, c->l)) return c;
-		(l < c->l ? b : a) = c;
+		if (approximate_greater_or_equal(index, c->index) && approximate_less_or_equal(index, c->last_index))
+			return c;
+		(index < c->index ? b : a) = c;
 	}
 	return c;
 }
@@ -272,30 +281,35 @@ Bend::find(Real length) const
 	if (points.empty())
 		return points.end();
 	PointList::const_iterator a = points.begin(), b = points.end() - 1, c;
-	if (!approximate_less(a->length, length)) return a;
-	if (!approximate_less(length, b->length)) return b;
+
+	if (approximate_greater_or_equal(a->length, length))
+		return a;
+	if (approximate_greater_or_equal(length, b->length))
+		return b;
+
 	while( (c = a + (b - a)/2) != a ) {
 		if (approximate_equal(length, c->length)) return c;
 		(length < c->length ? b : a) = c;
 	}
 	return c;
 }
 
-Real Bend::length_by_l(Real l) const {
-	PointList::const_iterator i = find_by_l(l);
+Real Bend::length_by_index(Real index) const {
+	PointList::const_iterator i = find_by_index(index);
 	if (i == points.end())
 		return 0;
 
-	if (approximate_equal(l, i->l)) return i->length;
-	if (l < i->l)
-		return i->length + (l - i->l);
+	if (approximate_greater_or_equal(index, i->index) && approximate_less_or_equal(index, i->last_index))
+		return i->length;
+	if (index < i->index)
+		return i->length + (index - i->index); // TODO: review: shouldn't interpolate?
 
 	PointList::const_iterator j = i + 1;
 	if (j == points.end())
-		return i->length + (l - i->l);
+		return i->length + (index - i->last_index); // TODO: review: shouldn't interpolate?
 
-	Real dl = j->l - i->l;
-	return approximate_zero(dl) ? i->length : i->length + (j->length - i->length)*(l - i->l)/dl;
+	Real dl = j->index - i->last_index;
+	return approximate_zero(dl) ? i->length : i->length + (j->length - i->length)*(index - i->last_index)/dl;
 }
 
 Bend::Point
@@ -312,7 +326,8 @@ Bend::interpolate(Real length) const
 		Point s;
 		s.p = i->p + i->tn0*dlen;
 		s.t0 = s.t1 = s.tn0 = s.tn1 = i->tn0;
-		s.l = i->l + dlen;
+		s.index = i->last_index + dlen;
+		s.last_index = s.index;
 		s.length = length;
 		s.e0 = s.e1 = i->e0;
 		return s;
@@ -325,7 +340,8 @@ Bend::interpolate(Real length) const
 		Point s;
 		s.p = i->p + i->tn1*dlen;
 		s.t0 = s.t1 = s.tn0 = s.tn1 = i->t1;
-		s.l = i->l + dlen;
+		s.index = i->last_index + dlen;
+		s.last_index = s.index;
 		s.length = length;
 		s.e0 = s.e1 = i->e1;
 		return s;
@@ -334,14 +350,15 @@ Bend::interpolate(Real length) const
 	// interpolation
 	Real l = j->length - i->length;
 	l = approximate_zero(l) ? 0 : (length - i->length)/l;
-	Real dl = j->l - i->l;
+	Real dl = j->index - i->last_index;
 	Hermite h(i->p, j->p, i->t1*dl, j->t0*dl);
 
 	Point s;
 	s.p = h.p(l);
 	s.t0 = s.t1 = h.t(l);
 	s.tn0 = s.tn1 = h.d(l);
-	s.l = i->l + l*(j->l - i->l);
+	s.index = i->last_index + l*(j->index - i->last_index);
+	s.last_index = s.index;
 	s.length = length;
 	s.e0 = s.e1 = (i->e1 && j->e0);
 
@@ -456,7 +473,7 @@ Bend::bend(Contour &dst, const Contour &src, const Matrix &matrix, int segments)
 			const Intersection &next = *bi;
 			if (approximate_equal(prev.l, next.l)) continue;
 
-			bool flip = next.point.l < prev.point.l;
+			bool flip = next.point.index < prev.point.last_index;
 			bool e0 = flip ? prev.point.e0 : prev.point.e1;
 			bool e1 = flip ? next.point.e1 : next.point.e0;
 			if (e0 && e1) {
@@ -469,7 +486,7 @@ Bend::bend(Contour &dst, const Contour &src, const Matrix &matrix, int segments)
 				Vector dst_p0 = prev.point.p + tn0.perp()*src_p0y;
 				Vector dst_p1 = next.point.p + tn1.perp()*src_p1y;
 
-				bool vertical = approximate_equal(next.point.l, prev.point.l);
+				bool vertical = approximate_greater_or_equal(next.point.index, prev.point.index) && approximate_less_or_equal(next.point.index, prev.point.last_index);
 
 				half_corner(dst, dst_move_flag, prev.point, src_p0y, flip || vertical, true);
 				touch(dst, dst_move_flag, dst_p0);

synfig-core/src/synfig/rendering/primitive/bend.h

@@ -72,9 +72,10 @@ class Bend: public etl::shared_object
 		Vector tn0, tn1;
 		Mode mode;
 		bool e0, e1;
-		Real l;
+		Real index; /**< The point index in the B-line */
+		Real last_index; /**< It is different (greater) of index only if zero-length segments follow this point */
 		Real length;
-		Point(): mode(NONE), e0(), e1(), l(), length() { }
+		Point(): mode(NONE), e0(), e1(), index(), last_index(), length() { }
 	};
 
 	typedef std::vector<Point> PointList;
@@ -86,18 +87,18 @@ class Bend: public etl::shared_object
 	void tails();
 
 	Real l0() const
-		{ return points.empty() ? Real() : points.front().l; }
+		{ return points.empty() ? Real() : points.front().index; }
 	Real l1() const
-		{ return points.empty() ? Real() : points.back().l; }
+		{ return points.empty() ? Real() : points.back().last_index; }
 
 	Real length0() const
 		{ return points.empty() ? Real() : points.front().length; }
 	Real length1() const
 		{ return points.empty() ? Real() : points.back().length; }
 
-	PointList::const_iterator find_by_l(Real l) const;
+	PointList::const_iterator find_by_index(Real index) const;
 	PointList::const_iterator find(Real length) const;
-	Real length_by_l(Real length) const;
+	Real length_by_index(Real index) const;
 	Point interpolate(Real length) const;
 
 	void bend(Contour &dst, const Contour &src, const Matrix &matrix, int segments) const;

synfig-core/src/synfig/valuenodes/valuenode_bline.cpp

@@ -228,9 +228,8 @@ synfig::find_closest_point(const ValueBase &bline, const Point &pos, Real radius
 Real
 synfig::std_to_hom(const ValueBase &bline, Real pos, bool index_loop, bool bline_loop)
 {
-	Real loops = index_loop ? floor(pos) : 0.0;
+	const Real loops = index_loop ? floor(pos) : 0.0;
 	pos -= loops;
-	assert(approximate_greater_or_equal(pos, 0.0));
 
 	// trivial cases
 	if (approximate_less_or_equal(pos, Real(0)))
@@ -239,31 +238,31 @@ synfig::std_to_hom(const ValueBase &bline, Real pos, bool index_loop, bool bline
 		return loops + 1;
 
 	const std::vector<BLinePoint> list(bline.get_list_of(BLinePoint()));
-	size_t size = list.size();
+	const size_t size = list.size();
 	if (size == 0)
 		return loops;
-	size_t count = bline_loop? size : size - 1;
+	const size_t count = bline_loop? size : size - 1;
 	if (count < 1)
 		return loops + pos;
 
 	// Calculate the lengths and the total length
 	std::vector<Real> lengths;
-	Real bline_total_length = bline_length(list, bline_loop, &lengths);
+	const Real bline_total_length = bline_length(list, bline_loop, &lengths);
 	// If the total length of the bline is zero return pos
-	if(approximate_equal(bline_total_length, 0.0))
+	if (approximate_equal(bline_total_length, 0.0))
 		return pos;
-	size_t from_vertex = size_t(pos*count);
+	const size_t from_vertex = size_t(pos*count);
 	// Calculate the partial length until the bezier that holds the current
 	Real partial_length = 0;
 	std::vector<Real>::const_iterator length_iter(lengths.begin());
-	for(size_t i=0; i < from_vertex; ++i, ++length_iter)
+	for (size_t i = 0; i < from_vertex; ++i, ++length_iter)
 		partial_length += *length_iter;
 	// Calculate the remaining length of the position over current bezier
 	// Setup the curve of the current bezier.
-	size_t next_vertex = (from_vertex + 1) % size;
-	const BLinePoint &blinepoint0 = list[from_vertex];
-	const BLinePoint &blinepoint1 = list[next_vertex];
-	hermite<Vector> curve(blinepoint0.get_vertex(),   blinepoint1.get_vertex(),
+	const size_t next_vertex = (from_vertex + 1) % size;
+	const BLinePoint& blinepoint0 = list[from_vertex];
+	const BLinePoint& blinepoint1 = list[next_vertex];
+	const hermite<Vector> curve(blinepoint0.get_vertex(), blinepoint1.get_vertex(),
 							blinepoint0.get_tangent2(), blinepoint1.get_tangent1());
 	// add the distance on the bezier we are on.
 	partial_length += curve.find_distance(0.0, pos*count - from_vertex);
@@ -274,7 +273,7 @@ synfig::std_to_hom(const ValueBase &bline, Real pos, bool index_loop, bool bline
 Real
 synfig::hom_to_std(const ValueBase &bline, Real pos, bool index_loop, bool bline_loop)
 {
-	Real loops = index_loop ? floor(pos) : 0.0;
+	const Real loops = index_loop ? floor(pos) : 0.0;
 	pos -= loops;
 	assert(approximate_greater_or_equal(pos, 0.0));
 
@@ -285,59 +284,58 @@ synfig::hom_to_std(const ValueBase &bline, Real pos, bool index_loop, bool bline
 		return loops + 1;
 
 	const std::vector<BLinePoint> list(bline.get_list_of(BLinePoint()));
-	size_t size = list.size();
+	const size_t size = list.size();
 	if (size == 0)
 		return loops;
-	size_t count = bline_loop? size : size - 1;
+	const size_t count = bline_loop? size : size - 1;
 	if (count < 1)
 		return loops + pos;
 
 	// Calculate the lengths and the total length
 	std::vector<Real> lengths;
-	Real bline_total_length=bline_length(bline, bline_loop,&lengths);
+	const Real bline_total_length = bline_length(bline, bline_loop, &lengths);
 	// Calculate the my partial length (the length where pos is)
-	Real target_length = pos * bline_total_length;
+	const Real target_length = pos * bline_total_length;
 	std::vector<Real>::const_iterator length_iter(lengths.begin());
 	// Find the previous bezier where we pos is placed and the sum
 	// of lengths to it (cumulative_length)
 	// also remember the bezier's length where we stop
 	Real cumulative_length = 0;
 	size_t from_vertex = 0;
 	Real segment_length = 0;
-	while(target_length > cumulative_length && length_iter != lengths.end())
-	{
+	while (approximate_greater(target_length, cumulative_length) && length_iter != lengths.end()) {
 		segment_length = *length_iter;
 		cumulative_length += segment_length;
 
 		++length_iter;
 		++from_vertex;
 	}
-	// correct the iters and partial length in case we passed over
-	if(cumulative_length > target_length)
-	{
+	if (approximate_equal(target_length, cumulative_length)) {
+		return loops + Real(from_vertex) / count;
+	} else {
+		// correct the iters and partial length in case we passed over
 		--length_iter;
 		cumulative_length -= *length_iter;
 		--from_vertex;
 	}
 	// set up the curve
-	const BLinePoint &blinepoint0 = list[from_vertex];
-	const BLinePoint &blinepoint1 = list[(from_vertex+1) % size];
-	hermite<Vector> curve(blinepoint0.get_vertex(),   blinepoint1.get_vertex(),
+	const BLinePoint& blinepoint0 = list[from_vertex];
+	const BLinePoint& blinepoint1 = list[(from_vertex+1) % size];
+	const hermite<Vector> curve(blinepoint0.get_vertex(),   blinepoint1.get_vertex(),
 	                           blinepoint0.get_tangent2(), blinepoint1.get_tangent1());
 	// Find the solution to which is the standard position which matches the current
 	// homogeneous position
 	// Secant method: http://en.wikipedia.org/wiki/Secant_method
 	Real sn(0.0); // the standard position on current bezier
 	Real sn1(0.0), sn2(1.0);
-	Real t0((target_length-cumulative_length)/segment_length); // the homogeneous position on the current bezier
+	const Real t0((target_length-cumulative_length)/segment_length); // the homogeneous position on the current bezier
 	int iterations=0;
 	const int max_iterations=100;
 	const Real max_error(0.00001);
 	Real error;
 	Real fsn1(t0-curve.find_distance(0.0,sn1)/segment_length);
 	Real fsn2(t0-curve.find_distance(0.0,sn2)/segment_length);
-	do
-	{
+	do {
 		sn=sn1-fsn1*((sn1-sn2)/(fsn1-fsn2));
 		Real fsn=t0-curve.find_distance(0.0, sn)/segment_length;
 		sn2=sn1;
@@ -360,22 +358,22 @@ synfig::bline_length(const ValueBase &bline, bool bline_loop, std::vector<Real>
 	const std::vector<BLinePoint> list(bline.get_list_of(BLinePoint()));
 	if (list.empty())
 		return 0;
-	size_t max_vertex_index(list.size());
-	if(!bline_loop) max_vertex_index--;
-	if(max_vertex_index < 1) return Real();
+	const size_t max_vertex_index = bline_loop ? list.size() : list.size() - 1;
+	if (max_vertex_index < 1)
+		return Real();
 
 	if (lengths)
 		lengths->reserve(max_vertex_index);
 
 	// Calculate the lengths and the total length
 	Real total_length = 0;
-	for(size_t i0 = 0; i0 < max_vertex_index; ++i0) {
-		size_t i1 = (i0 + 1)%list.size();
-		const BLinePoint &blinepoint0 = list[i0];
-		const BLinePoint &blinepoint1 = list[i1];
-		hermite<Vector> curve(blinepoint0.get_vertex(),   blinepoint1.get_vertex(),
+	for (size_t i0 = 0; i0 < max_vertex_index; ++i0) {
+		const size_t i1 = (i0 + 1) % list.size();
+		const BLinePoint& blinepoint0 = list[i0];
+		const BLinePoint& blinepoint1 = list[i1];
+		const hermite<Vector> curve(blinepoint0.get_vertex(), blinepoint1.get_vertex(),
 							blinepoint0.get_tangent2(), blinepoint1.get_tangent1());
-		Real l=curve.length();
+		const Real l = curve.length();
 		if(lengths) lengths->push_back(l);
 		total_length+=l;
 	}