1 /* === S Y N F I G ========================================================= */
2 /*! \file valuenode_bline.cpp
3 ** \brief Template File
8 ** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
10 ** This package is free software; you can redistribute it and/or
11 ** modify it under the terms of the GNU General Public License as
12 ** published by the Free Software Foundation; either version 2 of
13 ** the License, or (at your option) any later version.
15 ** This package is distributed in the hope that it will be useful,
16 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
17 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 ** General Public License for more details.
21 /* ========================================================================= */
23 /* === H E A D E R S ======================================================= */
32 #include "valuenode_bline.h"
33 #include "valuenode_const.h"
34 #include "valuenode_composite.h"
36 #include "exception.h"
37 #include "blinepoint.h"
41 #include <ETL/hermite>
42 #include <ETL/calculus>
47 /* === U S I N G =========================================================== */
51 using namespace synfig;
53 /* === M A C R O S ========================================================= */
55 /* === G L O B A L S ======================================================= */
57 /* === P R O C E D U R E S ================================================= */
60 linear_interpolation(const float& a, const float& b, float c)
64 linear_interpolation(const Vector& a, const Vector& b, float c)
68 radial_interpolation(const Vector& a, const Vector& b, float c)
70 // if either extreme is zero then use linear interpolation instead
71 if (a.is_equal_to(Vector::zero()) || b.is_equal_to(Vector::zero()))
72 return linear_interpolation(a, b, c);
74 affine_combo<Real,float> mag_combo;
75 affine_combo<Angle,float> ang_combo;
77 Real mag(mag_combo(a.mag(),b.mag(),c));
78 Angle ang(ang_combo(Angle::tan(a[1],a[0]),Angle::tan(b[1],b[0]),c));
80 return Point( mag*Angle::cos(ang).get(),mag*Angle::sin(ang).get() );
84 transform(Vector in, Vector& out, Point& coord_origin, Point *coord_sys)
87 out[0] = in * coord_sys[0];
88 out[1] = in * coord_sys[1];
92 untransform(const Vector& in, Vector& out, Point& coord_origin, Point *coord_sys)
94 out[0] = in * coord_sys[0];
95 out[1] = in * coord_sys[1];
100 synfig::convert_bline_to_segment_list(const ValueBase& bline)
102 std::vector<Segment> ret;
104 // std::vector<BLinePoint> list(bline.operator std::vector<BLinePoint>());
105 //std::vector<BLinePoint> list(bline);
106 std::vector<BLinePoint> list(bline.get_list().begin(),bline.get_list().end());
107 std::vector<BLinePoint>::const_iterator iter;
109 BLinePoint prev,first;
111 //start with prev = first and iter on the second...
113 if(list.empty()) return ValueBase(ret,bline.get_loop());
114 first = prev = list.front();
116 for(iter=++list.begin();iter!=list.end();++iter)
139 return ValueBase(ret,bline.get_loop());
143 synfig::convert_bline_to_width_list(const ValueBase& bline)
145 std::vector<Real> ret;
146 // std::vector<BLinePoint> list(bline.operator std::vector<BLinePoint>());
147 //std::vector<BLinePoint> list(bline);
148 std::vector<BLinePoint> list(bline.get_list().begin(),bline.get_list().end());
149 std::vector<BLinePoint>::const_iterator iter;
152 return ValueBase(ValueBase::TYPE_LIST);
154 for(iter=list.begin();iter!=list.end();++iter)
155 ret.push_back(iter->get_width());
158 ret.push_back(list.front().get_width());
160 return ValueBase(ret,bline.get_loop());
164 /* === M E T H O D S ======================================================= */
167 ValueNode_BLine::ValueNode_BLine():
168 ValueNode_DynamicList(ValueBase::TYPE_BLINEPOINT)
172 ValueNode_BLine::~ValueNode_BLine()
177 ValueNode_BLine::create(const ValueBase &value)
179 if(value.get_type()!=ValueBase::TYPE_LIST)
182 ValueNode_BLine* value_node(new ValueNode_BLine());
186 switch(value.get_contained_type())
188 case ValueBase::TYPE_BLINEPOINT:
190 // std::vector<BLinePoint> bline_points(value.operator std::vector<BLinePoint>());
191 //std::vector<BLinePoint> bline_points(value);
192 std::vector<BLinePoint> bline_points(value.get_list().begin(),value.get_list().end());
193 std::vector<BLinePoint>::const_iterator iter;
195 for(iter=bline_points.begin();iter!=bline_points.end();iter++)
197 value_node->add(ValueNode::Handle(ValueNode_Composite::create(*iter)));
199 value_node->set_loop(value.get_loop());
202 case ValueBase::TYPE_SEGMENT:
204 // Here, we want to convert a list of segments
205 // into a list of BLinePoints. We make an assumption
206 // that the segment list is continuous(sp), but not necessarily
209 value_node->set_loop(false);
210 // std::vector<Segment> segments(value.operator std::vector<Segment>());
211 // std::vector<Segment> segments(value);
212 std::vector<Segment> segments(value.get_list().begin(),value.get_list().end());
213 std::vector<Segment>::const_iterator iter,last(segments.end());
215 ValueNode_Const::Handle prev,first;
217 for(iter=segments.begin();iter!=segments.end();iter++)
219 #define PREV_POINT prev->get_value().get(BLinePoint())
220 #define FIRST_POINT first->get_value().get(BLinePoint())
221 #define CURR_POINT curr->get_value().get(BLinePoint())
222 if(iter==segments.begin())
224 prev=ValueNode_Const::create(ValueBase::TYPE_BLINEPOINT);
226 BLinePoint prev_point(PREV_POINT);
227 prev_point.set_vertex(iter->p1);
228 prev_point.set_tangent1(iter->t1);
229 prev_point.set_width(0.01);
230 prev_point.set_origin(0.5);
231 prev_point.set_split_tangent_flag(false);
232 prev->set_value(prev_point);
235 value_node->add(ValueNode::Handle(prev));
238 if(iter==last && iter->p2.is_equal_to(FIRST_POINT.get_vertex()))
240 value_node->set_loop(true);
241 if(!iter->t2.is_equal_to(FIRST_POINT.get_tangent1()))
243 BLinePoint first_point(FIRST_POINT);
244 first_point.set_tangent1(iter->t2);
245 first->set_value(first_point);
250 ValueNode_Const::Handle curr;
251 curr=ValueNode_Const::create(ValueBase::TYPE_BLINEPOINT);
253 BLinePoint curr_point(CURR_POINT);
254 curr_point.set_vertex(iter->p2);
255 curr_point.set_tangent1(iter->t2);
256 curr_point.set_width(0.01);
257 curr_point.set_origin(0.5);
258 curr_point.set_split_tangent_flag(false);
259 curr->set_value(curr_point);
261 if(!PREV_POINT.get_tangent1().is_equal_to(iter->t1))
263 BLinePoint prev_point(PREV_POINT);
264 prev_point.set_split_tangent_flag(true);
265 prev_point.set_tangent2(iter->t1);
266 prev->set_value(prev_point);
268 value_node->add(ValueNode::Handle(curr));
275 // We got a list of who-knows-what. We don't have any idea
276 // what to do with it.
286 ValueNode_BLine::ListEntry
287 ValueNode_BLine::create_list_entry(int index, Time time, Real origin)
289 ValueNode_BLine::ListEntry ret;
292 synfig::BLinePoint prev,next;
296 index=index%link_count();
300 ret.set_parent_value_node(this);
302 if(!list[index].status_at_time(time))
303 next_i=find_next_valid_entry(index,time);
306 prev_i=find_prev_valid_entry(index,time);
308 synfig::info("index=%d, next_i=%d, prev_i=%d",index,next_i,prev_i);
310 next=(*list[next_i].value_node)(time);
311 prev=(*list[prev_i].value_node)(time);
313 etl::hermite<Vector> curve(prev.get_vertex(),next.get_vertex(),prev.get_tangent2(),next.get_tangent1());
314 etl::derivative< etl::hermite<Vector> > deriv(curve);
316 synfig::BLinePoint bline_point;
317 bline_point.set_vertex(curve(origin));
318 bline_point.set_width((next.get_width()-prev.get_width())*origin+prev.get_width());
319 bline_point.set_tangent1(deriv(origin)*min(1.0-origin,origin));
320 bline_point.set_tangent2(bline_point.get_tangent1());
321 bline_point.set_split_tangent_flag(false);
322 bline_point.set_origin(origin);
324 ret.value_node=ValueNode_Composite::create(bline_point);
330 ValueNode_BLine::operator()(Time t)const
332 std::vector<BLinePoint> ret_list;
334 std::vector<ListEntry>::const_iterator iter,first_iter;
335 bool first_flag(true);
338 float next_scale(1.0f);
340 BLinePoint prev,first;
341 first.set_origin(100.0f);
343 for(iter=list.begin();iter!=list.end();++iter,index++)
345 float amount(iter->amount_at_time(t,&rising));
347 assert(amount>=0.0f);
348 assert(amount<=1.0f);
355 first=prev=(*iter->value_node)(t).get(prev);
357 ret_list.push_back(first);
362 curr=(*iter->value_node)(t).get(prev);
366 ret_list.back().set_split_tangent_flag(true);
367 ret_list.back().set_tangent2(prev.get_tangent2()*next_scale);
369 ret_list.push_back(curr);
371 ret_list.back().set_split_tangent_flag(true);
372 ret_list.back().set_tangent2(curr.get_tangent2());
373 ret_list.back().set_tangent1(curr.get_tangent1()*next_scale);
379 ret_list.push_back(curr);
387 std::vector<ListEntry>::const_iterator begin_iter,end_iter;
389 // This is where the interesting stuff happens
390 // We need to seek forward in the list to see what the next
393 BLinePoint blp_here_on; // the current vertex, when fully on
394 BLinePoint blp_here_off; // the current vertex, when fully off
395 BLinePoint blp_here_now; // the current vertex, right now (between on and off)
396 BLinePoint blp_prev_off; // the beginning of dynamic group when fully off
397 BLinePoint blp_next_off; // end of the dynamic group when fully off
399 int dist_from_begin(0), dist_from_end(0);
400 Time off_time, on_time;
404 try{ on_time=iter->find_prev(t)->get_time(); }
405 catch(...) { on_time=Time::begin(); }
406 try{ off_time=iter->find_next(t)->get_time(); }
407 catch(...) { off_time=Time::end(); }
411 try{ off_time=iter->find_prev(t)->get_time(); }
412 catch(...) { off_time=Time::begin(); }
413 try{ on_time=iter->find_next(t)->get_time(); }
414 catch(...) { on_time=Time::end(); }
417 blp_here_on=(*iter->value_node)(on_time).get(blp_here_on);
418 // blp_here_on=(*iter->value_node)(t).get(blp_here_on);
420 // Find "end" of dynamic group
422 // for(++end_iter;begin_iter!=list.end();++end_iter)
423 for(++end_iter;end_iter!=list.end();++end_iter)
424 if(end_iter->amount_at_time(t)>amount)
426 blp_next_off=(*end_iter->value_node)(off_time).get(prev);
430 // If we did not find an end of the dynamic group...
431 if(end_iter==list.end())
436 blp_next_off=(*end_iter->value_node)(off_time).get(prev);
443 blp_next_off=(*end_iter->value_node)(off_time).get(prev);
448 // Find "begin" of dynamic group
450 blp_prev_off.set_origin(100.0f); // set the origin to 100 (which is crazy) so that we can check to see if it was found
453 if(begin_iter==list.begin())
456 begin_iter=list.end();
467 if(begin_iter->amount_at_time(t)>amount)
469 blp_prev_off=(*begin_iter->value_node)(off_time).get(prev);
472 }while(begin_iter!=iter);
474 // If we did not find a begin
475 if(blp_prev_off.get_origin()==100.0f)
479 begin_iter=first_iter;
480 blp_prev_off=(*begin_iter->value_node)(off_time).get(prev);
481 // blp_prev_off=first;
486 begin_iter=first_iter;
487 blp_prev_off=(*begin_iter->value_node)(off_time).get(prev);
488 // blp_prev_off=first;
492 etl::hermite<Vector> curve(blp_prev_off.get_vertex(), blp_next_off.get_vertex(),
493 blp_prev_off.get_tangent2(), blp_next_off.get_tangent1());
494 etl::derivative< etl::hermite<Vector> > deriv(curve);
496 blp_here_off.set_vertex(curve(blp_here_on.get_origin()));
498 blp_here_off.set_width((blp_next_off.get_width()-blp_prev_off.get_width())*blp_here_on.get_origin()+blp_prev_off.get_width());
500 blp_here_off.set_tangent1(deriv(blp_here_on.get_origin()));
501 blp_here_off.set_tangent2(deriv(blp_here_on.get_origin()));
503 float prev_tangent_scalar(1.0f);
504 float next_tangent_scalar(1.0f);
506 //synfig::info("index_%d:dist_from_begin=%d",index,dist_from_begin);
507 //synfig::info("index_%d:dist_from_end=%d",index,dist_from_end);
509 // If we are the next to the begin
510 if(begin_iter==--std::vector<ListEntry>::const_iterator(iter) || dist_from_begin==1)
511 prev_tangent_scalar=linear_interpolation(blp_here_on.get_origin(), 1.0f, amount);
513 prev_tangent_scalar=linear_interpolation(blp_here_on.get_origin()-prev.get_origin(), 1.0f, amount);
515 // If we are the next to the end
516 if(end_iter==++std::vector<ListEntry>::const_iterator(iter) || dist_from_end==1)
517 next_tangent_scalar=linear_interpolation(1.0-blp_here_on.get_origin(), 1.0f, amount);
518 else if(list.end()!=++std::vector<ListEntry>::const_iterator(iter))
521 next=((*(++std::vector<ListEntry>::const_iterator(iter))->value_node)(t).get(prev));
522 next_tangent_scalar=linear_interpolation(next.get_origin()-blp_here_on.get_origin(), 1.0f, amount);
525 //! \todo this isn't quite right; we should handle looped blines identically no matter where the loop happens
526 //! and we currently don't. this at least makes it a lot better than it was before
527 next_tangent_scalar=linear_interpolation(blp_next_off.get_origin()-blp_here_on.get_origin(), 1.0f, amount);
528 next_scale=next_tangent_scalar;
530 //blp_here_now.set_vertex(linear_interpolation(blp_here_off.get_vertex(), blp_here_on.get_vertex(), amount));
534 // Point ref_point_begin(((*begin_iter->value_node)(off_time).get(prev).get_vertex() +
535 // (*end_iter->value_node)(off_time).get(prev).get_vertex()) * 0.5);
536 // Point ref_point_end(((*begin_iter->value_node)(on_time).get(prev).get_vertex() +
537 // (*end_iter->value_node)(on_time).get(prev).get_vertex()) * 0.5);
538 // Point ref_point_now(((*begin_iter->value_node)(t).get(prev).get_vertex() +
539 // (*end_iter->value_node)(t).get(prev).get_vertex()) * 0.5);
540 // Point ref_point_linear(linear_interpolation(ref_point_begin, ref_point_end, amount));
542 // blp_here_now.set_vertex(linear_interpolation(blp_here_off.get_vertex(), blp_here_on.get_vertex(), amount) +
543 // (ref_point_now-ref_point_linear));
544 // blp_here_now.set_tangent1(linear_interpolation(blp_here_off.get_tangent1(), blp_here_on.get_tangent1(), amount));
545 // blp_here_now.set_split_tangent_flag(blp_here_on.get_split_tangent_flag());
546 // if(blp_here_now.get_split_tangent_flag())
547 // blp_here_now.set_tangent2(linear_interpolation(blp_here_off.get_tangent2(), blp_here_on.get_tangent2(), amount));
553 // define 3 coordinate systems:
554 Point off_coord_sys[2], off_coord_origin; // when the current vertex is completely off
555 Point on_coord_sys[2] , on_coord_origin; // when the current vertex is completely on
556 Point curr_coord_sys[2], curr_coord_origin; // the current state - somewhere in between
558 // for each of the 3 systems, the origin is half way between the previous and next active point
559 // and the axes are based on a vector from the next active point to the previous
561 const Point end_pos_at_off_time(( *end_iter->value_node)(off_time).get(prev).get_vertex());
562 const Point begin_pos_at_off_time((*begin_iter->value_node)(off_time).get(prev).get_vertex());
563 off_coord_origin=(begin_pos_at_off_time + end_pos_at_off_time)/2;
564 off_coord_sys[0]=(begin_pos_at_off_time - end_pos_at_off_time).norm();
565 off_coord_sys[1]=off_coord_sys[0].perp();
567 const Point end_pos_at_on_time(( *end_iter->value_node)(on_time).get(prev).get_vertex());
568 const Point begin_pos_at_on_time((*begin_iter->value_node)(on_time).get(prev).get_vertex());
569 on_coord_origin=(begin_pos_at_on_time + end_pos_at_on_time)/2;
570 on_coord_sys[0]=(begin_pos_at_on_time - end_pos_at_on_time).norm();
571 on_coord_sys[1]=on_coord_sys[0].perp();
573 const Point end_pos_at_current_time(( *end_iter->value_node)(t).get(prev).get_vertex());
574 const Point begin_pos_at_current_time((*begin_iter->value_node)(t).get(prev).get_vertex());
575 curr_coord_origin=(begin_pos_at_current_time + end_pos_at_current_time)/2;
576 curr_coord_sys[0]=(begin_pos_at_current_time - end_pos_at_current_time).norm();
577 curr_coord_sys[1]=curr_coord_sys[0].perp();
580 /* The code that was here before used just end_iter as the origin, rather than the mid-point */
582 // For each of the 3 coordinate systems we've just defined, we convert a point and tangent(s) into that system
583 Point trans_on_point, trans_off_point, untrans_curr_point;
584 Vector trans_on_t1, trans_on_t2, trans_off_t1, trans_off_t2, untrans_curr_t1, untrans_curr_t2;
586 // Convert points where vertex is fully on and fully off
587 transform(blp_here_on.get_vertex(), trans_on_point, on_coord_origin, on_coord_sys);
588 transform(blp_here_off.get_vertex(), trans_off_point, off_coord_origin, off_coord_sys);
590 #define COORD_SYS_RADIAL_TAN_INTERP 1
592 #ifdef COORD_SYS_RADIAL_TAN_INTERP
593 // this I don't understand. why add on this bit ---v
594 transform(blp_here_on.get_tangent1() + blp_here_on.get_vertex(), trans_on_t1, on_coord_origin, on_coord_sys);
595 transform(blp_here_off.get_tangent1() + blp_here_off.get_vertex(), trans_off_t1, off_coord_origin, off_coord_sys);
597 if(blp_here_on.get_split_tangent_flag())
599 transform(blp_here_on.get_tangent2()+blp_here_on.get_vertex(), trans_on_t2, on_coord_origin, on_coord_sys);
600 transform(blp_here_off.get_tangent2()+blp_here_off.get_vertex(), trans_off_t2, off_coord_origin, off_coord_sys);
603 // Convert current point
604 // Transpose (invert)
605 swap(curr_coord_sys[0][1],curr_coord_sys[1][0]);
607 // interpolate between the 'on' point and the 'off' point and untransform to get our point's location
608 untransform(linear_interpolation(trans_off_point, trans_on_point, amount),
609 untrans_curr_point, curr_coord_origin, curr_coord_sys);
611 #define INTERP_FUNCTION radial_interpolation
612 //#define INTERP_FUNCTION linear_interpolation
614 #ifdef COORD_SYS_RADIAL_TAN_INTERP
615 untransform(INTERP_FUNCTION(trans_off_t1,trans_on_t1,amount),
616 untrans_curr_t1, curr_coord_origin, curr_coord_sys);
617 untrans_curr_t1 -= untrans_curr_point;
619 if(blp_here_on.get_split_tangent_flag())
621 untransform(INTERP_FUNCTION(trans_off_t2,trans_on_t2,amount),
622 untrans_curr_t2, curr_coord_origin, curr_coord_sys);
623 untrans_curr_t2 -= untrans_curr_point;
627 blp_here_now.set_vertex(untrans_curr_point);
628 #ifndef COORD_SYS_RADIAL_TAN_INTERP
629 blp_here_now.set_tangent1(radial_interpolation(blp_here_off.get_tangent1(),blp_here_on.get_tangent1(),amount));
630 blp_here_now.set_split_tangent_flag(blp_here_on.get_split_tangent_flag());
631 if(blp_here_now.get_split_tangent_flag())
632 blp_here_now.set_tangent2(radial_interpolation(blp_here_off.get_tangent2(),blp_here_on.get_tangent2(),amount));
634 blp_here_now.set_tangent1(untrans_curr_t1);
635 blp_here_now.set_split_tangent_flag(blp_here_on.get_split_tangent_flag());
636 if(blp_here_now.get_split_tangent_flag())
637 blp_here_now.set_tangent2(untrans_curr_t2);
641 blp_here_now.set_origin(blp_here_on.get_origin());
642 blp_here_now.set_width(linear_interpolation(blp_here_off.get_width(), blp_here_on.get_width(), amount));
645 // Handle the case where we are the first vertex
648 blp_here_now.set_tangent1(blp_here_now.get_tangent1()*prev_tangent_scalar);
650 first=prev=blp_here_now;
652 ret_list.push_back(blp_here_now);
656 ret_list.back().set_split_tangent_flag(true);
657 ret_list.back().set_tangent2(prev.get_tangent2()*prev_tangent_scalar);
658 ret_list.push_back(blp_here_now);
659 ret_list.back().set_split_tangent_flag(true);
660 //ret_list.back().set_tangent2(blp_here_now.get_tangent1());
661 ret_list.back().set_tangent1(blp_here_now.get_tangent1()*prev_tangent_scalar);
669 ret_list.back().set_split_tangent_flag(true);
670 ret_list.back().set_tangent2(prev.get_tangent2()*next_scale);
674 if(get_loop() && !first_flag)
688 synfig::warning(string("ValueNode_BLine::operator()():")+_("No entries in list"));
691 synfig::warning(string("ValueNode_BLine::operator()():")+_("No entries in ret_list"));
693 return ValueBase(ret_list,get_loop());
697 ValueNode_BLine::link_local_name(int i)const
699 assert(i>=0 && (unsigned)i<list.size());
700 return etl::strprintf(_("Vertex %03d"),i+1);
704 ValueNode_BLine::clone(const GUID& deriv_guid)const
706 { ValueNode* x(find_value_node(get_guid()^deriv_guid).get()); if(x)return x; }
708 ValueNode_BLine* ret=new ValueNode_BLine();
709 ret->set_guid(get_guid()^deriv_guid);
711 std::vector<ListEntry>::const_iterator iter;
713 for(iter=list.begin();iter!=list.end();++iter)
715 if(iter->value_node->is_exported())
719 ListEntry list_entry(*iter);
720 //list_entry.value_node=find_value_node(iter->value_node->get_guid()^deriv_guid).get();
721 //if(!list_entry.value_node)
722 list_entry.value_node=iter->value_node->clone(deriv_guid);
723 ret->add(list_entry);
724 //ret->list.back().value_node=iter->value_node.clone();
727 ret->set_loop(get_loop());
733 ValueNode_BLine::get_name()const
739 ValueNode_BLine::get_local_name()const
745 ValueNode_BLine::create_new()const
752 ValueNode_BLine::check_type(ValueBase::Type type)
754 return type==ValueBase::TYPE_LIST;