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 Vector& a, const Vector& b, float c)
64 radial_interpolation(const Vector& a, const Vector& b, float c)
66 // if either extreme is zero then use linear interpolation instead
67 if (a.is_equal_to(Vector::zero()) || b.is_equal_to(Vector::zero()))
68 return linear_interpolation(a, b, c);
70 affine_combo<Real,float> mag_combo;
71 affine_combo<Angle,float> ang_combo;
73 Real mag(mag_combo(a.mag(),b.mag(),c));
74 Angle ang(ang_combo(Angle::tan(a[1],a[0]),Angle::tan(b[1],b[0]),c));
76 return Point( mag*Angle::cos(ang).get(),mag*Angle::sin(ang).get() );
82 synfig::convert_bline_to_segment_list(const ValueBase& bline)
84 std::vector<Segment> ret;
86 // std::vector<BLinePoint> list(bline.operator std::vector<BLinePoint>());
87 //std::vector<BLinePoint> list(bline);
88 std::vector<BLinePoint> list(bline.get_list().begin(),bline.get_list().end());
89 std::vector<BLinePoint>::const_iterator iter;
91 BLinePoint prev,first;
93 //start with prev = first and iter on the second...
95 if(list.empty()) return ValueBase(ret,bline.get_loop());
96 first = prev = list.front();
98 for(iter=++list.begin();iter!=list.end();++iter)
121 return ValueBase(ret,bline.get_loop());
125 synfig::convert_bline_to_width_list(const ValueBase& bline)
127 std::vector<Real> ret;
128 // std::vector<BLinePoint> list(bline.operator std::vector<BLinePoint>());
129 //std::vector<BLinePoint> list(bline);
130 std::vector<BLinePoint> list(bline.get_list().begin(),bline.get_list().end());
131 std::vector<BLinePoint>::const_iterator iter;
134 return ValueBase(ValueBase::TYPE_LIST);
136 for(iter=list.begin();iter!=list.end();++iter)
137 ret.push_back(iter->get_width());
140 ret.push_back(list.front().get_width());
142 return ValueBase(ret,bline.get_loop());
146 /* === M E T H O D S ======================================================= */
149 ValueNode_BLine::ValueNode_BLine():
150 ValueNode_DynamicList(ValueBase::TYPE_BLINEPOINT)
154 ValueNode_BLine::~ValueNode_BLine()
159 ValueNode_BLine::create(const ValueBase &value)
161 if(value.get_type()!=ValueBase::TYPE_LIST)
164 ValueNode_BLine* value_node(new ValueNode_BLine());
168 switch(value.get_contained_type())
170 case ValueBase::TYPE_BLINEPOINT:
172 // std::vector<BLinePoint> bline_points(value.operator std::vector<BLinePoint>());
173 //std::vector<BLinePoint> bline_points(value);
174 std::vector<BLinePoint> bline_points(value.get_list().begin(),value.get_list().end());
175 std::vector<BLinePoint>::const_iterator iter;
177 for(iter=bline_points.begin();iter!=bline_points.end();iter++)
179 value_node->add(ValueNode::Handle(ValueNode_Composite::create(*iter)));
181 value_node->set_loop(value.get_loop());
184 case ValueBase::TYPE_SEGMENT:
186 // Here, we want to convert a list of segments
187 // into a list of BLinePoints. We make an assumption
188 // that the segment list is continuous(sp), but not necessarily
191 value_node->set_loop(false);
192 // std::vector<Segment> segments(value.operator std::vector<Segment>());
193 // std::vector<Segment> segments(value);
194 std::vector<Segment> segments(value.get_list().begin(),value.get_list().end());
195 std::vector<Segment>::const_iterator iter,last(segments.end());
197 ValueNode_Const::Handle prev,first;
199 for(iter=segments.begin();iter!=segments.end();iter++)
201 #define PREV_POINT prev->get_value().get(BLinePoint())
202 #define FIRST_POINT first->get_value().get(BLinePoint())
203 #define CURR_POINT curr->get_value().get(BLinePoint())
204 if(iter==segments.begin())
206 prev=ValueNode_Const::create(ValueBase::TYPE_BLINEPOINT);
208 BLinePoint prev_point(PREV_POINT);
209 prev_point.set_vertex(iter->p1);
210 prev_point.set_tangent1(iter->t1);
211 prev_point.set_width(0.01);
212 prev_point.set_origin(0.5);
213 prev_point.set_split_tangent_flag(false);
214 prev->set_value(prev_point);
217 value_node->add(ValueNode::Handle(prev));
220 if(iter==last && iter->p2.is_equal_to(FIRST_POINT.get_vertex()))
222 value_node->set_loop(true);
223 if(!iter->t2.is_equal_to(FIRST_POINT.get_tangent1()))
225 BLinePoint first_point(FIRST_POINT);
226 first_point.set_tangent1(iter->t2);
227 first->set_value(first_point);
232 ValueNode_Const::Handle curr;
233 curr=ValueNode_Const::create(ValueBase::TYPE_BLINEPOINT);
235 BLinePoint curr_point(CURR_POINT);
236 curr_point.set_vertex(iter->p2);
237 curr_point.set_tangent1(iter->t2);
238 curr_point.set_width(0.01);
239 curr_point.set_origin(0.5);
240 curr_point.set_split_tangent_flag(false);
241 curr->set_value(curr_point);
243 if(!PREV_POINT.get_tangent1().is_equal_to(iter->t1))
245 BLinePoint prev_point(PREV_POINT);
246 prev_point.set_split_tangent_flag(true);
247 prev_point.set_tangent2(iter->t1);
248 prev->set_value(prev_point);
250 value_node->add(ValueNode::Handle(curr));
257 // We got a list of who-knows-what. We don't have any idea
258 // what to do with it.
268 ValueNode_BLine::ListEntry
269 ValueNode_BLine::create_list_entry(int index, Time time, Real origin)
271 ValueNode_BLine::ListEntry ret;
274 synfig::BLinePoint prev,next;
278 index=index%link_count();
282 ret.set_parent_value_node(this);
284 if(!list[index].status_at_time(time))
285 next_i=find_next_valid_entry(index,time);
288 prev_i=find_prev_valid_entry(index,time);
290 synfig::info("index=%d, next_i=%d, prev_i=%d",index,next_i,prev_i);
292 next=(*list[next_i].value_node)(time);
293 prev=(*list[prev_i].value_node)(time);
295 etl::hermite<Vector> curve(prev.get_vertex(),next.get_vertex(),prev.get_tangent2(),next.get_tangent1());
296 etl::derivative< etl::hermite<Vector> > deriv(curve);
298 synfig::BLinePoint bline_point;
299 bline_point.set_vertex(curve(origin));
300 bline_point.set_width((next.get_width()-prev.get_width())*origin+prev.get_width());
301 bline_point.set_tangent1(deriv(origin)*min(1.0-origin,origin));
302 bline_point.set_tangent2(bline_point.get_tangent1());
303 bline_point.set_split_tangent_flag(false);
304 bline_point.set_origin(origin);
306 ret.value_node=ValueNode_Composite::create(bline_point);
312 ValueNode_BLine::operator()(Time t)const
314 std::vector<BLinePoint> ret_list;
316 std::vector<ListEntry>::const_iterator iter,first_iter;
317 bool first_flag(true);
320 float next_scale(1.0f);
322 BLinePoint prev,first;
323 first.set_origin(100.0f);
325 for(iter=list.begin();iter!=list.end();++iter,index++)
327 float amount(iter->amount_at_time(t,&rising));
329 assert(amount>=0.0f);
330 assert(amount<=1.0f);
337 first=prev=(*iter->value_node)(t).get(prev);
339 ret_list.push_back(first);
344 curr=(*iter->value_node)(t).get(prev);
348 ret_list.back().set_split_tangent_flag(true);
349 ret_list.back().set_tangent2(prev.get_tangent2()*next_scale);
351 ret_list.push_back(curr);
353 ret_list.back().set_split_tangent_flag(true);
354 ret_list.back().set_tangent2(curr.get_tangent2());
355 ret_list.back().set_tangent1(curr.get_tangent1()*next_scale);
361 ret_list.push_back(curr);
369 std::vector<ListEntry>::const_iterator begin_iter,end_iter;
371 // This is where the interesting stuff happens
372 // We need to seek forward in the list to see what the next
376 BLinePoint begin; // begin of dynamic group
377 BLinePoint end; // end of dynamic group
378 int dist_from_begin(0), dist_from_end(0);
381 Time off_time, on_time;
385 try{ on_time=iter->find_prev(t)->get_time(); }
386 catch(...) { on_time=Time::begin(); }
387 try{ off_time=iter->find_next(t)->get_time(); }
388 catch(...) { off_time=Time::end(); }
392 try{ off_time=iter->find_prev(t)->get_time(); }
393 catch(...) { off_time=Time::begin(); }
394 try{ on_time=iter->find_next(t)->get_time(); }
395 catch(...) { on_time=Time::end(); }
398 curr=(*iter->value_node)(on_time).get(curr);
399 // curr=(*iter->value_node)(t).get(curr);
401 // Find "end" of dynamic group
403 // for(++end_iter;begin_iter!=list.end();++end_iter)
404 for(++end_iter;end_iter!=list.end();++end_iter)
405 if(end_iter->amount_at_time(t)>amount)
407 end=(*end_iter->value_node)(off_time).get(prev);
411 // If we did not find an end of the dynamic group...
412 if(end_iter==list.end())
417 end=(*end_iter->value_node)(off_time).get(prev);
424 end=(*end_iter->value_node)(off_time).get(prev);
429 // Find "begin" of dynamic group
431 begin.set_origin(100.0f); // set the origin to 100 (which is crazy) so that we can check to see if it was found
434 if(begin_iter==list.begin())
437 begin_iter=list.end();
448 if(begin_iter->amount_at_time(t)>amount)
450 begin=(*begin_iter->value_node)(off_time).get(prev);
453 }while(begin_iter!=iter);
455 // If we did not find a begin
456 if(begin.get_origin()==100.0f)
460 begin_iter=first_iter;
461 begin=(*begin_iter->value_node)(off_time).get(prev);
467 begin_iter=first_iter;
468 begin=(*begin_iter->value_node)(off_time).get(prev);
473 etl::hermite<Vector> curve(begin.get_vertex(),end.get_vertex(),begin.get_tangent2(),end.get_tangent1());
474 etl::derivative< etl::hermite<Vector> > deriv(curve);
476 ret.set_vertex(curve(curr.get_origin()));
478 ret.set_width((end.get_width()-begin.get_width())*curr.get_origin()+begin.get_width());
480 ret.set_tangent1(deriv(curr.get_origin()));
481 ret.set_tangent2(deriv(curr.get_origin()));
483 float prev_tangent_scalar(1.0f);
484 float next_tangent_scalar(1.0f);
486 //synfig::info("index_%d:dist_from_begin=%d",index,dist_from_begin);
487 //synfig::info("index_%d:dist_from_end=%d",index,dist_from_end);
489 // If we are the next to the begin
490 if(begin_iter==--std::vector<ListEntry>::const_iterator(iter) || dist_from_begin==1)
492 prev_tangent_scalar=(1.0f-curr.get_origin())*amount+curr.get_origin();
496 float origin=curr.get_origin()-prev.get_origin();
497 prev_tangent_scalar=(1.0f-origin)*amount+origin;
500 // If we are the next to the end
501 if(end_iter==++std::vector<ListEntry>::const_iterator(iter) || dist_from_end==1)
503 float origin=1.0-curr.get_origin();
504 next_tangent_scalar=(1.0f-origin)*amount+origin;
507 if(list.end()!=++std::vector<ListEntry>::const_iterator(iter))
510 next=((*(++std::vector<ListEntry>::const_iterator(iter))->value_node)(t).get(prev));
511 float origin=next.get_origin()-curr.get_origin();
512 next_tangent_scalar=(1.0f-origin)*amount+origin;
516 //! \todo this isn't quite right; we should handle looped blines identically no matter where the loop happens
517 //! and we currently don't. this at least makes it a lot better than it was before
518 float origin=end.get_origin()-curr.get_origin();
519 next_tangent_scalar=(1.0f-origin)*amount+origin;
521 next_scale=next_tangent_scalar;
523 //ret.set_vertex((curr.get_vertex()-ret.get_vertex())*amount+ret.get_vertex());
527 Point ref_point_begin(
529 (*begin_iter->value_node)(off_time).get(prev).get_vertex() +
530 (*end_iter->value_node)(off_time).get(prev).get_vertex()
535 (*begin_iter->value_node)(on_time).get(prev).get_vertex() +
536 (*end_iter->value_node)(on_time).get(prev).get_vertex()
541 (*begin_iter->value_node)(t).get(prev).get_vertex() +
542 (*end_iter->value_node)(t).get(prev).get_vertex()
545 Point ref_point_linear((ref_point_end-ref_point_begin)*amount+ref_point_begin);
548 (curr.get_vertex()-ret.get_vertex())*amount+ret.get_vertex() +
549 (ref_point_now-ref_point_linear)
551 ret.set_tangent1((curr.get_tangent1()-ret.get_tangent1())*amount+ret.get_tangent1());
552 ret.set_split_tangent_flag(curr.get_split_tangent_flag());
553 if(ret.get_split_tangent_flag())
554 ret.set_tangent2((curr.get_tangent2()-ret.get_tangent2())*amount+ret.get_tangent2());
560 // define 3 coordinate systems:
561 Point off_coord_sys[2], off_coord_origin; // when the current vertex is completely off
562 Point on_coord_sys[2] , on_coord_origin; // when the current vertex is completely on
563 Point curr_coord_sys[2], curr_coord_origin; // the current state - somewhere in between
565 // for each of the 3 systems, the origin is half way between the previous and next active point
566 // and the axes are based on a vector from the next active point to the previous
568 const Point end_pos_at_off_time(( *end_iter->value_node)(off_time).get(prev).get_vertex());
569 const Point begin_pos_at_off_time((*begin_iter->value_node)(off_time).get(prev).get_vertex());
570 off_coord_origin=(begin_pos_at_off_time + end_pos_at_off_time)/2;
571 off_coord_sys[0]=(begin_pos_at_off_time - end_pos_at_off_time).norm();
572 off_coord_sys[1]=off_coord_sys[0].perp();
574 const Point end_pos_at_on_time(( *end_iter->value_node)(on_time).get(prev).get_vertex());
575 const Point begin_pos_at_on_time((*begin_iter->value_node)(on_time).get(prev).get_vertex());
576 on_coord_origin=(begin_pos_at_on_time + end_pos_at_on_time)/2;
577 on_coord_sys[0]=(begin_pos_at_on_time - end_pos_at_on_time).norm();
578 on_coord_sys[1]=on_coord_sys[0].perp();
580 const Point end_pos_at_current_time(( *end_iter->value_node)(t).get(prev).get_vertex());
581 const Point begin_pos_at_current_time((*begin_iter->value_node)(t).get(prev).get_vertex());
582 curr_coord_origin=(begin_pos_at_current_time + end_pos_at_current_time)/2;
583 curr_coord_sys[0]=(begin_pos_at_current_time - end_pos_at_current_time).norm();
584 curr_coord_sys[1]=curr_coord_sys[0].perp();
587 /* The code that was here before used just end_iter as the origin, rather than the mid-point */
589 // For each of the 3 coordinate systems we've just defined, we convert a point and tangent(s) into that system
591 // Convert point where vertex is fully 'off'
592 Point trans_off_point;
593 Vector trans_off_t1,trans_off_t2;
595 Point tmp(ret.get_vertex()-off_coord_origin);
596 trans_off_point[0]=tmp*off_coord_sys[0];
597 trans_off_point[1]=tmp*off_coord_sys[1];
598 #define COORD_SYS_RADIAL_TAN_INTERP 1
600 #ifdef COORD_SYS_RADIAL_TAN_INTERP
601 tmp=ret.get_tangent1()+ret.get_vertex()-off_coord_origin;
602 trans_off_t1[0]=tmp*off_coord_sys[0];
603 trans_off_t1[1]=tmp*off_coord_sys[1];
605 if(curr.get_split_tangent_flag())
607 tmp=ret.get_tangent2()+ret.get_vertex()-off_coord_origin;
608 trans_off_t2[0]=tmp*off_coord_sys[0];
609 trans_off_t2[1]=tmp*off_coord_sys[1];
614 // Convert point where vertex is fully 'on'
615 Point trans_on_point;
616 Vector trans_on_t1,trans_on_t2;
618 Point tmp(curr.get_vertex()-on_coord_origin);
619 trans_on_point[0]=tmp*on_coord_sys[0];
620 trans_on_point[1]=tmp*on_coord_sys[1];
622 #ifdef COORD_SYS_RADIAL_TAN_INTERP
623 tmp=curr.get_tangent1()+curr.get_vertex()-on_coord_origin;
624 trans_on_t1[0]=tmp*on_coord_sys[0];
625 trans_on_t1[1]=tmp*on_coord_sys[1];
627 if(curr.get_split_tangent_flag())
629 tmp=curr.get_tangent2()+curr.get_vertex()-on_coord_origin;
630 trans_on_t2[0]=tmp*on_coord_sys[0];
631 trans_on_t2[1]=tmp*on_coord_sys[1];
636 // Convert current point
637 Point trans_curr_point;
638 Vector trans_curr_t1,trans_curr_t2;
640 // Transpose (invert)
641 swap(curr_coord_sys[0][1],curr_coord_sys[1][0]);
643 Point tmp((trans_on_point-trans_off_point)*amount+trans_off_point);
644 trans_curr_point[0]=tmp*curr_coord_sys[0];
645 trans_curr_point[1]=tmp*curr_coord_sys[1];
646 trans_curr_point+=curr_coord_origin;
648 #define INTERP_FUNCTION radial_interpolation
649 //#define INTERP_FUNCTION linear_interpolation
651 #ifdef COORD_SYS_RADIAL_TAN_INTERP
652 tmp=INTERP_FUNCTION(trans_off_t1,trans_on_t1,amount);
653 trans_curr_t1[0]=tmp*curr_coord_sys[0];
654 trans_curr_t1[1]=tmp*curr_coord_sys[1];
655 trans_curr_t1+=curr_coord_origin;
656 trans_curr_t1-=trans_curr_point;
658 if(curr.get_split_tangent_flag())
660 tmp=INTERP_FUNCTION(trans_off_t2,trans_on_t2,amount);
661 trans_curr_t2[0]=tmp*curr_coord_sys[0];
662 trans_curr_t2[1]=tmp*curr_coord_sys[1];
663 trans_curr_t2+=curr_coord_origin;
664 trans_curr_t2-=trans_curr_point;
669 ret.set_vertex(trans_curr_point);
670 #ifndef COORD_SYS_RADIAL_TAN_INTERP
671 ret.set_tangent1(radial_interpolation(ret.get_tangent1(),curr.get_tangent1(),amount));
672 ret.set_split_tangent_flag(curr.get_split_tangent_flag());
673 if(ret.get_split_tangent_flag())
674 ret.set_tangent2(radial_interpolation(ret.get_tangent2(),curr.get_tangent2(),amount));
676 ret.set_tangent1(trans_curr_t1);
677 ret.set_split_tangent_flag(curr.get_split_tangent_flag());
678 if(ret.get_split_tangent_flag())
679 ret.set_tangent2(trans_curr_t2);
683 ret.set_origin(curr.get_origin());
684 ret.set_width((curr.get_width()-ret.get_width())*amount+ret.get_width());
687 // Handle the case where we are the first vertex
690 ret.set_tangent1(ret.get_tangent1()*prev_tangent_scalar);
694 ret_list.push_back(ret);
698 ret_list.back().set_split_tangent_flag(true);
699 ret_list.back().set_tangent2(prev.get_tangent2()*prev_tangent_scalar);
700 ret_list.push_back(ret);
701 ret_list.back().set_split_tangent_flag(true);
702 //ret_list.back().set_tangent2(ret.get_tangent1());
703 ret_list.back().set_tangent1(ret.get_tangent1()*prev_tangent_scalar);
711 ret_list.back().set_split_tangent_flag(true);
712 ret_list.back().set_tangent2(prev.get_tangent2()*next_scale);
716 if(get_loop() && !first_flag)
730 synfig::warning(string("ValueNode_BLine::operator()():")+_("No entries in list"));
733 synfig::warning(string("ValueNode_BLine::operator()():")+_("No entries in ret_list"));
735 return ValueBase(ret_list,get_loop());
739 ValueNode_BLine::link_local_name(int i)const
741 assert(i>=0 && (unsigned)i<list.size());
742 return etl::strprintf(_("Vertex %03d"),i+1);
746 ValueNode_BLine::clone(const GUID& deriv_guid)const
748 { ValueNode* x(find_value_node(get_guid()^deriv_guid).get()); if(x)return x; }
750 ValueNode_BLine* ret=new ValueNode_BLine();
751 ret->set_guid(get_guid()^deriv_guid);
753 std::vector<ListEntry>::const_iterator iter;
755 for(iter=list.begin();iter!=list.end();++iter)
757 if(iter->value_node->is_exported())
761 ListEntry list_entry(*iter);
762 //list_entry.value_node=find_value_node(iter->value_node->get_guid()^deriv_guid).get();
763 //if(!list_entry.value_node)
764 list_entry.value_node=iter->value_node->clone(deriv_guid);
765 ret->add(list_entry);
766 //ret->list.back().value_node=iter->value_node.clone();
769 ret->set_loop(get_loop());
775 ValueNode_BLine::get_name()const
781 ValueNode_BLine::get_local_name()const
787 ValueNode_BLine::create_new()const
794 ValueNode_BLine::check_type(ValueBase::Type type)
796 return type==ValueBase::TYPE_LIST;